@publish.os/nextjs 0.0.1-alpha.90 → 0.0.1-alpha.92

package/dist/kernel/components/blocks/agent-actions.d.ts

@@ -0,0 +1,4 @@
+import 'react';
+export { AgentActionConfig, AgentActionContext, AgentActionCopyTarget, AgentActionGroup, AgentActions, AgentActionsProps, Feedback, Group, Item, MarkdownLink, Menu, PrimaryAction, Root, Toolbar } from './AgentActions.js';
+import 'class-variance-authority/types';
+import 'class-variance-authority';

package/dist/kernel/components/blocks/agent-actions.js

@@ -0,0 +1,563 @@
+"use client";
+
+// src/modules/agent-actions/agent-actions.tsx
+import { AnimatedIconSwap } from "@components/blocks/animated-icon-swap";
+import {
+  Button,
+  buttonVariants
+} from "@components/ui/button";
+import { ButtonGroup, ButtonGroupSeparator } from "@components/ui/button-group";
+import {
+  Menu,
+  MenuGroup,
+  MenuGroupLabel,
+  MenuItem,
+  MenuLinkItem,
+  MenuPopup,
+  MenuPortal,
+  MenuPositioner,
+  MenuSeparator,
+  MenuTrigger
+} from "@components/ui/menu";
+import {
+  CaretDownIcon,
+  CheckIcon,
+  CopyIcon,
+  MarkdownLogoIcon
+} from "@phosphor-icons/react/ssr";
+import { cn } from "@publish.os/nextjs/utils/cn";
+import {
+  createContext,
+  Fragment,
+  use,
+  useCallback,
+  useEffect,
+  useRef,
+  useState
+} from "react";
+import { flushSync } from "react-dom";
+import { jsx, jsxs } from "@publish.os/nextjs/jsx-runtime";
+var DEFAULT_PROMPT_SUFFIX = "I want to ask questions about it.", COPY_FEEDBACK_MS = 1600;
+function normalizePath(path) {
+  let [pathname = "/"] = path.split(/[?#]/), prefixed = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return prefixed === "/" ? prefixed : prefixed.replace(/\/+$/, "");
+}
+function markdownPathForPagePath(path) {
+  let normalized = normalizePath(path);
+  return normalized === "/" ? "/index.md" : `${normalized}.md`;
+}
+function isAbsoluteUrl(url) {
+  return /^[a-z][a-z\d+\-.]*:/i.test(url);
+}
+function absoluteUrl(url, siteUrl) {
+  if (isAbsoluteUrl(url) || !siteUrl) return url;
+  try {
+    return new URL(url, siteUrl).toString();
+  } catch {
+    return url;
+  }
+}
+function mergeRel(rel) {
+  let values = new Set((rel ?? "").split(/\s+/).filter(Boolean));
+  return values.add("noreferrer"), Array.from(values).join(" ");
+}
+function createPrompt(markdownUrl) {
+  return `Read ${markdownUrl}, ${DEFAULT_PROMPT_SUFFIX}`;
+}
+function providerPromptUrl(baseUrl, prompt, param = "q") {
+  let url = new URL(baseUrl);
+  return url.searchParams.set(param, prompt), url.toString();
+}
+var DEFAULT_PRIMARY_ACTION = {
+  id: "copy-page-markdown-primary",
+  title: "Copy Markdown",
+  copy: "page-markdown"
+}, DEFAULT_ACTION_GROUPS = [
+  {
+    id: "open-in-ai",
+    title: "Open in",
+    actions: [
+      {
+        id: "open-chatgpt",
+        title: "ChatGPT",
+        href: ({ prompt }) => providerPromptUrl("https://chatgpt.com/?hints=search", prompt),
+        openInNew: !0
+      }
+    ]
+  },
+  {
+    id: "page-actions",
+    title: "Page",
+    actions: [
+      {
+        id: "copy-page-markdown",
+        title: "Copy markdown",
+        copy: "page-markdown"
+      },
+      {
+        id: "view-page-markdown",
+        title: "View as Markdown",
+        href: ({ markdownPath }) => markdownPath
+      },
+      {
+        id: "copy-page-link",
+        title: "Copy link",
+        copy: "page-link"
+      }
+    ]
+  }
+];
+function resolveValue(value, context) {
+  return typeof value == "function" ? value(context) : value;
+}
+async function copyText(text) {
+  if (!navigator.clipboard?.writeText)
+    throw new Error("Clipboard access is not available in this browser.");
+  await navigator.clipboard.writeText(text);
+}
+function revisionRequestPath(path, revision) {
+  if (!revision) return path;
+  let separator = path.includes("?") ? "&" : "?";
+  return `${path}${separator}publishos_revision=${encodeURIComponent(revision)}`;
+}
+async function markdownHash(text) {
+  if (!globalThis.crypto?.subtle)
+    throw new Error("This browser cannot verify the current Markdown version.");
+  let digest = await globalThis.crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(text)
+  );
+  return `sha256-${Array.from(
+    new Uint8Array(digest),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("").slice(0, 32)}`;
+}
+var AgentActionsContext = createContext(
+  null
+);
+function useAgentActions() {
+  let context = use(AgentActionsContext);
+  if (!context)
+    throw new Error("AgentActions parts must be inside AgentActions.Root.");
+  return context;
+}
+function AgentActionsProvider({
+  actionGroups,
+  buttonSize = "xs",
+  buttonVariant = "outline",
+  className,
+  markdown,
+  markdownPath,
+  markdownRevision,
+  markdownUrl,
+  menuLabel = "More agent actions",
+  markdownLinkLabel = "View as Markdown",
+  pagePath,
+  pageUrl,
+  primaryAction,
+  prompt,
+  siteUrl,
+  sourceUrl,
+  showMarkdownLink = !0,
+  children,
+  ...props
+}) {
+  let [copiedActionId, setCopiedActionId] = useState(), [copyFeedback, setCopyFeedback] = useState(), [menuOpen, setMenuOpen] = useState(!1), menuTriggerRef = useRef(null), menuActionsRef = useRef(null), menuOpenRef = useRef(!1), markdownPreparationRef = useRef(null), currentMarkdownKeyRef = useRef(""), resetTimerRef = useRef(
+    void 0
+  ), closeMenu = useCallback(() => {
+    flushSync(() => {
+      menuOpenRef.current = !1, setMenuOpen(!1), menuActionsRef.current?.close(), menuActionsRef.current?.unmount();
+    });
+  }, []);
+  useEffect(() => () => {
+    resetTimerRef.current && clearTimeout(resetTimerRef.current);
+  }, []);
+  let resolvedPagePath = pagePath ?? "/", resolvedMarkdownPath = markdownPath ?? markdownPathForPagePath(resolvedPagePath), resolvedMarkdownUrl = absoluteUrl(
+    markdownUrl ?? resolvedMarkdownPath,
+    siteUrl
+  ), context = {
+    markdown,
+    markdownPath: resolvedMarkdownPath,
+    markdownUrl: resolvedMarkdownUrl,
+    pagePath: resolvedPagePath,
+    pageUrl: absoluteUrl(pageUrl ?? resolvedPagePath, siteUrl),
+    prompt: prompt ?? createPrompt(resolvedMarkdownUrl),
+    sourceUrl
+  }, markdownKey = `${context.markdownUrl}\0${markdownRevision ?? "unversioned"}`;
+  currentMarkdownKeyRef.current = markdownKey, useEffect(
+    () => () => {
+      markdownPreparationRef.current?.controller?.abort(), markdownPreparationRef.current = null;
+    },
+    []
+  ), useEffect(() => {
+    let preparation = markdownPreparationRef.current;
+    preparation && preparation.key !== markdownKey && (preparation.controller?.abort(), markdownPreparationRef.current = null, setCopyFeedback(void 0), setCopiedActionId(void 0));
+  }, [markdownKey]);
+  let resolvedPrimaryAction = primaryAction ?? DEFAULT_PRIMARY_ACTION, resolvedActionGroups = actionGroups ?? DEFAULT_ACTION_GROUPS, markCopied = (actionId) => {
+    resetTimerRef.current && clearTimeout(resetTimerRef.current), setCopiedActionId(actionId), resetTimerRef.current = setTimeout(() => {
+      setCopiedActionId(void 0);
+    }, COPY_FEEDBACK_MS);
+  }, markdownPreparation = () => {
+    let current = markdownPreparationRef.current;
+    if (current?.key === markdownKey) return current;
+    current?.controller?.abort();
+    let next = { key: markdownKey };
+    return markdownPreparationRef.current = next, next;
+  }, prepareMarkdown = () => {
+    if (context.markdown !== void 0 || !context.markdownUrl) return;
+    let record = markdownPreparation();
+    if (record.text !== void 0 || record.pending) return;
+    let controller = new AbortController();
+    record.controller = controller;
+    let requestPath = revisionRequestPath(
+      context.markdownPath,
+      markdownRevision
+    ), localPreview = process.env.NODE_ENV !== "production", request = async (cache) => {
+      let response;
+      try {
+        response = await fetch(requestPath, {
+          cache,
+          signal: controller.signal
+        });
+      } catch {
+        throw new Error("The Markdown page could not be loaded.");
+      }
+      if (!response.ok)
+        throw new Error(
+          `The Markdown page could not be loaded (${response.status}).`
+        );
+      return response.text();
+    }, pending = (async () => {
+      let firstBody = await request(localPreview ? "no-store" : "default");
+      if (!markdownRevision || await markdownHash(firstBody) === markdownRevision)
+        return firstBody;
+      let refreshedBody = await request(localPreview ? "no-store" : "reload");
+      if (await markdownHash(refreshedBody) !== markdownRevision)
+        throw new Error(
+          "The Markdown page changed while loading. Refresh the page and try again."
+        );
+      return refreshedBody;
+    })().then((text) => (markdownPreparationRef.current === record && currentMarkdownKeyRef.current === record.key && (record.text = text), text)).catch((error) => {
+      throw markdownPreparationRef.current === record && (markdownPreparationRef.current = null), error;
+    }).finally(() => {
+      record.pending = void 0, record.controller = void 0;
+    });
+    record.pending = pending, pending.catch(() => {
+    });
+  }, setMenuOpenState = (open) => {
+    menuOpenRef.current = open, setMenuOpen(open), open && resolvedActionGroups.some(
+      (group) => group.actions.some(
+        (action) => action.copy === "page-markdown" && !resolveValue(action.disabled, context)
+      )
+    ) && prepareMarkdown();
+  }, prepareAction = (action) => {
+    action.copy === "page-markdown" && !resolveValue(action.disabled, context) && prepareMarkdown();
+  }, finishAction = async (action, clipboardWrite, actionMarkdownKey) => {
+    try {
+      if (await clipboardWrite, actionMarkdownKey && currentMarkdownKeyRef.current !== actionMarkdownKey)
+        return;
+      markCopied(action.id), setCopyFeedback("Copied to clipboard."), await action.onSelect?.(context);
+    } catch (error) {
+      if (actionMarkdownKey && currentMarkdownKeyRef.current !== actionMarkdownKey)
+        return;
+      setCopyFeedback(
+        error instanceof Error ? `${error.message} Try again.` : "The action failed. Try again."
+      );
+    }
+  }, handleAction = (action) => {
+    if (resolveValue(action.disabled, context)) return;
+    if (setCopyFeedback(void 0), setCopiedActionId(void 0), !action.copy) {
+      Promise.resolve(action.onSelect?.(context)).catch(
+        (error) => {
+          setCopyFeedback(
+            error instanceof Error ? `${error.message} Try again.` : "The action failed. Try again."
+          );
+        }
+      );
+      return;
+    }
+    if (action.copy === "page-markdown" && context.markdown === void 0) {
+      if (!context.markdownUrl) {
+        setCopyFeedback("The Markdown page URL is not available. Try again.");
+        return;
+      }
+      let record = markdownPreparation();
+      if (record.text !== void 0) {
+        if (!record.text) {
+          setCopyFeedback("There is no Markdown content to copy. Try again.");
+          return;
+        }
+        finishAction(action, copyText(record.text), record.key);
+        return;
+      }
+      setCopyFeedback("Preparing Markdown\u2026"), prepareMarkdown();
+      let pending = markdownPreparationRef.current?.pending;
+      if (!pending) return;
+      pending.then(
+        (text) => {
+          if (currentMarkdownKeyRef.current === record.key) {
+            if (!text) {
+              setCopyFeedback("There is no Markdown content to copy. Try again.");
+              return;
+            }
+            finishAction(action, copyText(text), record.key);
+          }
+        },
+        (error) => {
+          currentMarkdownKeyRef.current === record.key && setCopyFeedback(
+            error instanceof Error ? `${error.message} Try again.` : "The action failed. Try again."
+          );
+        }
+      );
+      return;
+    }
+    let value = action.copy === "page-markdown" ? context.markdown : action.copy === "page-link" ? context.pageUrl : action.copy === "markdown-link" ? context.markdownUrl : action.copy;
+    if (!value) {
+      setCopyFeedback("There is no Markdown content to copy. Try again.");
+      return;
+    }
+    finishAction(action, copyText(value));
+  }, iconForAction = (action) => {
+    let copied = copiedActionId === action.id;
+    return action.copy === "page-markdown" ? /* @__PURE__ */ jsx(
+      AnimatedIconSwap,
+      {
+        active: copied,
+        activeIcon: /* @__PURE__ */ jsx(CheckIcon, { "aria-hidden": "true", className: "size-4" }),
+        defaultIcon: action.icon ?? /* @__PURE__ */ jsx(CopyIcon, { "aria-hidden": "true", className: "size-4" }),
+        size: 16
+      }
+    ) : copied ? /* @__PURE__ */ jsx(CheckIcon, { "aria-hidden": "true", className: "size-4" }) : action.icon;
+  }, contextValue = {
+    buttonSize,
+    buttonVariant,
+    closeMenu,
+    copyFeedback,
+    menuActionsRef,
+    menuLabel,
+    menuOpen,
+    menuTriggerRef,
+    markdownLink: showMarkdownLink ? /* @__PURE__ */ jsxs(
+      "a",
+      {
+        className: "inline-flex min-h-7 items-center gap-1.5 text-xs font-medium text-foreground-2 no-underline transition-colors hover:text-foreground-1 hover:underline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-focus-stroke motion-reduce:transition-none",
+        "data-slot": "agent-actions-markdown-link",
+        href: resolvedMarkdownPath,
+        children: [
+          /* @__PURE__ */ jsx(
+            MarkdownLogoIcon,
+            {
+              "aria-hidden": "true",
+              className: "size-4 shrink-0",
+              weight: "fill"
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { children: markdownLinkLabel })
+        ]
+      }
+    ) : null,
+    renderPrimaryAction: (action = resolvedPrimaryAction) => {
+      let href = resolveValue(action.href, context), disabled = resolveValue(action.disabled, context), target = action.target ?? (action.openInNew ? "_blank" : void 0), rel = target === "_blank" ? mergeRel(action.rel) : void 0;
+      return href && !action.copy && !action.onSelect ? /* @__PURE__ */ jsxs(
+        "a",
+        {
+          "aria-disabled": disabled ? "true" : void 0,
+          className: cn(
+            buttonVariants({
+              iconOnly: !1,
+              size: buttonSize,
+              variant: buttonVariant
+            }),
+            disabled && "pointer-events-none opacity-50"
+          ),
+          "data-disabled": disabled ? "" : void 0,
+          href: disabled ? void 0 : href,
+          rel,
+          target,
+          children: [
+            iconForAction(action),
+            /* @__PURE__ */ jsx("span", { children: action.title })
+          ]
+        }
+      ) : /* @__PURE__ */ jsx(
+        Button,
+        {
+          disabled: !!disabled,
+          leftIcon: iconForAction(action),
+          onFocus: () => prepareAction(action),
+          onClick: () => {
+            handleAction(action);
+          },
+          onPointerDown: () => prepareAction(action),
+          onPointerEnter: () => prepareAction(action),
+          size: buttonSize,
+          variant: buttonVariant,
+          children: action.title
+        }
+      );
+    },
+    renderMenuAction: (action) => {
+      let href = resolveValue(action.href, context), disabled = resolveValue(action.disabled, context), target = action.target ?? (action.openInNew ? "_blank" : void 0), rel = target === "_blank" ? mergeRel(action.rel) : void 0, label = action.title;
+      return href && !action.copy && !action.onSelect && !disabled ? /* @__PURE__ */ jsxs(
+        MenuLinkItem,
+        {
+          closeOnClick: !0,
+          href,
+          onClick: closeMenu,
+          rel,
+          target,
+          children: [
+            action.icon ? /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: "shrink-0", children: action.icon }) : null,
+            /* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1 truncate", children: label })
+          ]
+        },
+        action.id
+      ) : /* @__PURE__ */ jsxs(
+        MenuItem,
+        {
+          disabled: !!disabled,
+          onFocus: () => prepareAction(action),
+          onClick: () => {
+            handleAction(action);
+          },
+          onPointerDown: () => prepareAction(action),
+          onPointerEnter: () => prepareAction(action),
+          children: [
+            action.icon ? /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: "shrink-0", children: action.icon }) : null,
+            /* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1 truncate", children: label })
+          ]
+        },
+        action.id
+      );
+    },
+    resolvedActionGroups,
+    setMenuOpenState
+  };
+  return /* @__PURE__ */ jsx(AgentActionsContext.Provider, { value: contextValue, children: children ?? /* @__PURE__ */ jsx(AgentActionsDefaultLayout, { className, ...props }) });
+}
+function AgentActionsDefaultLayout({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxs(AgentActionsToolbar, { className, ...props, children: [
+    /* @__PURE__ */ jsx(AgentActionsMarkdownLink, {}),
+    /* @__PURE__ */ jsxs(ButtonGroup, { children: [
+      /* @__PURE__ */ jsx(AgentActionsPrimaryAction, {}),
+      /* @__PURE__ */ jsx(ButtonGroupSeparator, {}),
+      /* @__PURE__ */ jsx(AgentActionsMenu, {})
+    ] }),
+    /* @__PURE__ */ jsx(AgentActionsFeedback, {})
+  ] });
+}
+function AgentActionsToolbar({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "inline-flex flex-wrap items-center gap-x-3 gap-y-2",
+        className
+      ),
+      "data-slot": "agent-actions",
+      ...props
+    }
+  );
+}
+function AgentActionsMarkdownLink() {
+  return useAgentActions().markdownLink;
+}
+function AgentActionsPrimaryAction({ action }) {
+  return useAgentActions().renderPrimaryAction(action);
+}
+function AgentActionsFeedback() {
+  let { copyFeedback } = useAgentActions();
+  return /* @__PURE__ */ jsx("span", { "aria-live": "polite", className: "sr-only", role: "status", children: copyFeedback });
+}
+function AgentActionsGroup({
+  title,
+  children
+}) {
+  return /* @__PURE__ */ jsxs(MenuGroup, { children: [
+    title ? /* @__PURE__ */ jsx(MenuGroupLabel, { children: title }) : null,
+    children
+  ] });
+}
+function AgentActionsItem({ action }) {
+  return useAgentActions().renderMenuAction(action);
+}
+function AgentActionsMenu({ children }) {
+  let {
+    buttonSize,
+    buttonVariant,
+    closeMenu,
+    menuActionsRef,
+    menuLabel,
+    menuOpen,
+    menuTriggerRef,
+    resolvedActionGroups,
+    setMenuOpenState
+  } = useAgentActions();
+  return useEffect(() => {
+    let view = menuTriggerRef.current?.ownerDocument.defaultView;
+    if (view)
+      return view.addEventListener("pagehide", closeMenu), view.addEventListener("pageshow", closeMenu), () => {
+        view.removeEventListener("pagehide", closeMenu), view.removeEventListener("pageshow", closeMenu);
+      };
+  }, [closeMenu, menuTriggerRef]), /* @__PURE__ */ jsxs(
+    Menu,
+    {
+      actionsRef: menuActionsRef,
+      modal: !1,
+      onOpenChange: setMenuOpenState,
+      open: menuOpen,
+      children: [
+        /* @__PURE__ */ jsx(
+          MenuTrigger,
+          {
+            "aria-label": menuLabel,
+            ref: menuTriggerRef,
+            className: cn(
+              buttonVariants({
+                iconOnly: !0,
+                size: buttonSize,
+                variant: buttonVariant
+              }),
+              "data-popup-open:rounded-r-button!"
+            ),
+            children: /* @__PURE__ */ jsx(CaretDownIcon, { "aria-hidden": "true", className: "size-4" })
+          }
+        ),
+        /* @__PURE__ */ jsx(MenuPortal, { children: /* @__PURE__ */ jsx(MenuPositioner, { align: "end", children: /* @__PURE__ */ jsx(MenuPopup, { className: "min-w-56", onClick: closeMenu, children: children ?? resolvedActionGroups.map((group, index) => /* @__PURE__ */ jsxs(Fragment, { children: [
+          index > 0 ? /* @__PURE__ */ jsx(MenuSeparator, {}) : null,
+          /* @__PURE__ */ jsx(AgentActionsGroup, { title: group.title, children: group.actions.map((action) => /* @__PURE__ */ jsx(AgentActionsItem, { action }, action.id)) })
+        ] }, group.id)) }) }) })
+      ]
+    }
+  );
+}
+function AgentActionsRoot(props) {
+  return /* @__PURE__ */ jsx(AgentActionsProvider, { ...props });
+}
+var AgentActions = Object.assign(AgentActionsRoot, {
+  Feedback: AgentActionsFeedback,
+  Group: AgentActionsGroup,
+  Item: AgentActionsItem,
+  MarkdownLink: AgentActionsMarkdownLink,
+  Menu: AgentActionsMenu,
+  PrimaryAction: AgentActionsPrimaryAction,
+  Root: AgentActionsRoot,
+  Toolbar: AgentActionsToolbar
+});
+export {
+  AgentActions,
+  AgentActionsFeedback as Feedback,
+  AgentActionsGroup as Group,
+  AgentActionsItem as Item,
+  AgentActionsMarkdownLink as MarkdownLink,
+  AgentActionsMenu as Menu,
+  AgentActionsPrimaryAction as PrimaryAction,
+  AgentActionsRoot as Root,
+  AgentActionsToolbar as Toolbar
+};

package/dist/kernel/components/blocks/animated-icon-swap.d.ts

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
 import { ComponentPropsWithoutRef, ReactNode } from 'react';
 
 type AnimatedIconSwapProps = Omit<ComponentPropsWithoutRef<"span">, "children"> & {
@@ -11,6 +11,6 @@ type AnimatedIconSwapProps = Omit<ComponentPropsWithoutRef<"span">, "children">
     /** Square wrapper size in pixels. */
     size: number;
 };
-declare function AnimatedIconSwap({ active, activeIcon, className, defaultIcon, size, style, ...props }: AnimatedIconSwapProps): react_jsx_runtime.JSX.Element;
+declare function AnimatedIconSwap({ active, activeIcon, className, defaultIcon, size, style, ...props }: AnimatedIconSwapProps): react.JSX.Element;
 
 export { AnimatedIconSwap, type AnimatedIconSwapProps };

package/dist/kernel/components/blocks/animated-icon-swap.js

@@ -1,6 +1,6 @@
 // src/components/ui/animated-icon-swap.tsx
 import { cn } from "@publish.os/nextjs/utils/cn";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { jsx, jsxs } from "@publish.os/nextjs/jsx-runtime";
 var iconSlotClassName = "pointer-events-none absolute inset-0 flex items-center justify-center transition-[transform,opacity] duration-200 ease-out motion-reduce:scale-100 motion-reduce:transition-opacity motion-reduce:duration-100";
 function AnimatedIconSwap({
   active,

package/dist/kernel/components/blocks/color-palette.d.ts

@@ -1,7 +1,7 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
 
 declare function collectTokenNamesFromCssText(css: string): string[];
 declare function deriveTokenGroup(name: string): string;
-declare function ColorPalette(): react_jsx_runtime.JSX.Element;
+declare function ColorPalette(): react.JSX.Element;
 
 export { collectTokenNamesFromCssText, ColorPalette as default, deriveTokenGroup };

package/dist/kernel/components/blocks/color-palette.js

@@ -1,7 +1,7 @@
 "use client";
 
 // src/modules/design-system/color-palette.tsx
-import { Button } from "@publish.os/nextjs/kernel/components/ui/button";
+import { Button } from "@components/ui/button";
 import {
   Menu,
   MenuItem,
@@ -9,7 +9,7 @@ import {
   MenuPortal,
   MenuPositioner,
   MenuTrigger
-} from "@publish.os/nextjs/kernel/components/ui/menu";
+} from "@components/ui/menu";
 import {
   Select,
   SelectIcon,
@@ -22,9 +22,9 @@ import {
   SelectPositioner,
   SelectTrigger,
   SelectValue
-} from "@publish.os/nextjs/kernel/components/ui/select";
+} from "@components/ui/select";
 import { useCallback, useEffect, useRef, useState } from "react";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Fragment, jsx, jsxs } from "@publish.os/nextjs/jsx-runtime";
 var DEFAULT_TOKEN_NAMES = [
   "surface-page",
   "surface-1",

package/dist/kernel/components/blocks/logo-block.d.ts

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
 
 type LogoBlockAsset = {
     readonly outputPath: string;
@@ -16,6 +16,6 @@ type LogoBlockProps = {
     maxWidth?: number;
     siteName: string;
 };
-declare function LogoBlock({ className, logo, maxHeight, maxWidth, siteName, }: LogoBlockProps): react_jsx_runtime.JSX.Element;
+declare function LogoBlock({ className, logo, maxHeight, maxWidth, siteName, }: LogoBlockProps): react.JSX.Element;
 
 export { LogoBlock, type LogoBlockAsset, type LogoBlockLogo, type LogoBlockProps };

package/dist/kernel/components/blocks/logo-block.js

@@ -1,6 +1,6 @@
 // src/components/block/logo-block.tsx
 import { cn } from "@publish.os/nextjs/utils/cn";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Fragment, jsx, jsxs } from "@publish.os/nextjs/jsx-runtime";
 var DEFAULT_LOGO_MAX_HEIGHT = 24, DEFAULT_LOGO_MAX_WIDTH = 160;
 function isValidLogoAsset(asset) {
   return typeof asset?.outputPath == "string" && asset.outputPath.trim() !== "";

package/dist/kernel/components/blocks/nav-breadcrumb.d.ts

@@ -1,19 +1,20 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import { VariantProps } from 'class-variance-authority';
-import { S as SiteData, T as TreeNode } from '../../../types-CUtrppxt.js';
+import { S as SiteData } from '../../../types-TjH1ek0X.js';
+import { R as ResolvedNavigation } from '../../../manifest-types-CcVPH_jh.js';
 
 declare const breadcrumbVariants: (props?: ({
     size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 type BreadcrumbVariantProps = VariantProps<typeof breadcrumbVariants>;
 
-declare function NavBreadcrumb({ currentPath, showRoot, size, site, tree, }: {
+declare function NavBreadcrumb({ currentPath, showRoot, size, site, navigation, }: {
     currentPath?: string;
     showRoot?: boolean;
     size?: BreadcrumbVariantProps["size"];
     site: SiteData;
-    tree: TreeNode[];
-}): react_jsx_runtime.JSX.Element | null;
+    navigation: ResolvedNavigation;
+}): react.JSX.Element | null;
 
 export { NavBreadcrumb };