@publish.os/nextjs 0.0.1-alpha.6 → 0.0.1-alpha.7

package/compiler-assets/nextjs/shims/proxy.ts

@@ -0,0 +1,317 @@
+import { agentRouteConfig } from "@source/.publishos/agent-route-config.generated";
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+
+const AGENT_USER_AGENT_PATTERN =
+  /\b(?:axios|got|node-fetch|undici|curl|wget|python-requests|httpx|aiohttp|claude-code|claudebot|claude|cursor|chatgpt|openai|perplexity|anthropic-ai)\b/i;
+const INTERNAL_MARKDOWN_PREFIX = "/__publishos/md";
+const PUBLIC_FILE_PATTERN = /\.[a-z0-9]{1,12}$/i;
+const TEXT_METHODS = new Set(["GET", "HEAD"]);
+
+function debugAgentRoute(
+  event: string,
+  details: Record<string, string | number | undefined>,
+) {
+  if (
+    process.env.NODE_ENV === "production" ||
+    process.env.NEXT_PRIVATE_DEBUG_CACHE !== "1"
+  ) {
+    return;
+  }
+
+  // biome-ignore lint/suspicious/noConsole: proxy debug logs are opt-in diagnostics for request routing.
+  console.debug("[publish.os:debug]", "[agent-route]", event, details);
+}
+
+function normalizePagePath(pathname: string): string {
+  if (pathname === "/") return "/";
+  return pathname.replace(/\/+$/, "");
+}
+
+function markdownRoutePath(pathname: string): string {
+  const normalized = normalizePagePath(pathname);
+  const pagePath = normalized.endsWith(".md")
+    ? normalized.slice(0, -".md".length)
+    : normalized;
+  return pagePath === "/"
+    ? INTERNAL_MARKDOWN_PREFIX
+    : `${INTERNAL_MARKDOWN_PREFIX}${pagePath}`;
+}
+
+function markdownAlternatePath(pathname: string): string {
+  const normalized = normalizePagePath(pathname);
+  if (normalized === "/") {
+    return agentRouteConfig.discoveryLinks.sitemap ?? "/sitemap.md";
+  }
+  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+}
+
+function markdownNotFoundBody(): string {
+  const links = [
+    agentRouteConfig.discoveryLinks.home
+      ? `> Home: ${agentRouteConfig.discoveryLinks.home}`
+      : undefined,
+    agentRouteConfig.discoveryLinks.sitemap
+      ? `> Sitemap: ${agentRouteConfig.discoveryLinks.sitemap}`
+      : undefined,
+    agentRouteConfig.discoveryLinks.llms
+      ? `> LLMS index: ${agentRouteConfig.discoveryLinks.llms}`
+      : undefined,
+  ].filter((line): line is string => Boolean(line));
+
+  return [
+    "# Not found",
+    "",
+    ...links,
+    "",
+    "The requested Markdown page was not found.",
+    "",
+  ].join("\n");
+}
+
+function explicitAcceptQuality(accept: string, mimeType: string): number {
+  if (!accept) return 0;
+
+  const [targetType, targetSubtype] = mimeType.toLowerCase().split("/");
+  let bestQuality = 0;
+
+  for (const entry of accept.split(",")) {
+    const [rawType, ...rawParams] = entry
+      .trim()
+      .toLowerCase()
+      .split(";")
+      .map((part) => part.trim());
+    if (!rawType) continue;
+
+    const [type, subtype] = rawType.split("/");
+    if (type !== targetType || subtype !== targetSubtype) continue;
+
+    let quality = 1;
+    for (const param of rawParams) {
+      const [key, value] = param.split("=").map((part) => part.trim());
+      if (key !== "q") continue;
+      const parsed = Number.parseFloat(value);
+      quality = Number.isFinite(parsed) ? parsed : 0;
+    }
+
+    if (quality > bestQuality) bestQuality = quality;
+  }
+
+  return bestQuality;
+}
+
+function wantsMarkdown(request: NextRequest): boolean {
+  if (!TEXT_METHODS.has(request.method)) return false;
+
+  const accept = request.headers.get("accept") ?? "";
+  const markdownQuality = agentRouteConfig.markdownAccept
+    ? explicitAcceptQuality(accept, "text/markdown")
+    : 0;
+  const plainQuality = agentRouteConfig.plainTextAccept
+    ? explicitAcceptQuality(accept, "text/plain")
+    : 0;
+  const htmlQuality = explicitAcceptQuality(accept, "text/html");
+
+  if (markdownQuality > 0 && markdownQuality >= htmlQuality) return true;
+  if (plainQuality > 0 && htmlQuality === 0 && markdownQuality === 0) {
+    return true;
+  }
+
+  return false;
+}
+
+function looksLikeAgent(request: NextRequest): boolean {
+  if (!TEXT_METHODS.has(request.method)) return false;
+  if (!agentRouteConfig.agentDetection) return false;
+  if (explicitAcceptQuality(request.headers.get("accept") ?? "", "text/html")) {
+    return false;
+  }
+  return AGENT_USER_AGENT_PATTERN.test(request.headers.get("user-agent") ?? "");
+}
+
+function markdownRequestReason(
+  request: NextRequest,
+): "accept" | "agent" | "extension" | undefined {
+  if (!agentRouteConfig.enabled) return undefined;
+  if (
+    agentRouteConfig.markdownRoutes &&
+    request.nextUrl.pathname.endsWith(".md")
+  ) {
+    return "extension";
+  }
+  if (wantsMarkdown(request)) return "accept";
+  if (looksLikeAgent(request)) return "agent";
+  return undefined;
+}
+
+function isInternalMarkdownRoute(pathname: string): boolean {
+  return (
+    pathname === INTERNAL_MARKDOWN_PREFIX ||
+    pathname.startsWith(`${INTERNAL_MARKDOWN_PREFIX}/`)
+  );
+}
+
+function isStaticOrMetadataRoute(pathname: string): boolean {
+  if (
+    pathname.startsWith("/_next/") ||
+    pathname.startsWith("/_publishos/assets/") ||
+    pathname.startsWith("/_publishos/favicon/") ||
+    pathname.startsWith("/_publishos/logo/") ||
+    pathname.startsWith("/_publishos/og/") ||
+    pathname.startsWith("/assets/")
+  ) {
+    return true;
+  }
+
+  if (
+    pathname === "/favicon.ico" ||
+    pathname === "/apple-touch-icon.png" ||
+    pathname === "/apple-touch-icon-precomposed.png" ||
+    pathname === "/robots.txt" ||
+    pathname === "/sitemap.xml" ||
+    pathname === "/sitemap.md" ||
+    pathname === "/llms.txt" ||
+    pathname === "/llms-full.txt"
+  ) {
+    return true;
+  }
+
+  return PUBLIC_FILE_PATTERN.test(pathname) && !pathname.endsWith(".md");
+}
+
+function rewriteToMarkdown(
+  request: NextRequest,
+  reason: "accept" | "agent" | "extension",
+): NextResponse {
+  const url = request.nextUrl.clone();
+  url.pathname =
+    normalizePagePath(url.pathname) === "/"
+      ? "/sitemap.md"
+      : markdownRoutePath(url.pathname);
+
+  const requestHeaders = new Headers(request.headers);
+  requestHeaders.set("x-publishos-agent-route", "markdown");
+
+  debugAgentRoute("md", {
+    accept: request.headers.get("accept") ?? undefined,
+    method: request.method,
+    path: request.nextUrl.pathname,
+    reason,
+    target: url.pathname,
+    userAgent: request.headers.get("user-agent") ?? undefined,
+  });
+
+  return NextResponse.rewrite(url, {
+    request: {
+      headers: requestHeaders,
+    },
+  });
+}
+
+function withDiscoveryHeaders(
+  response: NextResponse,
+  pathname: string,
+): NextResponse {
+  const markdownUrl = markdownAlternatePath(pathname);
+  const links = [
+    `<${markdownUrl}>; rel="alternate"; type="text/markdown"`,
+    agentRouteConfig.discoveryLinks.llms
+      ? `<${agentRouteConfig.discoveryLinks.llms}>; rel="llms-txt"; type="text/plain"`
+      : undefined,
+    agentRouteConfig.discoveryLinks.sitemap
+      ? `<${agentRouteConfig.discoveryLinks.sitemap}>; rel="alternate"; type="text/markdown"; title="Markdown sitemap"`
+      : undefined,
+  ].filter((link): link is string => Boolean(link));
+  response.headers.set("link", links.join(", "));
+  response.headers.set("x-publishos-markdown", markdownUrl);
+  if (agentRouteConfig.discoveryLinks.llms) {
+    response.headers.set(
+      "x-publishos-llms",
+      agentRouteConfig.discoveryLinks.llms,
+    );
+  }
+  if (agentRouteConfig.discoveryLinks.sitemap) {
+    response.headers.set(
+      "x-publishos-sitemap",
+      agentRouteConfig.discoveryLinks.sitemap,
+    );
+  }
+  response.headers.set("x-publishos-agent-readable", "1");
+  return response;
+}
+
+export function proxy(request: NextRequest) {
+  const { pathname } = request.nextUrl;
+
+  if (isInternalMarkdownRoute(pathname)) {
+    if (request.headers.get("x-publishos-agent-route") === "markdown") {
+      return NextResponse.next();
+    }
+    if (!agentRouteConfig.blockInternalMarkdownRoute) {
+      debugAgentRoute("pass", {
+        method: request.method,
+        path: pathname,
+        reason: "allowed-internal",
+      });
+      return NextResponse.next();
+    }
+
+    debugAgentRoute("md", {
+      method: request.method,
+      path: pathname,
+      reason: "blocked-internal",
+      status: 404,
+    });
+
+    return new Response(markdownNotFoundBody(), {
+      status: 404,
+      headers: {
+        "cache-control": "public, max-age=60, s-maxage=300",
+        "content-type": "text/markdown; charset=utf-8",
+        "x-content-type-options": "nosniff",
+        "x-robots-tag": "noindex",
+      },
+    });
+  }
+
+  if (isStaticOrMetadataRoute(pathname)) {
+    debugAgentRoute("pass", {
+      method: request.method,
+      path: pathname,
+      reason: "static-or-metadata",
+    });
+    return NextResponse.next();
+  }
+
+  const markdownReason = markdownRequestReason(request);
+  if (markdownReason) {
+    return rewriteToMarkdown(request, markdownReason);
+  }
+
+  if (!agentRouteConfig.enabled || !agentRouteConfig.discoveryHeaders) {
+    debugAgentRoute("pass", {
+      method: request.method,
+      path: pathname,
+      reason: agentRouteConfig.enabled
+        ? "discovery-disabled"
+        : "agent-routes-disabled",
+    });
+    return NextResponse.next();
+  }
+
+  debugAgentRoute("html", {
+    accept: request.headers.get("accept") ?? undefined,
+    markdown: markdownAlternatePath(pathname),
+    method: request.method,
+    path: pathname,
+    userAgent: request.headers.get("user-agent") ?? undefined,
+  });
+
+  return withDiscoveryHeaders(NextResponse.next(), pathname);
+}
+
+export const config = {
+  matcher: [
+    "/((?!_next/static|_next/image|_next/webpack-hmr|_publishos/assets|_publishos/favicon|_publishos/logo|_publishos/og|assets).*)",
+  ],
+};

