@takazudo/zudo-doc 1.2.0 → 2.0.0

package/dist/chrome/derive.d.ts

@@ -0,0 +1,68 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { JSX, VNode } from "preact";
+import type { ChromeContext, FactoryComponent } from "../factory-context/index.js";
+import type { Settings } from "../settings.js";
+import { type ColorScheme } from "../color-scheme-utils.js";
+import { createBodyEndIslands } from "../doc-body-end-islands/index.js";
+/** Package-default color scheme used when `colorSchemes` is `null` or a key is
+ *  missing. Exported so `createChrome` keeps the identical fallback. */
+export declare const DEFAULT_SCHEME: ColorScheme;
+/** Package no-op DocHistory island stub — renders an empty fragment (the
+ *  `DocHistoryComponent` contract requires a VNode, not null). */
+declare function DocHistoryStub(_props: {
+    slug: string;
+    locale?: string;
+    basePath?: string;
+}): VNode;
+/** Derive the meta-title composer from the context's site name. */
+export declare function deriveComposeMetaTitle(ctx: ChromeContext): (title: string) => string;
+/** Derive the single-scheme / light-dark CSS-property generators bound to the
+ *  context's `colorSchemes` payload (with the neutral grey-ramp fallback). */
+export declare function deriveColorSchemeGenerators(ctx: ChromeContext): {
+    generateCssCustomProperties: () => string;
+    generateLightDarkCssProperties: () => string;
+};
+/** Derive the four nav data-prep builders (root menu items, locale-switcher
+ *  links, sidebar nodes, theme default mode) bound to the context. The sidebar
+ *  builder reads `ctx.hostBindings.sidebarsConfig` (default `{}`). */
+export declare function deriveNavDataPrep(ctx: ChromeContext): {
+    buildRootMenuItems: (lang: string, currentVersion: string | undefined) => import("../nav-data-prep/index.js").RootMenuItem[];
+    buildLocaleLinksForNav: (currentPath: string, lang: string, localeCount: number) => import("../url-helpers/index.js").LocaleLink[] | undefined;
+    buildSidebarNodes: (lang: string, navSection: string | undefined, currentVersion: string | undefined, emptyWhenUnsectioned?: boolean) => import("../sidebar-utils/index.js").SidebarNavNode[];
+    getThemeDefaultMode: () => "light" | "dark" | undefined;
+};
+/** Derive the header SearchWidget: `ctx.hostBindings.SearchWidget` when the host
+ *  supplies one, else the package `SearchWidget` bound to the site base. */
+export declare function deriveSearchWidgetSlot(ctx: ChromeContext): (props: {
+    placeholderText: string;
+    shortcutHint: string;
+    resultCountTemplate: string;
+    searchLabel: string;
+    searchUnavailableText: string;
+    loadingIndexText: string;
+    noResultsText: string;
+}) => JSX.Element;
+/** Derive the body-end islands: `ctx.hostBindings.BodyEndIslands` when supplied,
+ *  else the package-island subset reconstructed from `settings`. */
+export declare function deriveBodyEndIslands(ctx: ChromeContext): ReturnType<typeof createBodyEndIslands>;
+/** Derive the DocHistory island: `ctx.hostBindings.DocHistory` when supplied,
+ *  else the package no-op stub. */
+export declare function deriveDocHistorySlot(ctx: ChromeContext): typeof DocHistoryStub;
+/** Derive the inline version-switcher builder bound to the context. */
+export declare function deriveInlineVersionSwitcher(ctx: ChromeContext): (slug: string, locale: string, currentVersion?: string) => JSX.Element | undefined;
+/**
+ * Derive the locale-aware `createMdxComponents` factory plus the
+ * `SiteTreeNavWrapper` (also exposed by `createChrome`). The nav wrappers
+ * (CategoryNav / CategoryTreeNav / SiteTreeNav) PREFER `ctx.components` — their
+ * documented allowlist — so a host can pass its exact wrapper functions and the
+ * MDX render stays byte-identical; they fall back to rebuilding from the context
+ * for the injected package path. The content overrides (Details / HtmlPreview /
+ * Island / PresetGenerator + any host extras) come from `ctx.hostBindings.mdxExtras`
+ * merged over the package defaults.
+ */
+export declare function deriveMdxComponents(ctx: ChromeContext): {
+    createMdxComponentsBound: (lang?: string) => Record<string, unknown>;
+    SiteTreeNavWrapper: FactoryComponent;
+};
+export type { Settings };

