@takazudo/zudo-doc 5.28.2 → 6.0.1

package/dist/design-token-panel-bootstrap-controller.js

@@ -0,0 +1,359 @@
+import {
+  DEFAULT_STORAGE_PREFIX,
+  DEFAULT_TOGGLE_EVENT,
+  EAGER_LOAD_GATE_KEY_SUFFIXES,
+  EAGER_LOAD_GATE_STATE_FAMILY,
+  resolveToggleEventName
+} from "./design-token-panel-constants.js";
+import {
+  BEFORE_NAVIGATE_EVENT,
+  AFTER_NAVIGATE_EVENT
+} from "./transitions/page-events.js";
+import {
+  DEFAULT_THEME_PACK_SLUG,
+  THEME_PACK_CHANGED_EVENT,
+  readThemePackFromDom
+} from "./theme-pack-switcher/theme-pack-sync.js";
+const COLOR_SCHEME_CHANGED_EVENT = "color-scheme-changed";
+function openStateKey(instancePrefix) {
+  return `${instancePrefix}-open`;
+}
+function readOpenState(instancePrefix) {
+  try {
+    return localStorage.getItem(openStateKey(instancePrefix)) === "1";
+  } catch {
+    return false;
+  }
+}
+function isEmptyEnvelope(raw) {
+  if (raw === null || raw === "") return true;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return false;
+  }
+  if (parsed === null) return true;
+  if (Array.isArray(parsed)) return parsed.length === 0;
+  if (typeof parsed === "object") return Object.keys(parsed).length === 0;
+  return false;
+}
+function hasPersistedPanelState(config) {
+  const instancePrefix = config.storagePrefix ?? DEFAULT_STORAGE_PREFIX;
+  try {
+    for (const [suffix, gate] of Object.entries(EAGER_LOAD_GATE_KEY_SUFFIXES)) {
+      if (gate.requiredConfig !== null && config[gate.requiredConfig] === void 0) {
+        continue;
+      }
+      const value = localStorage.getItem(`${instancePrefix}${suffix}`);
+      if (suffix === ":autoload" && value !== "1") continue;
+      if (gate.acceptedValues.some((accepted) => accepted === value)) return true;
+    }
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key === null || !EAGER_LOAD_GATE_STATE_FAMILY.matchesKey(instancePrefix, key)) {
+        continue;
+      }
+      if (!isEmptyEnvelope(localStorage.getItem(key))) return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function readMode() {
+  return document.documentElement.getAttribute("data-theme") === "dark" ? "dark" : "light";
+}
+function withPackScopedStoragePrefix(config, activePack) {
+  if (activePack === DEFAULT_THEME_PACK_SLUG) return config;
+  return { ...config, storagePrefix: `${config.storagePrefix}--${activePack}` };
+}
+function collectDeclaredTokenNames(config) {
+  const names = [];
+  for (const tab of config.tabs ?? []) {
+    for (const tier of tab.tiers ?? []) {
+      for (const item of tier.items ?? []) {
+        names.push(item.cssVar);
+      }
+    }
+    const baseRoles = tab.colorExtras?.baseRoles;
+    if (baseRoles) {
+      for (const cssVar of Object.values(baseRoles)) {
+        if (typeof cssVar === "string" && cssVar.length > 0) {
+          names.push(cssVar);
+        }
+      }
+    }
+  }
+  return names;
+}
+function clearAppliedTokenOverrides(config) {
+  const names = collectDeclaredTokenNames(config);
+  if (config.applySink) {
+    try {
+      config.applySink.clear(names);
+    } catch (err) {
+      console.warn(
+        "[zudo-doc] applySink.clear threw during theme-pack switch; outgoing overrides may linger.",
+        err
+      );
+    }
+    return;
+  }
+  const style = document.documentElement.style;
+  for (const name of names) {
+    style.removeProperty(name);
+  }
+}
+function bootstrapDesignTokenPanel(buildConfig) {
+  bootstrapDesignTokenPanelForScope(buildConfig);
+}
+function bootstrapDesignTokenPanelForScope(buildConfig, activationSignal, onConfigured) {
+  if (activationSignal?.aborted) return;
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return;
+  }
+  let zdtpImport = null;
+  let activationInFlight = false;
+  let configurePhase = "pending";
+  const pendingListenerCleanups = [];
+  let pendingListenersRetained = false;
+  function removePendingListeners() {
+    if (pendingListenersRetained) return;
+    pendingListenersRetained = true;
+    for (const cleanup of pendingListenerCleanups.splice(0).reverse()) cleanup();
+    activationSignal?.removeEventListener("abort", onActivationAbort);
+  }
+  function retainDocumentListeners() {
+    pendingListenersRetained = true;
+    pendingListenerCleanups.length = 0;
+    activationSignal?.removeEventListener("abort", onActivationAbort);
+  }
+  function addPendingListener(target, type, listener) {
+    target.addEventListener(type, listener);
+    pendingListenerCleanups.push(() => target.removeEventListener(type, listener));
+  }
+  function onActivationAbort() {
+    if (configurePhase !== "pending") return;
+    removePendingListeners();
+    activationInFlight = false;
+  }
+  activationSignal?.addEventListener("abort", onActivationAbort, { once: true });
+  let pendingToggles = 0;
+  function loadZdtp() {
+    if (zdtpImport === null) {
+      zdtpImport = import("@takazudo/zudo-doc/zdtp-loader").catch((err) => {
+        zdtpImport = null;
+        throw err;
+      });
+    }
+    return zdtpImport;
+  }
+  function configureAndWire(zdtp) {
+    const {
+      configurePanelIfActive,
+      configurePanel,
+      reapplyPersistedOverrides,
+      setLifecycleAdapter,
+      showDesignTokenPanel
+    } = zdtp;
+    let currentConfig = withPackScopedStoragePrefix(
+      buildConfig(readMode()),
+      readThemePackFromDom()
+    );
+    const initialHandle = configurePanelIfActive(
+      activationSignal,
+      currentConfig
+    );
+    if (!initialHandle) return false;
+    let handle = initialHandle;
+    if (activationSignal?.aborted) {
+      handle.destroy();
+      return false;
+    }
+    let pendingMode = readMode();
+    let timer = null;
+    addPendingListener(window, COLOR_SCHEME_CHANGED_EVENT, () => {
+      pendingMode = readMode();
+      if (timer !== null) return;
+      timer = setTimeout(() => {
+        timer = null;
+        const mode = pendingMode;
+        const wasOpen = readOpenState(handle.instanceId);
+        handle.destroy();
+        currentConfig = withPackScopedStoragePrefix(
+          buildConfig(mode),
+          readThemePackFromDom()
+        );
+        handle = configurePanel(currentConfig);
+        if (wasOpen) showDesignTokenPanel();
+      }, 0);
+    });
+    let pendingPack = readThemePackFromDom();
+    let packTimer = null;
+    pendingListenerCleanups.push(() => {
+      if (timer !== null) clearTimeout(timer);
+      if (packTimer !== null) clearTimeout(packTimer);
+    });
+    addPendingListener(window, THEME_PACK_CHANGED_EVENT, () => {
+      pendingPack = readThemePackFromDom();
+      if (packTimer !== null) return;
+      packTimer = setTimeout(() => {
+        packTimer = null;
+        const pack = pendingPack;
+        const wasOpen = readOpenState(handle.instanceId);
+        const outgoingConfig = currentConfig;
+        handle.destroy();
+        clearAppliedTokenOverrides(outgoingConfig);
+        currentConfig = withPackScopedStoragePrefix(buildConfig(readMode()), pack);
+        handle = configurePanel(currentConfig);
+        reapplyPersistedOverrides();
+        if (wasOpen) showDesignTokenPanel();
+      }, 0);
+    });
+    if (activationSignal?.aborted) {
+      handle.destroy();
+      return false;
+    }
+    reapplyPersistedOverrides();
+    const adapter = {
+      onBeforeSwap(cb) {
+        const handler = () => cb();
+        document.addEventListener(BEFORE_NAVIGATE_EVENT, handler);
+        return () => document.removeEventListener(BEFORE_NAVIGATE_EVENT, handler);
+      },
+      onPageLoad(cb) {
+        const handler = () => cb();
+        document.addEventListener(AFTER_NAVIGATE_EVENT, handler);
+        return () => document.removeEventListener(AFTER_NAVIGATE_EVENT, handler);
+      }
+    };
+    if (activationSignal?.aborted) {
+      handle.destroy();
+      return false;
+    }
+    setLifecycleAdapter(adapter);
+    return true;
+  }
+  async function activate() {
+    if (activationSignal?.aborted) {
+      removePendingListeners();
+      return;
+    }
+    if (activationInFlight || configurePhase !== "pending") return;
+    activationInFlight = true;
+    let zdtp;
+    try {
+      zdtp = await loadZdtp();
+    } catch (err) {
+      activationInFlight = false;
+      if (activationSignal?.aborted) return;
+      pendingToggles = 0;
+      console.error(
+        "[zudo-doc] design-token-panel: loading @takazudo/zdtp failed; the next toggle retries.",
+        err
+      );
+      return;
+    }
+    if (activationSignal?.aborted) {
+      activationInFlight = false;
+      removePendingListeners();
+      return;
+    }
+    try {
+      if (!configureAndWire(zdtp)) {
+        if (activationSignal?.aborted) removePendingListeners();
+        return;
+      }
+      configurePhase = "configured";
+      onConfigured?.();
+      retainDocumentListeners();
+    } catch (err) {
+      configurePhase = "failed";
+      removePendingListeners();
+      console.error(
+        "[zudo-doc] design-token-panel: configure failed; the panel is disabled until the next full page load.",
+        err
+      );
+      return;
+    } finally {
+      activationInFlight = false;
+    }
+    if (!activationSignal?.aborted && pendingToggles % 2 === 1) {
+      zdtp.showDesignTokenPanel();
+    }
+    pendingToggles = 0;
+  }
+  function readActiveConfig() {
+    return withPackScopedStoragePrefix(
+      buildConfig(readMode()),
+      readThemePackFromDom()
+    );
+  }
+  const onInterimToggle = () => {
+    if (configurePhase !== "pending") return;
+    pendingToggles += 1;
+    void activate();
+  };
+  const boundToggleChannels = /* @__PURE__ */ new Set();
+  let instanceToggleChannel = null;
+  function bindToggleChannel(name) {
+    if (boundToggleChannels.has(name)) return;
+    boundToggleChannels.add(name);
+    addPendingListener(window, name, onInterimToggle);
+  }
+  function refreshInstanceToggleChannel(config) {
+    const resolved = resolveToggleEventName(config);
+    if (resolved === instanceToggleChannel) return;
+    if (instanceToggleChannel !== null && instanceToggleChannel !== DEFAULT_TOGGLE_EVENT) {
+      window.removeEventListener(instanceToggleChannel, onInterimToggle);
+      boundToggleChannels.delete(instanceToggleChannel);
+    }
+    instanceToggleChannel = resolved;
+    bindToggleChannel(resolved);
+  }
+  const bootConfig = readActiveConfig();
+  bindToggleChannel(DEFAULT_TOGGLE_EVENT);
+  refreshInstanceToggleChannel(bootConfig);
+  window.__zdtpReadyClicks?.();
+  if (hasPersistedPanelState(bootConfig)) void activate();
+  addPendingListener(window, THEME_PACK_CHANGED_EVENT, () => {
+    if (configurePhase !== "pending") return;
+    const activeConfig = readActiveConfig();
+    refreshInstanceToggleChannel(activeConfig);
+    if (hasPersistedPanelState(activeConfig)) void activate();
+  });
+  addPendingListener(window, COLOR_SCHEME_CHANGED_EVENT, () => {
+    if (configurePhase !== "pending") return;
+    refreshInstanceToggleChannel(readActiveConfig());
+  });
+}
+let bootstrapWinner = null;
+let warnedLostRace = false;
+function warnLostBootstrapRace(winnerOrigin, loserOrigin) {
+  if (typeof window === "undefined" || warnedLostRace) return;
+  warnedLostRace = true;
+  const detail = loserOrigin === "configured" && winnerOrigin === "default" ? "The package-default island configured the panel earlier in this browser session, so `designTokenPanelConfigModule` did not apply on this page. This happens when the session first hard-loaded a page rendered by a self-contained `pages/` stub, which reaches the package default instead of the package-injected route. Thread your builder through `chromeBindings.DesignTokenPanelBootstrap` to make it apply on every page regardless of entry point." : `The ${winnerOrigin} island configured the panel first; this ${loserOrigin} island's builder was ignored. zdtp is configured once per session \u2014 mount exactly one design-token-panel bootstrap, e.g. via \`chromeBindings.DesignTokenPanelBootstrap\`.`;
+  console.warn(`[zudo-doc] design-token panel already configured. ${detail}`);
+}
+function runDesignTokenPanelBootstrapOnce(build, origin = "default", activationSignal) {
+  if (activationSignal?.aborted) return;
+  if (bootstrapWinner) {
+    if (bootstrapWinner.build !== build) warnLostBootstrapRace(bootstrapWinner.origin, origin);
+    return;
+  }
+  const winner = { origin, build, configured: false };
+  bootstrapWinner = winner;
+  const releasePendingClaim = () => {
+    if (!winner.configured && bootstrapWinner === winner) bootstrapWinner = null;
+  };
+  activationSignal?.addEventListener("abort", releasePendingClaim, { once: true });
+  bootstrapDesignTokenPanelForScope(build, activationSignal, () => {
+    winner.configured = true;
+    activationSignal?.removeEventListener("abort", releasePendingClaim);
+  });
+}
+export {
+  bootstrapDesignTokenPanel,
+  runDesignTokenPanelBootstrapOnce,
+  withPackScopedStoragePrefix
+};