package/compiler-assets/nextjs/shims/publish-os-theme-provider.tsx

@@ -0,0 +1,77 @@
+"use client";
+
+import { ThemeScopeProvider } from "@publish.os/nextjs/theme-scope";
+import {
+  ROOT_DEFAULT_MODE,
+  ROOT_FORCED_MODE,
+  routeThemes,
+} from "@source/.theme.generated";
+import { useSelectedLayoutSegments } from "next/navigation";
+import { ThemeProvider as NextThemes } from "next-themes";
+import type { ReactNode } from "react";
+
+type ForcedMode = "dark" | "light" | "none";
+type RouteTheme = {
+  group: string;
+  forcedMode?: ForcedMode;
+};
+
+function selectedPathFromSegments(segments: readonly string[]): string {
+  const path = segments
+    .filter((segment) => segment !== "" && !segment.startsWith("("))
+    .join("/");
+
+  return path ? `/${path}` : "/";
+}
+
+function resolveRouteTheme(
+  segments: readonly string[],
+): RouteTheme | undefined {
+  const selectedPath = selectedPathFromSegments(segments);
+  let match: RouteTheme | undefined;
+  let matchLength = 0;
+
+  const entries = Object.entries(routeThemes) as Array<[string, RouteTheme]>;
+  for (const [basePath, routeTheme] of entries) {
+    if (selectedPath === basePath || selectedPath.startsWith(`${basePath}/`)) {
+      if (basePath.length > matchLength) {
+        match = routeTheme;
+        matchLength = basePath.length;
+      }
+    }
+  }
+
+  return match;
+}
+
+function effectiveForcedMode(routeTheme: RouteTheme | undefined): ForcedMode {
+  if (routeTheme?.forcedMode) return routeTheme.forcedMode;
+
+  return ROOT_FORCED_MODE ?? "none";
+}
+
+export function PublishOSThemeProvider({ children }: { children: ReactNode }) {
+  const routeTheme = resolveRouteTheme(useSelectedLayoutSegments());
+  const forcedMode = effectiveForcedMode(routeTheme);
+  const forcedTheme = forcedMode === "none" ? undefined : forcedMode;
+
+  return (
+    <NextThemes
+      attribute="class"
+      defaultTheme={ROOT_DEFAULT_MODE}
+      disableTransitionOnChange
+      enableSystem
+      forcedTheme={forcedTheme}
+    >
+      <ThemeScopeProvider group={routeTheme?.group}>
+        <div
+          className="contents"
+          data-theme-root=""
+          data-group={routeTheme?.group ?? ""}
+        >
+          {children}
+        </div>
+      </ThemeScopeProvider>
+    </NextThemes>
+  );
+}