package/dist/chrome/derive.js

@@ -0,0 +1,231 @@
+import { Fragment, jsx } from "preact/jsx-runtime";
+import { createComposeMetaTitle } from "../compose-meta-title/index.js";
+import {
+  generateCssCustomProperties,
+  generateLightDarkCssProperties
+} from "../color-scheme-utils.js";
+import { createBodyEndIslands } from "../doc-body-end-islands/index.js";
+import { SearchWidget } from "../search-widget/index.js";
+import { createMdxComponents } from "../mdx-components/index.js";
+import { createCategoryNavWrapper } from "../category-nav/index.js";
+import { createCategoryTreeNavWrapper } from "../category-tree-nav/index.js";
+import { createSiteTreeNavWrapper } from "../site-tree-nav/index.js";
+import { Details } from "../details/index.js";
+import {
+  HtmlPreviewWrapper
+} from "../html-preview-wrapper/index.js";
+import { createInlineVersionSwitcher } from "../inline-version-switcher/index.js";
+import {
+  buildRootMenuItems as buildRootMenuItemsBase,
+  buildLocaleLinksForNav as buildLocaleLinksForNavBase,
+  remapVersionedHrefs,
+  getThemeDefaultMode as getThemeDefaultModeBase
+} from "../nav-data-prep/index.js";
+import { buildSidebarForSection } from "../sidebar-utils/index.js";
+const GREY_RAMP = [
+  "#000000",
+  "#1a1a1a",
+  "#333333",
+  "#4d4d4d",
+  "#666666",
+  "#808080",
+  "#999999",
+  "#b3b3b3",
+  "#cccccc",
+  "#d9d9d9",
+  "#e6e6e6",
+  "#f2f2f2",
+  "#ff5555",
+  "#50fa7b",
+  "#f1fa8c",
+  "#8be9fd"
+];
+const DEFAULT_SCHEME = {
+  background: "#000000",
+  foreground: "#ffffff",
+  cursor: "#ffffff",
+  selectionBg: "#444444",
+  selectionFg: "#ffffff",
+  palette: GREY_RAMP
+};
+function DocHistoryStub(_props) {
+  return /* @__PURE__ */ jsx(Fragment, {});
+}
+function IslandPassthrough(props) {
+  return props.children ?? null;
+}
+function deriveComposeMetaTitle(ctx) {
+  return createComposeMetaTitle(ctx.settings.siteName);
+}
+function resolveHostScheme(ctx, key) {
+  if (!ctx.colorSchemes) return DEFAULT_SCHEME;
+  return ctx.colorSchemes[key] ?? DEFAULT_SCHEME;
+}
+function deriveColorSchemeGenerators(ctx) {
+  return {
+    // Called only in single-scheme mode (colorMode false).
+    generateCssCustomProperties: () => generateCssCustomProperties(resolveHostScheme(ctx, ctx.settings.colorScheme)),
+    // Called only in light/dark mode (colorMode truthy).
+    generateLightDarkCssProperties: () => {
+      const cm = ctx.settings.colorMode;
+      if (cm) {
+        return generateLightDarkCssProperties(
+          resolveHostScheme(ctx, cm.lightScheme),
+          resolveHostScheme(ctx, cm.darkScheme)
+        );
+      }
+      return generateLightDarkCssProperties(DEFAULT_SCHEME, DEFAULT_SCHEME);
+    }
+  };
+}
+function deriveNavDataPrep(ctx) {
+  function buildRootMenuItems(lang, currentVersion) {
+    return buildRootMenuItemsBase(
+      lang,
+      currentVersion,
+      ctx.settings.headerNav,
+      (key, l) => ctx.t(key, l),
+      (path, l, v) => ctx.navHref(path, l, v)
+    );
+  }
+  function buildLocaleLinksForNav(currentPath, lang, localeCount) {
+    return buildLocaleLinksForNavBase(
+      currentPath,
+      lang,
+      localeCount,
+      (path, l) => ctx.buildLocaleLinks(path, l)
+    );
+  }
+  const sidebarsConfig = ctx.hostBindings.sidebarsConfig ?? {};
+  function buildSidebarNodes(lang, navSection, currentVersion, emptyWhenUnsectioned = true) {
+    if (navSection === void 0 && emptyWhenUnsectioned) return [];
+    const { navDocs, categoryMeta } = ctx.loadNavSourceDocs(lang, currentVersion);
+    const explicitPrefixes = ctx.getCategoryOrder().filter((cm) => cm !== "!");
+    const rawNodes = buildSidebarForSection(
+      navDocs,
+      lang,
+      navSection,
+      categoryMeta,
+      sidebarsConfig,
+      (d, l, meta) => ctx.buildNavTree(
+        d,
+        l,
+        meta,
+        (slug, loc) => ctx.docsUrl(slug, loc)
+      ),
+      explicitPrefixes
+    );
+    return currentVersion ? remapVersionedHrefs(
+      rawNodes,
+      currentVersion,
+      lang,
+      (slug, v, l) => ctx.versionedDocsUrl(slug, v, l)
+    ) : rawNodes;
+  }
+  function getThemeDefaultMode() {
+    return getThemeDefaultModeBase(ctx.settings.colorMode);
+  }
+  return { buildRootMenuItems, buildLocaleLinksForNav, buildSidebarNodes, getThemeDefaultMode };
+}
+function deriveSearchWidgetSlot(ctx) {
+  function SearchWidgetBound(props) {
+    return SearchWidget({ ...props, base: ctx.withBase("/") });
+  }
+  return ctx.hostBindings.SearchWidget ?? SearchWidgetBound;
+}
+function deriveBodyEndIslands(ctx) {
+  return ctx.hostBindings.BodyEndIslands ?? createBodyEndIslands({ settings: ctx.settings });
+}
+function deriveDocHistorySlot(ctx) {
+  return ctx.hostBindings.DocHistory ?? DocHistoryStub;
+}
+function deriveInlineVersionSwitcher(ctx) {
+  return createInlineVersionSwitcher({
+    settings: ctx.settings,
+    defaultLocale: ctx.defaultLocale,
+    t: ctx.t,
+    docsUrl: ctx.docsUrl,
+    versionedDocsUrl: ctx.versionedDocsUrl,
+    withBase: ctx.withBase
+  });
+}
+function deriveMdxComponents(ctx) {
+  const CategoryNavWrapper = ctx.components.CategoryNav ?? createCategoryNavWrapper({
+    defaultLocale: ctx.defaultLocale,
+    resolveNavSource: ctx.resolveNavSource,
+    buildNavTree: ((docs, locale, categoryMeta) => ctx.buildNavTree(
+      docs,
+      locale,
+      categoryMeta,
+      (slug, loc) => ctx.docsUrl(slug, loc)
+    )),
+    findNode: ctx.findNode,
+    firstRoutedHref: ctx.firstRoutedHref
+  });
+  const CategoryTreeNavWrapper = ctx.components.CategoryTreeNav ?? createCategoryTreeNavWrapper({
+    defaultLocale: ctx.defaultLocale,
+    resolveNavSource: ctx.resolveNavSource,
+    buildNavTree: ((docs, locale, categoryMeta) => ctx.buildNavTree(
+      docs,
+      locale,
+      categoryMeta,
+      (slug, loc) => ctx.docsUrl(slug, loc)
+    )),
+    groupSatelliteNodes: ctx.groupSatelliteNodes,
+    findNode: ctx.findNode
+  });
+  const SiteTreeNavWrapper = ctx.components.SiteTreeNav ?? createSiteTreeNavWrapper({
+    defaultLocale: ctx.defaultLocale,
+    resolveNavSource: ctx.resolveNavSource,
+    buildNavTree: ((docs, locale, categoryMeta) => ctx.buildNavTree(
+      docs,
+      locale,
+      categoryMeta,
+      (slug, loc) => ctx.docsUrl(slug, loc)
+    )),
+    groupSatelliteNodes: ctx.groupSatelliteNodes,
+    getCategoryOrder: ctx.getCategoryOrder
+  });
+  function HtmlPreviewBound(props) {
+    return HtmlPreviewWrapper({
+      globalConfig: ctx.settings.htmlPreview ?? null,
+      ...props
+    });
+  }
+  const mdxExtrasDefault = {
+    Details,
+    HtmlPreview: HtmlPreviewBound,
+    Island: IslandPassthrough,
+    // PresetGenerator stays a package stub (render nothing): it is the
+    // showcase's project-bound interactive island; downstream projects stub it.
+    PresetGenerator: (_props) => null
+  };
+  const mdxExtras = { ...mdxExtrasDefault, ...ctx.hostBindings.mdxExtras ?? {} };
+  function createMdxComponentsBound(lang = ctx.defaultLocale) {
+    return createMdxComponents({
+      settings: ctx.settings,
+      locale: lang,
+      navData: {
+        CategoryNav: CategoryNavWrapper,
+        CategoryTreeNav: CategoryTreeNavWrapper,
+        SiteTreeNav: SiteTreeNavWrapper
+      },
+      // Package-owned content components wired here so an INJECTED docs route
+      // renders MDX using these tags without the "MDX requires '<X>' to be
+      // passed via the 'components' prop" error.
+      extras: mdxExtras
+    });
+  }
+  return { createMdxComponentsBound, SiteTreeNavWrapper };
+}
+export {
+  DEFAULT_SCHEME,
+  deriveBodyEndIslands,
+  deriveColorSchemeGenerators,
+  deriveComposeMetaTitle,
+  deriveDocHistorySlot,
+  deriveInlineVersionSwitcher,
+  deriveMdxComponents,
+  deriveNavDataPrep,
+  deriveSearchWidgetSlot
+};