package/dist/design-token-panel-bootstrap-island.d.ts

@@ -0,0 +1,5 @@
+/** Package-default island; zdtp owns the opaque Preact UI it mounts. */
+export declare function DesignTokenPanelBootstrap(): null;
+export declare namespace DesignTokenPanelBootstrap {
+    var displayName: string;
+}

package/dist/design-token-panel-bootstrap-island.js

@@ -0,0 +1,19 @@
+"use client";
+import { getScope } from "@takazudo/zfb/zudo-react";
+import { buildDesignTokenPanelConfig } from "./design-token-panel-config/index.js";
+import { runDesignTokenPanelBootstrapOnce } from "./design-token-panel-bootstrap-controller.js";
+function DesignTokenPanelBootstrap() {
+  const scope = getScope();
+  scope.onActivate(() => {
+    runDesignTokenPanelBootstrapOnce(
+      buildDesignTokenPanelConfig,
+      "default",
+      scope.abortSignal
+    );
+  });
+  return null;
+}
+DesignTokenPanelBootstrap.displayName = "DesignTokenPanelBootstrap";
+export {
+  DesignTokenPanelBootstrap
+};

package/dist/design-token-panel-bootstrap.d.ts

@@ -1,197 +1,7 @@
-/** @jsxRuntime automatic */
-/** @jsxImportSource preact */
 /**
- * Design-token panel (zdtp) WIRING MECHANISM + PACKAGE-DEFAULT ISLAND (#2658,
- * epic Minimal Scaffold #2651). zdtp itself is LAZY-LOADED (#3282, epic
- * #3261): this module carries NO top-level value import of `@takazudo/zdtp`
- * whatsoever. It used to eagerly import the side-effect-free `/constants` leaf;
- * since #4018 those constants come from the in-package mirror
- * `./design-token-panel-constants.js`, because that one static edge made an
- * OPTIONAL peer a hard build-time requirement for every chrome consumer
- * (#4009 — see that module's header).
- * The root package is `import()`ed on the first dispatch on either resolved
- * toggle channel (the shared `toggle-design-token-panel`, or this instance's own —
- * see the public 0.5 {@link resolveToggleEventName}), or eagerly when the
- * persisted-state probe finds saved tweaks / a previously-open panel, so zdtp's bundle stays
- * out of the initial page load.
- *
- * `bootstrapDesignTokenPanel` is a callable that configures zdtp's panel and
- * wires its lifecycle hooks to zfb's navigation events via
- * `setLifecycleAdapter()`. It receives a mode-scoped PanelConfig builder —
- * either a project override or the package default from
- * `@takazudo/zudo-doc/design-token-panel-config`. The builder module is
- * zdtp-runtime-free (type-only zdtp imports), which is what lets it stay a
- * STATIC import here without defeating the lazy load — and lets the probe
- * compute the exact active storage prefix before zdtp exists.
- *
- * The current call shape is a mode-scoped builder. It rebuilds the panel per
- * light/dark mode on every `color-scheme-changed` toggle:
- *
- *   import { bootstrapDesignTokenPanel } from "@takazudo/zudo-doc/design-token-panel-bootstrap";
- *   import { buildDesignTokenPanelConfig } from "@/config/design-token-panel-config";
- *   bootstrapDesignTokenPanel(buildDesignTokenPanelConfig);
- *
- * `DesignTokenPanelBootstrap` (below) is the PACKAGE-OWNED island component
- * that wires the mode-scoped builder for every `createChrome` consumer with no
- * host config file — the #2658 "Approach (a)" package default. Since #3396 it
- * binds the package-default builder DIRECTLY
- * (`./design-token-panel-config/index.js`), not the routes plugin's
- * `virtual:zudo-doc-design-token-panel-config` module.
- * `packages/zudo-doc/src/chrome/derive.tsx` statically imports it so zfb's
- * island scanner walks route → chrome → derive → here (mirrors the DocHistory
- * #2480 static-import contract). A host that ejects entirely can call
- * `bootstrapDesignTokenPanel` with its own builder. Package-owned INJECTED
- * routes do not render this component — they render the configured wrapper
- * described below — but every other `createChrome` caller does.
- *
- * COUPLING REMOVED (#3396, epic #3394): this module no longer imports any
- * `virtual:` specifier, so `@takazudo/zudo-doc/chrome` (which reaches here via
- * `chrome/derive.tsx`) bundles OUTSIDE a zfb build with zero shims, and a
- * `packageOwnedRoutes: false` host needs no alias for the config specifier.
- *
- * WHERE THE HOST OVERRIDE ENTERS NOW: `settings.designTokenPanelConfigModule`
- * still travels through `virtual:zudo-doc-design-token-panel-config`, but the
- * ONLY module that imports that specifier is the routes-only wrapper
- * `routes/_design-token-panel-bootstrap.tsx`. It calls
- * {@link runDesignTokenPanelBootstrapOnce} with the resolved builder and is
- * threaded into `hostBindings.DesignTokenPanelBootstrap` by `routes/_chrome.tsx`,
- * so `deriveBodyEndIslands` renders it instead of the package default on
- * injected routes. The wrapper is a component-level seam INSIDE the client
- * island bundle — deliberately NOT a module-level setter: the route/SSR graph
- * and the hydrated island bundle are separate module graphs, so a setter called
- * during route evaluation would configure only the server instance while the
- * client re-evaluated this module and kept the default.
- *
- * SELF-CONTAINED `pages/` STUBS (was a KNOWN GAP in #3396; closed by #3414).
- * A host that renders docs through a self-contained `pages/` stub (the
- * locked-manifest shape, #2653 — it calls `createChrome` directly rather than
- * going through `routes/_chrome.tsx`) reaches the package default here, so
- * `designTokenPanelConfigModule` does not apply to those pages. Because
- * {@link runDesignTokenPanelBootstrapOnce}'s latch is per SESSION, not per
- * page, that used to make the whole SPA session's panel config depend on which
- * page was hard-loaded first (#3406). Two things now bound it:
- *
- * - `chrome/derive.tsx` SKIPS this package default as the slot default when
- *   `settings.designTokenPanelConfigModule` is set and the host supplied no
- *   explicit `chromeBindings.DesignTokenPanelBootstrap` (and
- *   `packageOwnedRoutes` is on). Stub-rendered pages then mount NO panel island
- *   at all, so they can no longer win the latch with the wrong builder — the
- *   configured island is the genuine first caller whatever the entry page. The
- *   absence on stub pages is deliberate; such a host threads its own builder
- *   via `chromeBindings.DesignTokenPanelBootstrap` to get a panel there too.
- * - Any residual default-then-configured race that skip does not close warns at
- *   runtime, naming both the setting and that workaround — see
- *   {@link runDesignTokenPanelBootstrapOnce}.
- *
- * Package-first wiring landed in S9a zudolab/zudo-doc#2333; mode-scoped rebuild
- * wiring was added in zudolab/zudo-doc#2610 and the package-default island in
- * #2658.
- *
- * CSS is pulled via `@import "@takazudo/zdtp/styles.css"` in the project's
- * `src/styles/global.css` so the panel chrome lands in the main page CSS
- * bundle (not a deferred chunk). Vite library mode strips the source CSS
- * import from the emitted JS, so the explicit CSS-side import is the
- * required pull point. See @takazudo/zdtp PORTABLE-CONTRACT.md §7.
+ * Public facade for the design-token-panel bootstrap subpath. Callable setup
+ * helpers live in the ordinary controller module; the sole island marker is
+ * defined in its own `use client` entry.
  */