package/compiler-assets/nextjs/shims/root-page.tsx

@@ -0,0 +1,13 @@
+import manifest from "@manifest";
+import {
+  createRootMetadata,
+  createRootPage,
+} from "@publish.os/nextjs/kernel/routes/pages/root";
+import { ogManifest } from "@source/.publishos/og-manifest.generated";
+import RootPage from "@source/page";
+import type { Metadata } from "next";
+
+const route = { manifest, ogManifest, RootPage } as const;
+
+export default createRootPage(route);
+export const metadata: Metadata = createRootMetadata(route);

package/compiler-assets/nextjs/shims/theme-defaults.css

@@ -0,0 +1,177 @@
+.PUBLISHOS_THEME_SELECTOR {
+  --surface-page: var(--neutral-100);
+  --surface-1: var(--neutral-100);
+  --surface-2: var(--neutral-200);
+  --surface-3: var(--neutral-300);
+  --surface-4: var(--neutral-400);
+  --surface-hover: var(--surface-3);
+  --surface-active: var(--surface-4);
+
+  --foreground-1: var(--neutral-1200);
+  --foreground-2: var(--neutral-1100);
+  --foreground-3: var(--neutral-1000);
+  --foreground-4: var(--neutral-800);
+
+  --stroke-1: var(--neutral-800);
+  --stroke-2: var(--neutral-700);
+  --stroke-3: var(--neutral-500);
+  --stroke-4: var(--neutral-400);
+  --backdrop: rgb(0 0 0 / 72%);
+
+  --accent-1: var(--accent);
+  --accent-2: color-mix(in oklch, var(--accent) 18%, transparent);
+  --accent-3: color-mix(in oklch, var(--accent) 12%, transparent);
+  --accent-4: color-mix(in oklch, var(--accent) 6%, transparent);
+  /* biome-ignore lint/correctness/noUnknownFunction: CSS Color 5. */
+  --accent-foreground: contrast-color(var(--accent-1));
+
+  --accent-1-foreground: var(--accent-foreground);
+  --accent-1-stroke: var(--accent-1);
+  --accent-1-hover: oklch(
+    from var(--accent-1) calc(l - 0.025) calc(c * 1.02) h
+  );
+  --accent-1-active: oklch(
+    from var(--accent-1) calc(l - 0.055) calc(c * 1.06) h
+  );
+
+  /* biome-ignore lint/correctness/noUnknownFunction: CSS Color 5. */
+  --accent-2-foreground: contrast-color(var(--accent-2));
+  --accent-2-stroke: color-mix(in oklch, var(--accent-2) 70%, var(--accent));
+  --accent-2-hover: color-mix(in oklch, var(--accent-2) 75%, var(--accent));
+  --accent-2-active: color-mix(in oklch, var(--accent-2) 60%, var(--accent));
+
+  /* biome-ignore lint/correctness/noUnknownFunction: CSS Color 5. */
+  --accent-3-foreground: contrast-color(var(--accent-3));
+  --accent-3-stroke: color-mix(in oklch, var(--accent-3) 55%, var(--accent));
+  --accent-3-hover: color-mix(in oklch, var(--accent-3) 75%, var(--accent));
+  --accent-3-active: color-mix(in oklch, var(--accent-3) 60%, var(--accent));
+
+  /* biome-ignore lint/correctness/noUnknownFunction: CSS Color 5. */
+  --accent-4-foreground: contrast-color(var(--accent-4));
+  --accent-4-stroke: color-mix(in oklch, var(--accent-4) 45%, var(--accent));
+  --accent-4-hover: color-mix(in oklch, var(--accent-4) 70%, var(--accent));
+  --accent-4-active: color-mix(in oklch, var(--accent-4) 55%, var(--accent));
+
+  --focus-stroke: var(--accent-3-stroke);
+  --selection-surface: var(--accent-2-active);
+  --selection-foreground: var(--foreground-1);
+  --progress-track-surface: transparent;
+  --progress-indicator-surface: var(--accent-1);
+  --progress-height: 2px;
+  --media-backdrop: var(--backdrop);
+  --media-surface: var(--neutral-1200);
+  --media-preview-backdrop: color-mix(
+    in oklab,
+    var(--backdrop) 28%,
+    transparent
+  );
+  --media-preview-backdrop-hover: color-mix(
+    in oklab,
+    var(--backdrop) 40%,
+    transparent
+  );
+  --media-ambient-surface: color-mix(
+    in oklab,
+    var(--neutral-100) 8%,
+    transparent
+  );
+  --media-control-surface: color-mix(
+    in oklab,
+    var(--neutral-1200) 72%,
+    transparent
+  );
+  --media-control-foreground: var(--neutral-100);
+  --media-control-stroke: color-mix(
+    in oklab,
+    var(--neutral-100) 40%,
+    transparent
+  );
+
+  --success-100: light-dark(#effaf7, #0d1816);
+  --success-200: light-dark(#e2f4ee, #10211e);
+  --success-300: light-dark(#c9e9df, #12312c);
+  --success-400: light-dark(#a9d9cd, #164238);
+  --success-500: light-dark(#83c7ba, #1a5346);
+  --success-600: light-dark(#5db3a5, #206655);
+  --success-700: light-dark(#399a8d, #297c68);
+  --success-800: light-dark(#258b80, #36927a);
+  --success-900: light-dark(#1d8178, #50ab91);
+  --success-1000: light-dark(#176e66, #65bea1);
+  --success-1100: light-dark(#0f5b55, #8bd0b7);
+  --success-1200: light-dark(#073f3c, #c4f0df);
+
+  --warning-100: light-dark(#fffaf0, #1e1507);
+  --warning-200: light-dark(#fff3da, #281b07);
+  --warning-300: light-dark(#ffe7b5, #392300);
+  --warning-400: light-dark(#ffda92, #4b2d00);
+  --warning-500: light-dark(#f8c56e, #5d3a00);
+  --warning-600: light-dark(#eeb050, #704900);
+  --warning-700: light-dark(#dd9f35, #895a00);
+  --warning-800: light-dark(#ca8816, #a86c00);
+  --warning-900: #ed940f;
+  --warning-1000: light-dark(#c97a09, #f5aa35);
+  --warning-1100: light-dark(#835000, #ffc978);
+  --warning-1200: light-dark(#4d2d00, #ffe9c5);
+
+  --danger-100: light-dark(#fffcfc, #180e0e);
+  --danger-200: light-dark(#fff7f7, #221212);
+  --danger-300: light-dark(#feebeb, #410a11);
+  --danger-400: light-dark(#ffdcdc, #590010);
+  --danger-500: light-dark(#ffcfce, #6c0017);
+  --danger-600: light-dark(#fabfbf, #7e0c22);
+  --danger-700: light-dark(#f1acac, #991f31);
+  --danger-800: light-dark(#e79293, #c62941);
+  --danger-900: #ce3247;
+  --danger-1000: #be1f3a;
+  --danger-1100: light-dark(#ca2d44, #ff8e92);
+  --danger-1200: light-dark(#631921, #ffcdcd);
+
+  --info-100: light-dark(hsl(198 83.3% 97.6%), hsl(200.9 62.2% 7.3%));
+  --info-200: light-dark(hsl(195.8 76% 95.1%), hsl(201.3 63.3% 9.6%));
+  --info-300: light-dark(hsl(195.9 73.9% 91%), hsl(200 70.6% 13.3%));
+  --info-400: light-dark(hsl(195.3 68% 85.3%), hsl(199.4 74.7% 17.1%));
+  --info-500: light-dark(hsl(195.6 63.5% 77.5%), hsl(198.5 75.7% 21%));
+  --info-600: light-dark(hsl(196.8 61% 67.8%), hsl(197.3 75.2% 25.3%));
+  --info-700: light-dark(hsl(198 58% 57.1%), hsl(197.2 75.3% 31.8%));
+  --info-800: light-dark(hsl(197.9 64.2% 47.1%), hsl(197 77.1% 37.6%));
+  --info-900: hsl(198.8 80.8% 40.8%);
+  --info-1000: light-dark(hsl(199.2 85.9% 36.3%), hsl(198 62.1% 50.4%));
+  --info-1100: light-dark(hsl(201.7 90.8% 29.8%), hsl(198.8 66.1% 64.1%));
+  --info-1200: light-dark(hsl(201.8 100% 19.4%), hsl(197.7 100% 88%));
+
+  --typography-body-foreground: var(--foreground-2);
+  --typography-heading-foreground: var(--foreground-1);
+  --typography-lead-foreground: var(--foreground-3);
+  --typography-link-foreground: var(--accent-1);
+  --typography-strong-foreground: var(--foreground-1);
+  --typography-counter-foreground: var(--foreground-4);
+  --typography-bullet-foreground: var(--stroke-1);
+  --typography-rule-stroke: var(--stroke-4);
+  --typography-quote-foreground: var(--foreground-2);
+  --typography-quote-stroke: var(--stroke-4);
+  --typography-caption-foreground: var(--foreground-4);
+  --typography-code-foreground: var(--foreground-1);
+  --typography-code-surface: var(--surface-2);
+  --typography-code-stroke: var(--stroke-2);
+  --typography-variable-foreground: var(--accent-1);
+  --typography-pre-foreground: var(--foreground-2);
+  --typography-pre-surface: var(--surface-3);
+  --typography-pre-stroke: var(--stroke-3);
+  --typography-table-heading-stroke: var(--stroke-3);
+  --typography-table-cell-stroke: var(--stroke-4);
+  --typography-base-size: 1rem;
+  --typography-line-height: 1.65;
+
+  --floating-surface-1: var(--surface-1);
+  --floating-surface-2: var(--surface-2);
+  --floating-surface-3: var(--surface-3);
+  --floating-surface-4: var(--surface-4);
+  --floating-foreground-1: var(--foreground-1);
+  --floating-foreground-2: var(--foreground-2);
+  --floating-foreground-3: var(--foreground-3);
+  --floating-foreground-4: var(--foreground-4);
+  --floating-stroke-1: var(--stroke-1);
+  --floating-stroke-2: var(--stroke-2);
+  --floating-stroke-3: var(--stroke-3);
+  --floating-stroke-4: var(--stroke-4);
+}

package/dist/button-CFdx-ohV.d.ts

@@ -0,0 +1,20 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { ReactNode, ButtonHTMLAttributes } from 'react';
+
+declare const buttonVariants: (props?: ({
+    variant?: "solid" | "soft" | "outline" | "ghost" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    iconOnly?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariantProps = VariantProps<typeof buttonVariants>;
+type ButtonProps = {
+    active?: boolean;
+    children?: ReactNode;
+    className?: string;
+    leftIcon?: ReactNode;
+    loading?: boolean;
+    rightIcon?: ReactNode;
+} & ButtonVariantProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "className">;
+
+export type { ButtonVariantProps as B, ButtonProps as a };

package/dist/cache/tags.js

@@ -1,23 +1,15 @@
-// src/cache/tags.ts
+// src/cache-tags.ts
 import { createHash } from "crypto";
-var MAX_TAG_LEN = 256;
-var MAX_SEGMENT_LEN = 80;
-var TAG_PATTERN = /^[a-z0-9:_./-]+$/;
+var MAX_TAG_LEN = 256, MAX_SEGMENT_LEN = 80, TAG_PATTERN = /^[a-z0-9:_./-]+$/;
 function sha256(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 16);
 }
 function safeSegment(value) {
-  const raw = value.trim().toLowerCase() || "root";
-  const normalized = raw.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\//, "").replace(/\/$/, "").replace(/[^a-z0-9:_./-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-  const segment = normalized || "root";
-  if (segment.length <= MAX_SEGMENT_LEN) return segment;
-  return `${segment.slice(0, 48)}.${sha256(segment)}`;
+  let segment = (value.trim().toLowerCase() || "root").replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\//, "").replace(/\/$/, "").replace(/[^a-z0-9:_./-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "root";
+  return segment.length <= MAX_SEGMENT_LEN ? segment : `${segment.slice(0, 48)}.${sha256(segment)}`;
 }
 function assertTag(tag) {
-  if (tag.length > MAX_TAG_LEN || !TAG_PATTERN.test(tag)) {
-    return `tag:${sha256(tag)}`;
-  }
-  return tag;
+  return tag.length > MAX_TAG_LEN || !TAG_PATTERN.test(tag) ? `tag:${sha256(tag)}` : tag;
 }
 var tags = {
   site() {
@@ -30,7 +22,7 @@ var tags = {
     return assertTag(`group:${safeSegment(group)}`);
   },
   page(group, slug) {
-    const path = Array.isArray(slug) ? slug.join("/") : slug;
+    let path = Array.isArray(slug) ? slug.join("/") : slug;
     return assertTag(`page:${safeSegment(group)}:${safeSegment(path)}`);
   },
   manifest(contentHash) {