package/dist/chrome/index.d.ts

@@ -0,0 +1,37 @@
+/** @jsxRuntime automatic */
+/** @jsxImportSource preact */
+import type { RouteContext, ChromeHostBindings } from "../factory-context/index.js";
+import type { Settings } from "../settings.js";
+/**
+ * Build the wired page-chrome factories from a reconstructed route context plus
+ * the host-bound slots. Assembles a {@link ChromeContext} (route context +
+ * empty `components` allowlist + the passed `hostBindings`) and threads it
+ * through each top-level factory; every omitted `hostBindings` slot falls back
+ * to the package stub default inside the factories, reproducing the injected
+ * package-routes path byte-for-byte.
+ */
+export declare function createChrome<S extends Settings = Settings>(context: RouteContext<S>, hostBindings?: ChromeHostBindings): {
+    composeMetaTitle: (title: string) => string;
+    HeadWithDefaults: (props: import("../head-with-defaults/index.js").HeadWithDefaultsProps) => import("preact").JSX.Element;
+    HeaderWithDefaults: (props: import("../header-with-defaults/index.js").HeaderWithDefaultsProps) => import("preact").JSX.Element;
+    FooterWithDefaults: (props: {
+        lang?: string;
+    }) => import("preact").VNode;
+    SidebarWithDefaults: (props: import("../sidebar-with-defaults/index.js").SidebarWithDefaultsProps) => import("preact").JSX.Element;
+    renderDocPage: (props: import("../doc-page-props/index.js").DocPageBaseProps, opts: import("../doc-page-renderer/index.js").RenderDocPageOptions) => import("preact").JSX.Element;
+    VersionsPageView: (props: import("../versions-page/index.js").VersionsPageViewProps) => import("preact").JSX.Element;
+    collectTagMapForLocale: (locale: string) => Map<string, import("../tag-pages/index.js").TagInfo>;
+    TagDetailPageView: (props: {
+        locale: string;
+        tag: string;
+        tagInfo: import("../tag-pages/index.js").TagInfo;
+    }) => import("preact").JSX.Element;
+    TagsIndexPageView: (props: {
+        locale: string;
+        children?: import("preact").ComponentChildren;
+    }) => import("preact").JSX.Element;
+    SiteTreeNavWrapper: import("../factory-context/index.js").FactoryComponent;
+    BodyEndIslands: (props: import("../doc-body-end-islands/index.js").BodyEndIslandsProps) => import("preact").JSX.Element;
+};
+/** The wired page-chrome surface returned by {@link createChrome}. */
+export type Chrome = ReturnType<typeof createChrome>;