-import type { JSX } from "preact";
-import type { PanelConfig } from "@takazudo/zdtp";
-/** Active color-scheme mode, read from `<html data-theme>`. */
-type ColorSchemeMode = "light" | "dark";
-/**
- * A per-mode PanelConfig factory. The package default and host overrides use
- * this same shape so panel defaults follow the live light/dark mode.
- */
-export type PanelConfigBuilder = (mode: ColorSchemeMode) => PanelConfig;
-/**
- * Theme-pack storage-prefix rule (ADR theme-packs.md Decision 4), enforced
- * CENTRALLY here — never per-builder, so host builders supplied via
- * `designTokenPanelConfigModule` cannot cross-contaminate namespaces even if
- * unaware of packs:
- *
- * - active pack `default` → the builder's `storagePrefix` stays BYTE-UNCHANGED
- *   (the existing-user carry-over guarantee: `zudo-doc-tweak` keys keep
- *   working on the stock look).
- * - any other pack → `${storagePrefix}--<slug>` (double hyphen avoids
- *   colliding with zdtp's own `-open`/version suffixes). zdtp derives every
- *   key — including the `${prefix}-open` open-state mirror — from the prefix,
- *   so tweaks saved under pack A are invisible under pack B and restored
- *   verbatim on switch-back.
- *
- * The `PanelConfigBuilder` signature stays `(mode) => PanelConfig` — this is a
- * post-process of the RETURNED config, not a builder-contract change.
- */
-export declare function withPackScopedStoragePrefix(config: PanelConfig, activePack: string): PanelConfig;
-/**
- * Bootstrap zdtp for a project — LAZILY (#3282). At mount this registers the
- * interim toggle listener on both resolved channels (#3315), drains the
- * pre-hydration click queue, and probes localStorage for persisted panel
- * state; the actual
- * `import("@takazudo/zudo-doc/zdtp-loader")` (zdtp's package-owned
- * re-export, #4201) + configure happen on the first toggle (or
- * immediately on a probe hit). The configure body then wires everything the
- * pre-lazy version wired eagerly: `configurePanel` with the pack-scoped
- * mode-config, the `color-scheme-changed` / `theme-pack-changed` rebuild
- * listeners, `reapplyPersistedOverrides`, and the zfb lifecycle adapter via
- * `setLifecycleAdapter`.
- *
- * @param buildConfig - The project's `(mode) => PanelConfig` builder for
- *   mode-scoped rebuilds.
- */
-export declare function bootstrapDesignTokenPanel(buildConfig: PanelConfigBuilder): void;
-/**
- * Which island won the once-latch below (#3414).
- *
- * - `"default"` — the package-default {@link DesignTokenPanelBootstrap}, bound
- *   to the package-default builder.
- * - `"configured"` — the routes-only wrapper
- *   (`routes/_design-token-panel-bootstrap.tsx`), bound to whatever
- *   `virtual:zudo-doc-design-token-panel-config` resolved to (a host's
- *   `settings.designTokenPanelConfigModule` when set, the package default
- *   otherwise).
- */
-export type DesignTokenPanelBootstrapOrigin = "default" | "configured";
-/**
- * Run {@link bootstrapDesignTokenPanel} at most once per module instance, with
- * whichever mode-scoped builder the caller supplies.
- *
- * Exists so the routes-only configured wrapper
- * (`routes/_design-token-panel-bootstrap.tsx`, #3396) gets the same one-shot
- * semantics as {@link DesignTokenPanelBootstrap} while supplying the
- * host-overridable builder from `virtual:zudo-doc-design-token-panel-config`.
- * The guard is deliberately shared across both callers: `deriveBodyEndIslands`
- * renders exactly ONE of them, and if a host ever mounted both, configuring the
- * panel twice would re-mount it rather than layer the two configs.
- *
- * `origin` tags WHICH island is calling (#3414). It is optional, defaulting to
- * `"default"`, because this function is reachable from the frozen
- * `./design-token-panel-bootstrap` subpath (API.md) — an added required
- * parameter would break an ejected host that calls it. Both in-package callers
- * pass it explicitly.
- *
- * This is a CALL, not a module-level setter — the builder is passed in at
- * render time inside whichever bundle the island actually hydrates in, so it
- * never has to cross the route-graph → island-bundle boundary.
- */
-export declare function runDesignTokenPanelBootstrapOnce(build: PanelConfigBuilder, origin?: DesignTokenPanelBootstrapOrigin): void;
-/**
- * The package-default `<DesignTokenPanelBootstrap/>` island: mounted (via
- * `Island({ when: "load" })`, no `ssrFallback` — it renders nothing on either
- * side) by `../doc-body-end-islands/index.tsx` when `settings.designTokenPanel`
- * is on, gated the same way `AiChatModal`/`ImageEnlarge`/`MermaidEnlarge` are.
- * On first render, calls `bootstrapDesignTokenPanel` with the PACKAGE-DEFAULT
- * mode-scoped `buildDesignTokenPanelConfig` builder. A host's
- * `designTokenPanelConfigModule` override does not reach this component — it
- * arrives through the routes-only wrapper described in the module docblock.
- *
- * `displayName` pinned explicitly (belt-and-braces, matching
- * `AiChatModal`/`ImageEnlarge`/`MermaidEnlarge`/`DocHistory`) so zfb's
- * `captureComponentName` emits a stable `data-zfb-island="DesignTokenPanelBootstrap"`
- * marker independent of minification. It MUST keep matching the exported
- * binding identifier — zfb's island scanner registers by the scanner-visible
- * export name and warns when a `displayName` diverges from it.
- */
-export declare function DesignTokenPanelBootstrap(): JSX.Element | null;
-export declare namespace DesignTokenPanelBootstrap {
-    var displayName: string;
-}
-export {};
+export * from "./design-token-panel-bootstrap-controller.js";
+export { DesignTokenPanelBootstrap } from "./design-token-panel-bootstrap-island.js";