package/dist/chrome/index.js

@@ -0,0 +1,43 @@
+import { createHeadWithDefaults } from "../head-with-defaults/index.js";
+import { createHeaderWithDefaults } from "../header-with-defaults/index.js";
+import { createFooterWithDefaults } from "../footer-with-defaults/index.js";
+import { createSidebarWithDefaults } from "../sidebar-with-defaults/index.js";
+import { createRenderDocPage } from "../doc-page-renderer/index.js";
+import { createVersionsPageView } from "../versions-page/index.js";
+import { createTagPages } from "../tag-pages/index.js";
+import {
+  deriveComposeMetaTitle,
+  deriveBodyEndIslands,
+  deriveMdxComponents
+} from "./derive.js";
+function createChrome(context, hostBindings = {}) {
+  const components = {};
+  const ctx = { ...context, components, hostBindings };
+  const composeMetaTitle = deriveComposeMetaTitle(ctx);
+  const HeadWithDefaults = createHeadWithDefaults(ctx);
+  const HeaderWithDefaults = createHeaderWithDefaults(ctx);
+  const FooterWithDefaults = createFooterWithDefaults(ctx);
+  const SidebarWithDefaults = createSidebarWithDefaults(ctx);
+  const renderDocPage = createRenderDocPage(ctx);
+  const VersionsPageView = createVersionsPageView(ctx);
+  const { collectTagMapForLocale, TagDetailPageView, TagsIndexPageView } = createTagPages(ctx);
+  const { SiteTreeNavWrapper } = deriveMdxComponents(ctx);
+  const BodyEndIslands = deriveBodyEndIslands(ctx);
+  return {
+    composeMetaTitle,
+    HeadWithDefaults,
+    HeaderWithDefaults,
+    FooterWithDefaults,
+    SidebarWithDefaults,
+    renderDocPage,
+    VersionsPageView,
+    collectTagMapForLocale,
+    TagDetailPageView,
+    TagsIndexPageView,
+    SiteTreeNavWrapper,
+    BodyEndIslands
+  };
+}
+export {
+  createChrome
+};

package/dist/content.css

@@ -271,19 +271,22 @@
  * rules must live here explicitly. Closes zudolab/zudo-doc#1357 / #1444 / #1456.
  *
  * Spacing: the box carries NO margin — the separating gap to the next block is
- * supplied by that block's flow-space `margin-top` (the owl rule above). The
- * snug bottom padding keeps the body tight inside the box without inflating
- * that gap. (A missing bottom margin on the box is intentional in the flow
- * model — do NOT add one; see zudolab/zudo-doc#2188 for why the per-element
- * margin model that needed it was retired.)
+ * supplied by that block's flow-space `margin-top` (the page owl above). Blocks
+ * INSIDE `.admonition-body` get their own shorter flow gap (vsp-sm) via the
+ * nested owl below, since the page owl only reaches direct children of
+ * `.zd-content`; the box's vsp-sm bottom padding then gives the last block room
+ * so it isn't cramped against the edge. (A missing bottom margin on the box is
+ * intentional in the flow model — do NOT add one; see zudolab/zudo-doc#2188 for
+ * why the per-element margin model that needed it was retired.)
  * ======================================== */
 
 [data-admonition] {
   border-left: 4px solid var(--color-muted);
-  /* Asymmetric padding mirrors the Astro reference (`pt-vsp-md pb-vsp-2xs`) —
-   * generous space at the top, snug at the bottom — so the title row sits
-   * under generous breathing room without inflating the bottom gap. */
-  padding: var(--spacing-vsp-md) var(--spacing-hsp-lg) var(--spacing-vsp-2xs);
+  /* Generous top padding gives the title row breathing room; the bottom uses
+   * the same vsp-sm as the body inner flow (below) so the last block isn't
+   * cramped against the box edge. (Was pb-vsp-2xs — too tight once the body
+   * has multiple flowed blocks; zudolab/zudo-doc#2417.) */
+  padding: var(--spacing-vsp-md) var(--spacing-hsp-lg) var(--spacing-vsp-sm);
   background-color: color-mix(in srgb, var(--color-muted) 12%, var(--color-bg));
   border-radius: 0 var(--radius-DEFAULT) var(--radius-DEFAULT) 0;
 }
@@ -301,6 +304,19 @@
   margin-right: var(--spacing-hsp-2xs);
 }
 
+/* Flow spacing between blocks INSIDE an admonition body. The page-level
+ * `.zd-content > * + *` owl only reaches direct children of `.zd-content`, so
+ * nested blocks here had no inter-element gap (zudolab/zudo-doc#2417). The
+ * admonition is a narrower scope than the page flow, so a shorter gap
+ * (vsp-sm < the page's vsp-md) reads as natural. Layered in `zd-flow` for the
+ * same reason as the page owl: it must beat preflight's `* { margin: 0 }` but
+ * lose to an unlayered `mt-*` utility on a nested block. */
+@layer zd-flow {
+  .admonition-body > :where(* + *) {
+    margin-top: var(--spacing-vsp-sm);
+  }
+}
+
 .admonition-body > :first-child {
   margin-top: 0;
 }

package/dist/doc-body-end/index.d.ts

@@ -1,21 +1,19 @@
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
 import type { JSX } from "preact";
+import type { ChromeContext } from "../factory-context/index.js";
+import type { Settings } from "../settings.js";
 /** Settings subset read by the DocBodyEnd factory. */
 export interface DocBodyEndSettings {
     base?: string | null;
     sidebarResizer: boolean;
 }
-/** Dependencies injected by the host stub. */
-export interface DocBodyEndDeps {
-    settings: DocBodyEndSettings;
-    /** The `BodyEndIslands` component (host-side — reads additional settings). */
-    BodyEndIslands: (props: {
-        basePath: string;
-    }) => JSX.Element;
-}
 /**
- * Create a `DocBodyEnd` component bound to the host's settings and
- * BodyEndIslands component.
+ * Create a `DocBodyEnd` component from the unified {@link ChromeContext}
+ * (epic Collapse Wiring Shells #2420, FACTORIES #2424 — breaking signature).
+ *
+ * Reads `settings` directly; the `BodyEndIslands` block is a HOST-bound slot
+ * (`ctx.hostBindings.BodyEndIslands`) that defaults to the package-island subset
+ * reconstructed from `settings` (no host-only client-router / token-panel boots).
  */
-export declare function createDocBodyEnd(deps: DocBodyEndDeps): () => JSX.Element;
+export declare function createDocBodyEnd<S extends Settings = Settings>(ctx: ChromeContext<S>): () => JSX.Element;

package/dist/doc-body-end/index.js

@@ -1,7 +1,9 @@
 import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
 import { SidebarResizerInit } from "../sidebar-resizer/index.js";
-function createDocBodyEnd(deps) {
-  const { settings, BodyEndIslands } = deps;
+import { deriveBodyEndIslands } from "../chrome/derive.js";
+function createDocBodyEnd(ctx) {
+  const settings = ctx.settings;
+  const BodyEndIslands = deriveBodyEndIslands(ctx);
   function DocBodyEnd() {
     return /* @__PURE__ */ jsxs(Fragment, { children: [
       /* @__PURE__ */ jsx(BodyEndIslands, { basePath: settings.base ?? "/" }),

package/dist/doc-content-header/index.d.ts

@@ -3,6 +3,8 @@
 import type { JSX } from "preact";
 import { type FrontmatterCellRenderer } from "../metainfo/index.js";
 import type { DocPageEntry } from "../doc-page-props/index.js";
+import type { ChromeContext } from "../factory-context/index.js";
+import type { Settings } from "../settings.js";
 export type { FrontmatterCellRenderer };
 /** Dependencies injected by the host stub. */
 export interface DocContentHeaderDeps {
@@ -64,6 +66,12 @@ interface DocContentHeaderProps {
     version?: string;
 }
 /**
- * Create a `DocContentHeader` component bound to the host's injected context.
+ * Create a `DocContentHeader` component from the unified {@link ChromeContext}
+ * (epic Collapse Wiring Shells #2420, FACTORIES #2424 — breaking signature).
+ *
+ * Reads `t` directly; the frontmatter-preview entry builder + per-key renderers
+ * are HOST-bound slots (`ctx.hostBindings.buildFrontmatterPreviewEntries` /
+ * `…frontmatterRenderers`, defaulting to `() => []` / `{}`). The nested
+ * `DocMetainfoArea` / `DocTagsArea` are rebuilt from the same context.
  */
-export declare function createDocContentHeader(deps: DocContentHeaderDeps): (props: DocContentHeaderProps) => JSX.Element;
+export declare function createDocContentHeader<S extends Settings = Settings>(ctx: ChromeContext<S>): (props: DocContentHeaderProps) => JSX.Element;

package/dist/doc-content-header/index.js

@@ -1,13 +1,13 @@
 import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
 import { FrontmatterPreview } from "../metainfo/index.js";
-function createDocContentHeader(deps) {
-  const {
-    t,
-    buildFrontmatterPreviewEntries,
-    frontmatterRenderers,
-    DocMetainfoArea,
-    DocTagsArea
-  } = deps;
+import { createDocMetainfoArea } from "../doc-metainfo-area/index.js";
+import { createDocTagsArea } from "../doc-tags-area/index.js";
+function createDocContentHeader(ctx) {
+  const t = ctx.t;
+  const buildFrontmatterPreviewEntries = ctx.hostBindings.buildFrontmatterPreviewEntries ?? (() => []);
+  const frontmatterRenderers = ctx.hostBindings.frontmatterRenderers ?? {};
+  const DocMetainfoArea = createDocMetainfoArea(ctx);
+  const DocTagsArea = createDocTagsArea(ctx);
   function DocContentHeader({
     entry,
     slug,

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

@@ -1,6 +1,8 @@
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
 import type { VNode } from "preact";
+import type { ChromeContext } from "../factory-context/index.js";
+import type { Settings } from "../settings.js";
 /** Per-entry metadata shape from the doc-history manifest. */
 export interface DocHistoryMetaEntry {
     author: string;
@@ -26,28 +28,6 @@ export type DocHistoryComponent = (props: {
     locale?: string;
     basePath?: string;
 }) => VNode;
-/** Dependencies injected by the host stub. */
-export interface DocHistoryAreaDeps {
-    settings: DocHistoryAreaSettings;
-    /** Default locale code (e.g. "en"). */
-    defaultLocale: string;
-    /** The parsed `#doc-history-meta` JSON manifest (host-side import). */
-    docHistoryMeta: Record<string, DocHistoryMetaEntry>;
-    /** Translate a UI string key for a locale. */
-    t: (key: string, locale: string) => string;
-    /** Convert a canonical route slug to a history slug (sentinel: "" → "index"). */
-    toHistorySlug: (slug: string) => string;
-    /**
-     * Build a view-source GitHub URL, or null when githubUrl is not set.
-     * Host passes a partially applied version binding `settings.githubUrl`.
-     */
-    buildGitHubSourceUrl: (contentDir: string, entryId: string) => string | null;
-    /**
-     * The DocHistory island component (host-side — must be imported in the stub so
-     * zfb's scanner walks page → stub → DocHistory).
-     */
-    DocHistory: DocHistoryComponent;
-}
 export interface DocHistoryAreaProps {
     /** Page slug, e.g. "getting-started/intro". */
     slug: string;
@@ -78,7 +58,12 @@ export interface DocHistoryAreaProps {
     isFallback?: boolean;
 }
 /**
- * Create a `DocHistoryArea` component bound to the host's settings and
- * injected dependencies.
+ * Create a `DocHistoryArea` component from the unified {@link ChromeContext}
+ * (epic Collapse Wiring Shells #2420, FACTORIES #2424 — breaking signature).
+ *
+ * Reads `settings`/`defaultLocale`/`t` directly, `toHistorySlug` from the slug
+ * helper, and binds `buildGitHubSourceUrl` to `settings.githubUrl`. The
+ * DocHistory island is a HOST-bound slot (`ctx.hostBindings.DocHistory`,
+ * default: a no-op stub rendering an empty fragment).
  */
-export declare function createDocHistoryArea(deps: DocHistoryAreaDeps): (props: DocHistoryAreaProps) => VNode | null;
+export declare function createDocHistoryArea<S extends Settings = Settings>(ctx: ChromeContext<S>): (props: DocHistoryAreaProps) => VNode | null;

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

@@ -1,16 +1,20 @@
 import { jsx, jsxs } from "preact/jsx-runtime";
 import { Island } from "@takazudo/zfb";
 import { BodyFootUtilArea } from "../body-foot-util/index.js";
-function createDocHistoryArea(deps) {
-  const {
-    settings,
-    defaultLocale,
-    docHistoryMeta,
-    t,
-    toHistorySlug,
-    buildGitHubSourceUrl,
-    DocHistory
-  } = deps;
+import { toHistorySlug } from "../slug/index.js";
+import { buildGitHubSourceUrl as buildGitHubSourceUrlBase } from "../github-helpers/index.js";
+import { deriveDocHistorySlot } from "../chrome/derive.js";
+function createDocHistoryArea(ctx) {
+  const settings = ctx.settings;
+  const defaultLocale = ctx.defaultLocale;
+  const docHistoryMeta = ctx.hostBindings.docHistoryMeta ?? {};
+  const t = ctx.t;
+  const buildGitHubSourceUrl = (contentDir, entryId) => buildGitHubSourceUrlBase(
+    ctx.settings.githubUrl,
+    contentDir,
+    entryId
+  );
+  const DocHistory = deriveDocHistorySlot(ctx);
   DocHistory.displayName = "DocHistory";
   function DocHistoryArea({
     slug,

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

@@ -1,6 +1,8 @@
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
 import type { VNode } from "preact";
+import type { ChromeContext } from "../factory-context/index.js";
+import type { Settings } from "../settings.js";
 /** Per-entry metadata shape from the doc-history manifest. */
 export interface DocHistoryMetaEntry {
     author: string;
@@ -11,18 +13,6 @@ export interface DocHistoryMetaEntry {
 export interface DocMetainfoAreaSettings {
     docMetainfo: boolean;
 }
-/** Dependencies injected by the host stub. */
-export interface DocMetainfoAreaDeps {
-    settings: DocMetainfoAreaSettings;
-    /** Default locale code (e.g. "en"). */
-    defaultLocale: string;
-    /** The parsed `#doc-history-meta` JSON manifest (host-side import). */
-    docHistoryMeta: Record<string, DocHistoryMetaEntry>;
-    /** Translate a UI string key for a locale. */
-    t: (key: string, locale: string) => string;
-    /** Convert a canonical route slug to a history slug (sentinel: "" → "index"). */
-    toHistorySlug: (slug: string) => string;
-}
 export interface DocMetainfoAreaProps {
     /** Page slug, e.g. "getting-started/intro". */
     slug: string;
@@ -40,7 +30,11 @@ export interface DocMetainfoAreaProps {
     isFallback?: boolean;
 }
 /**
- * Create a `DocMetainfoArea` component bound to the host's settings and
- * injected dependencies.
+ * Create a `DocMetainfoArea` component from the unified {@link ChromeContext}
+ * (epic Collapse Wiring Shells #2420, FACTORIES #2424 — breaking signature).
+ *
+ * Reads `settings`/`defaultLocale`/`t` directly and `toHistorySlug` from the
+ * package slug helper; the per-page git-history manifest is a HOST-bound slot
+ * (`ctx.hostBindings.docHistoryMeta`, default `{}` → no Created/Updated block).
  */
-export declare function createDocMetainfoArea(deps: DocMetainfoAreaDeps): (props: DocMetainfoAreaProps) => VNode | null;
+export declare function createDocMetainfoArea<S extends Settings = Settings>(ctx: ChromeContext<S>): (props: DocMetainfoAreaProps) => VNode | null;