@nastechai-research/ui 0.13.2

package/dist/ui/components/poster.js

@@ -0,0 +1,256 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import fillerBg from "../../assets/filler-bg0.webp";
+import { cn } from "../../utils/index.js";
+import { Blink } from "./blink.js";
+import { ImageDistortion } from "./image-distortion.js";
+import { Typography } from "./typography/index.js";
+import { Small } from "./typography/small.js";
+const ASPECT_CONFIG = {
+  landscape: { defaultLayout: "split", height: 1080, width: 1920 },
+  portrait: { defaultLayout: "split", height: 1350, width: 1080 },
+  square: { defaultLayout: "split", height: 1080, width: 1080 },
+  story: { defaultLayout: "stacked", height: 1920, width: 1080 },
+  wide: { defaultLayout: "split", height: 900, width: 1600 }
+};
+const DEFAULT_SRC = fillerBg.src ?? fillerBg;
+function useUtcClock() {
+  const [now, setNow] = useState(null);
+  useEffect(() => {
+    setNow(/* @__PURE__ */ new Date());
+    const id = setInterval(() => setNow(/* @__PURE__ */ new Date()), 1e3);
+    return () => clearInterval(id);
+  }, []);
+  return now ? now.toISOString().slice(11, 19) : "--:--:--";
+}
+function CornerMark({ className }) {
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      "aria-hidden": true,
+      className: cn(
+        "pointer-events-none absolute block size-4 opacity-50",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "absolute top-1/2 left-0 h-px w-full -translate-y-1/2 bg-current" }),
+        /* @__PURE__ */ jsx("span", { className: "absolute top-0 left-1/2 h-full w-px -translate-x-1/2 bg-current" })
+      ]
+    }
+  );
+}
+function ChannelDot() {
+  return /* @__PURE__ */ jsxs("span", { className: "flex items-center gap-1.5", children: [
+    /* @__PURE__ */ jsx("span", { className: "bg-midground size-1.5 animate-pulse rounded-full" }),
+    /* @__PURE__ */ jsx(Small, { className: "opacity-70", children: "REC" })
+  ] });
+}
+function ScanlineOverlay() {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "aria-hidden": true,
+      className: "pointer-events-none absolute inset-0 opacity-20 mix-blend-overlay",
+      style: {
+        backgroundImage: "repeating-linear-gradient(0deg, transparent 0, transparent 2px, rgba(255,255,255,0.08) 2px, rgba(255,255,255,0.08) 3px)"
+      }
+    }
+  );
+}
+export function Poster({
+  aspect = "square",
+  autoPlay = "slash",
+  body,
+  border = true,
+  channel,
+  children,
+  className,
+  cornerMarks = true,
+  eyebrow,
+  headline = ["An Agent", "That Grows", "With You."],
+  layout,
+  scale = 1,
+  seal = "MIT \xB7 2026",
+  signature,
+  src = DEFAULT_SRC,
+  tags,
+  tint,
+  tintStrength,
+  variant = "vibe",
+  ...rest
+}) {
+  const config = ASPECT_CONFIG[aspect];
+  const resolvedLayout = layout ?? config.defaultLayout;
+  const outerProps = {
+    // `text-midground` (not `text-foreground`) is the readable on-canvas
+    // color across every lens. `--foreground` is really the lens's inversion
+    // layer color: on dark lenses it has `fgOpacity: 0` and resolves to
+    // fully-transparent via `color-mix`, which would make text invisible.
+    // `--midground` always has opacity 1 and picks up each lens's accent.
+    className: cn(
+      "text-midground relative overflow-hidden font-sans",
+      border && "border border-current/25",
+      className
+    ),
+    style: {
+      aspectRatio: `${config.width} / ${config.height}`,
+      background: "var(--background)",
+      containerType: "inline-size",
+      fontSize: `${16 / config.width * 100}cqi`,
+      maxHeight: "calc(100dvh - 8rem)",
+      maxWidth: "100%",
+      width: `${config.width * scale}px`
+    },
+    ...rest
+  };
+  if (variant === "vibe") {
+    return /* @__PURE__ */ jsx("div", { ...outerProps, children: /* @__PURE__ */ jsx(
+      VibeContent,
+      {
+        autoPlay,
+        channel,
+        cornerMarks,
+        signature,
+        src,
+        tint,
+        tintStrength
+      }
+    ) });
+  }
+  const headlineLines = Array.isArray(headline) ? headline : [headline];
+  return /* @__PURE__ */ jsxs("div", { ...outerProps, className: cn("flex flex-col", outerProps.className), children: [
+    /* @__PURE__ */ jsx(DispatchHeader, { channel }),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: cn(
+          "relative min-h-0 min-w-0 flex-1",
+          resolvedLayout === "split" ? "grid grid-cols-[3fr_2fr]" : "grid grid-rows-[3fr_2fr]"
+        ),
+        children: [
+          /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: cn(
+                "relative overflow-hidden border-current/20",
+                resolvedLayout === "split" ? "border-r" : "border-b"
+              ),
+              style: { backgroundColor: "var(--background)" },
+              children: [
+                /* @__PURE__ */ jsx(
+                  ImageDistortion,
+                  {
+                    autoPlay,
+                    src,
+                    tint,
+                    tintStrength
+                  }
+                ),
+                cornerMarks && /* @__PURE__ */ jsxs(Fragment, { children: [
+                  /* @__PURE__ */ jsx(CornerMark, { className: "top-3 left-3" }),
+                  /* @__PURE__ */ jsx(CornerMark, { className: "top-3 right-3" }),
+                  /* @__PURE__ */ jsx(CornerMark, { className: "bottom-3 left-3" }),
+                  /* @__PURE__ */ jsx(CornerMark, { className: "right-3 bottom-3" })
+                ] }),
+                /* @__PURE__ */ jsx(ScanlineOverlay, {}),
+                /* @__PURE__ */ jsx(Small, { className: "absolute bottom-4 left-4 z-1 opacity-80", children: "Hermes Agent" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs("aside", { className: "relative flex min-w-0 flex-col justify-between gap-8 p-8", children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-5", children: [
+              eyebrow && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+                /* @__PURE__ */ jsx("span", { className: "bg-midground/80 h-px flex-1" }),
+                /* @__PURE__ */ jsx(Small, { className: "opacity-80", children: eyebrow })
+              ] }),
+              children ?? /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsx(
+                  Typography,
+                  {
+                    as: "h1",
+                    className: "text-[2.75em] leading-[0.95] font-bold tracking-[-0.01em]",
+                    expanded: true,
+                    children: headlineLines.map((line, i) => /* @__PURE__ */ jsx("span", { className: "block", children: line }, `${line}-${i}`))
+                  }
+                ),
+                body && /* @__PURE__ */ jsx("p", { className: "text-[1.0625em] leading-[1.5] tracking-normal normal-case opacity-60", children: body })
+              ] })
+            ] }),
+            tags && tags.length > 0 && /* @__PURE__ */ jsx("ul", { className: "flex flex-col gap-2 border-t border-current/15 pt-4", children: tags.map((tag, i) => /* @__PURE__ */ jsxs(
+              "li",
+              {
+                className: "flex items-baseline justify-between gap-3",
+                children: [
+                  /* @__PURE__ */ jsx(Small, { className: "font-courier opacity-40", children: String(i + 1).padStart(3, "0") }),
+                  /* @__PURE__ */ jsx(Small, { className: "opacity-80", children: tag }),
+                  /* @__PURE__ */ jsx("span", { className: "mx-1 h-px flex-1 translate-y-[-3px] border-b border-dotted border-current/25" }),
+                  /* @__PURE__ */ jsxs(Small, { className: "font-courier opacity-40", children: [
+                    String(i + 1).padStart(2, "0"),
+                    "/",
+                    String(tags.length).padStart(2, "0")
+                  ] })
+                ]
+              },
+              `${tag}-${i}`
+            )) })
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs("footer", { className: "flex items-center justify-between gap-4 border-t border-current/20 px-6 py-3", children: [
+      /* @__PURE__ */ jsxs(Small, { className: "opacity-70", children: [
+        signature,
+        /* @__PURE__ */ jsx(Blink, {})
+      ] }),
+      /* @__PURE__ */ jsx(Small, { className: "font-courier opacity-40", children: seal })
+    ] })
+  ] });
+}
+function DispatchHeader({ channel }) {
+  const clock = useUtcClock();
+  return /* @__PURE__ */ jsxs("header", { className: "flex items-center justify-between gap-4 border-b border-current/20 px-6 py-3", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+      /* @__PURE__ */ jsx("span", { className: "bg-midground size-2 rounded-sm opacity-70" }),
+      /* @__PURE__ */ jsx(Small, { className: "opacity-70", children: channel })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-4", children: [
+      /* @__PURE__ */ jsx(ChannelDot, {}),
+      /* @__PURE__ */ jsxs(Small, { className: "font-courier opacity-50", children: [
+        clock,
+        " UTC"
+      ] })
+    ] })
+  ] });
+}
+function VibeContent({
+  autoPlay,
+  channel,
+  cornerMarks,
+  signature,
+  src,
+  tint,
+  tintStrength
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "absolute inset-0", children: [
+    /* @__PURE__ */ jsx(
+      ImageDistortion,
+      {
+        autoPlay,
+        src,
+        tint,
+        tintStrength
+      }
+    ),
+    cornerMarks && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(CornerMark, { className: "top-5 left-5" }),
+      /* @__PURE__ */ jsx(CornerMark, { className: "top-5 right-5" }),
+      /* @__PURE__ */ jsx(CornerMark, { className: "bottom-5 left-5" }),
+      /* @__PURE__ */ jsx(CornerMark, { className: "right-5 bottom-5" })
+    ] }),
+    /* @__PURE__ */ jsx(ScanlineOverlay, {}),
+    channel && /* @__PURE__ */ jsx(Small, { className: "absolute top-5 left-10 z-1 text-[0.75em] opacity-70", children: channel }),
+    /* @__PURE__ */ jsx(Small, { className: "absolute right-10 bottom-5 z-1 text-[0.75em] opacity-80", children: signature })
+  ] });
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport { useEffect, useState } from 'react'\n\nimport fillerBg from '../../assets/filler-bg0.webp'\nimport { cn } from '../../utils'\n\nimport { Blink } from './blink'\nimport { ImageDistortion } from './image-distortion'\nimport { Typography } from './typography'\nimport { Small } from './typography/small'\n\nimport type { AutoPlayPattern } from './image-distortion'\n\nconst ASPECT_CONFIG: Record<\n  PosterAspect,\n  { defaultLayout: 'split' | 'stacked'; height: number; width: number }\n> = {\n  landscape: { defaultLayout: 'split', height: 1080, width: 1920 },\n  portrait: { defaultLayout: 'split', height: 1350, width: 1080 },\n  square: { defaultLayout: 'split', height: 1080, width: 1080 },\n  story: { defaultLayout: 'stacked', height: 1920, width: 1080 },\n  wide: { defaultLayout: 'split', height: 900, width: 1600 }\n}\n\nconst DEFAULT_SRC =\n  (fillerBg as { src?: string }).src ?? (fillerBg as unknown as string)\n\nfunction useUtcClock() {\n  const [now, setNow] = useState<Date | null>(null)\n\n  useEffect(() => {\n    setNow(new Date())\n    const id = setInterval(() => setNow(new Date()), 1000)\n\n    return () => clearInterval(id)\n  }, [])\n\n  return now ? now.toISOString().slice(11, 19) : '--:--:--'\n}\n\nfunction CornerMark({ className }: { className?: string }) {\n  return (\n    <span\n      aria-hidden\n      className={cn(\n        'pointer-events-none absolute block size-4 opacity-50',\n        className\n      )}\n    >\n      <span className=\"absolute top-1/2 left-0 h-px w-full -translate-y-1/2 bg-current\" />\n\n      <span className=\"absolute top-0 left-1/2 h-full w-px -translate-x-1/2 bg-current\" />\n    </span>\n  )\n}\n\nfunction ChannelDot() {\n  return (\n    <span className=\"flex items-center gap-1.5\">\n      <span className=\"bg-midground size-1.5 animate-pulse rounded-full\" />\n\n      <Small className=\"opacity-70\">REC</Small>\n    </span>\n  )\n}\n\nfunction ScanlineOverlay() {\n  return (\n    <div\n      aria-hidden\n      className=\"pointer-events-none absolute inset-0 opacity-20 mix-blend-overlay\"\n      style={{\n        backgroundImage:\n          'repeating-linear-gradient(0deg, transparent 0, transparent 2px, rgba(255,255,255,0.08) 2px, rgba(255,255,255,0.08) 3px)'\n      }}\n    />\n  )\n}\n\n/**\n * Social-ready glitchy card built around the haptic-distortion image\n * component. The poster runs the sword-guy distortion on an auto-animated\n * slash pattern so it can be screen-recorded as a GIF without a human\n * moving a cursor.\n *\n * Two variants, matching actual use cases:\n * - `'vibe'` (default): full-bleed distorted image with just registration\n *   marks and a tiny \"Hermes Agent\" mark in the corner \u2014 mirrors the\n *   overlay on the Hermes agent website.\n * - `'dispatch'`: broadcast-card layout with sidebar copy, numbered tags,\n *   and chrome \u2014 for when the poster needs to carry information.\n */\nexport function Poster({\n  aspect = 'square',\n  autoPlay = 'slash',\n  body,\n  border = true,\n  channel,\n  children,\n  className,\n  cornerMarks = true,\n  eyebrow,\n  headline = ['An Agent', 'That Grows', 'With You.'],\n  layout,\n  scale = 1,\n  seal = 'MIT \u00B7 2026',\n  signature,\n  src = DEFAULT_SRC,\n  tags,\n  tint,\n  tintStrength,\n  variant = 'vibe',\n  ...rest\n}: PosterProps) {\n  const config = ASPECT_CONFIG[aspect]\n  const resolvedLayout = layout ?? config.defaultLayout\n\n  // Use aspect-ratio + max-width/height so the poster fluidly fits any parent\n  // (storybook iframe, a tweet preview, an embed) without getting clipped,\n  // but caps at the intended export width for screen-recording. `maxHeight`\n  // uses an absolute `dvh`-based value rather than `%` because `%` inside a\n  // flex container can cause the browser to clamp height without re-running\n  // aspect-ratio on width, producing a subtly wrong shape. An absolute cap\n  // leaves aspect-ratio fully in charge: once the height binds, width is\n  // re-derived correctly. `calc(100dvh - 8rem)` = viewport minus a typical\n  // host's vertical padding (e.g. Storybook's `p-8` = 4rem on each side),\n  // so the poster + padding fit within the viewport without ever producing\n  // scrollbars. Container queries tie all internal typography to the\n  // actual rendered width so headline/metadata scales along with the canvas.\n  const outerProps = {\n    // `text-midground` (not `text-foreground`) is the readable on-canvas\n    // color across every lens. `--foreground` is really the lens's inversion\n    // layer color: on dark lenses it has `fgOpacity: 0` and resolves to\n    // fully-transparent via `color-mix`, which would make text invisible.\n    // `--midground` always has opacity 1 and picks up each lens's accent.\n    className: cn(\n      'text-midground relative overflow-hidden font-sans',\n      border && 'border border-current/25',\n      className\n    ),\n    style: {\n      aspectRatio: `${config.width} / ${config.height}`,\n      background: 'var(--background)',\n      containerType: 'inline-size' as const,\n      fontSize: `${(16 / config.width) * 100}cqi`,\n      maxHeight: 'calc(100dvh - 8rem)',\n      maxWidth: '100%',\n      width: `${config.width * scale}px`\n    },\n    ...rest\n  }\n\n  if (variant === 'vibe') {\n    return (\n      <div {...outerProps}>\n        <VibeContent\n          autoPlay={autoPlay}\n          channel={channel}\n          cornerMarks={cornerMarks}\n          signature={signature}\n          src={src}\n          tint={tint}\n          tintStrength={tintStrength}\n        />\n      </div>\n    )\n  }\n\n  const headlineLines = Array.isArray(headline) ? headline : [headline]\n\n  return (\n    <div {...outerProps} className={cn('flex flex-col', outerProps.className)}>\n      <DispatchHeader channel={channel} />\n\n      <div\n        className={cn(\n          'relative min-h-0 min-w-0 flex-1',\n          resolvedLayout === 'split'\n            ? 'grid grid-cols-[3fr_2fr]'\n            : 'grid grid-rows-[3fr_2fr]'\n        )}\n      >\n        <div\n          className={cn(\n            'relative overflow-hidden border-current/20',\n            resolvedLayout === 'split' ? 'border-r' : 'border-b'\n          )}\n          style={{ backgroundColor: 'var(--background)' }}\n        >\n          <ImageDistortion\n            autoPlay={autoPlay}\n            src={src}\n            tint={tint}\n            tintStrength={tintStrength}\n          />\n\n          {cornerMarks && (\n            <>\n              <CornerMark className=\"top-3 left-3\" />\n              <CornerMark className=\"top-3 right-3\" />\n              <CornerMark className=\"bottom-3 left-3\" />\n              <CornerMark className=\"right-3 bottom-3\" />\n            </>\n          )}\n\n          <ScanlineOverlay />\n\n          <Small className=\"absolute bottom-4 left-4 z-1 opacity-80\">\n            Hermes Agent\n          </Small>\n        </div>\n\n        <aside className=\"relative flex min-w-0 flex-col justify-between gap-8 p-8\">\n          <div className=\"flex flex-col gap-5\">\n            {eyebrow && (\n              <div className=\"flex items-center gap-2\">\n                <span className=\"bg-midground/80 h-px flex-1\" />\n\n                <Small className=\"opacity-80\">{eyebrow}</Small>\n              </div>\n            )}\n\n            {children ?? (\n              <>\n                <Typography\n                  as=\"h1\"\n                  className=\"text-[2.75em] leading-[0.95] font-bold tracking-[-0.01em]\"\n                  expanded\n                >\n                  {headlineLines.map((line, i) => (\n                    <span className=\"block\" key={`${line}-${i}`}>\n                      {line}\n                    </span>\n                  ))}\n                </Typography>\n\n                {body && (\n                  <p className=\"text-[1.0625em] leading-[1.5] tracking-normal normal-case opacity-60\">\n                    {body}\n                  </p>\n                )}\n              </>\n            )}\n          </div>\n\n          {tags && tags.length > 0 && (\n            <ul className=\"flex flex-col gap-2 border-t border-current/15 pt-4\">\n              {tags.map((tag, i) => (\n                <li\n                  className=\"flex items-baseline justify-between gap-3\"\n                  key={`${tag}-${i}`}\n                >\n                  <Small className=\"font-courier opacity-40\">\n                    {String(i + 1).padStart(3, '0')}\n                  </Small>\n\n                  <Small className=\"opacity-80\">{tag}</Small>\n\n                  <span className=\"mx-1 h-px flex-1 translate-y-[-3px] border-b border-dotted border-current/25\" />\n\n                  <Small className=\"font-courier opacity-40\">\n                    {String(i + 1).padStart(2, '0')}/\n                    {String(tags.length).padStart(2, '0')}\n                  </Small>\n                </li>\n              ))}\n            </ul>\n          )}\n        </aside>\n      </div>\n\n      <footer className=\"flex items-center justify-between gap-4 border-t border-current/20 px-6 py-3\">\n        <Small className=\"opacity-70\">\n          {signature}\n\n          <Blink />\n        </Small>\n\n        <Small className=\"font-courier opacity-40\">{seal}</Small>\n      </footer>\n    </div>\n  )\n}\n\nfunction DispatchHeader({ channel }: { channel: React.ReactNode }) {\n  const clock = useUtcClock()\n\n  return (\n    <header className=\"flex items-center justify-between gap-4 border-b border-current/20 px-6 py-3\">\n      <div className=\"flex items-center gap-3\">\n        <span className=\"bg-midground size-2 rounded-sm opacity-70\" />\n\n        <Small className=\"opacity-70\">{channel}</Small>\n      </div>\n\n      <div className=\"flex items-center gap-4\">\n        <ChannelDot />\n\n        <Small className=\"font-courier opacity-50\">{clock} UTC</Small>\n      </div>\n    </header>\n  )\n}\n\ninterface VibeContentProps {\n  autoPlay: AutoPlayPattern\n  channel: React.ReactNode\n  cornerMarks: boolean\n  signature: React.ReactNode\n  src: string\n  tint?: string\n  tintStrength?: { active: number; inactive: number }\n}\n\nfunction VibeContent({\n  autoPlay,\n  channel,\n  cornerMarks,\n  signature,\n  src,\n  tint,\n  tintStrength\n}: VibeContentProps) {\n  // Absolute-inset-0 guarantees this fills the poster even when the outer\n  // container uses aspect-ratio-derived height in a browser that doesn't\n  // propagate that as a definite height for percentage-based children.\n  return (\n    <div className=\"absolute inset-0\">\n      <ImageDistortion\n        autoPlay={autoPlay}\n        src={src}\n        tint={tint}\n        tintStrength={tintStrength}\n      />\n\n      {cornerMarks && (\n        <>\n          <CornerMark className=\"top-5 left-5\" />\n          <CornerMark className=\"top-5 right-5\" />\n          <CornerMark className=\"bottom-5 left-5\" />\n          <CornerMark className=\"right-5 bottom-5\" />\n        </>\n      )}\n\n      <ScanlineOverlay />\n\n      {channel && (\n        <Small className=\"absolute top-5 left-10 z-1 text-[0.75em] opacity-70\">\n          {channel}\n        </Small>\n      )}\n\n      <Small className=\"absolute right-10 bottom-5 z-1 text-[0.75em] opacity-80\">\n        {signature}\n      </Small>\n    </div>\n  )\n}\n\nexport type PosterAspect =\n  | 'landscape'\n  | 'portrait'\n  | 'square'\n  | 'story'\n  | 'wide'\n\nexport type PosterVariant = 'dispatch' | 'vibe'\n\nexport interface PosterProps {\n  /** Output aspect ratio. Picks sensible defaults for common social formats. */\n  aspect?: PosterAspect\n  /** Distortion choreography pattern. Default: `'slash'`. */\n  autoPlay?: AutoPlayPattern\n  /** (`dispatch` only) Descriptive copy under the headline. */\n  body?: React.ReactNode\n  /** Show the thin outer frame around the poster. Default `true`. */\n  border?: boolean\n  /** Tiny broadcast-station label. Optional in `vibe`; shown in header in `dispatch`. */\n  channel?: React.ReactNode\n  /** (`dispatch` only) Override the sidebar content (takes precedence over headline/body). */\n  children?: React.ReactNode\n  className?: string\n  /** Show the small `+` die-line registration marks in the image corners. Default `true`. */\n  cornerMarks?: boolean\n  /** (`dispatch` only) Small tagline above the headline. */\n  eyebrow?: React.ReactNode\n  /** (`dispatch` only) Big expanded-typography headline. Pass an array of strings to stack lines. */\n  headline?: string[] | string\n  /** (`dispatch` only) Force stacked vs split layout. Default inferred from `aspect`. */\n  layout?: 'split' | 'stacked'\n  /** Render scale. 1 = full canvas (1080px+ base width). */\n  scale?: number\n  /** (`dispatch` only) Small legal / signature line at the bottom-right. */\n  seal?: React.ReactNode\n  /**\n   * Signature mark. In `vibe` this is the small \"Hermes Agent\" overlay in the\n   * bottom-right. In `dispatch` this is the URL / CTA in the footer.\n   */\n  signature?: React.ReactNode\n  /** Override the poster image. Defaults to the Hermes \"filler-bg0\" asset. */\n  src?: string\n  /** (`dispatch` only) Ranked list of features / pricing tiers rendered as a numbered sidebar list. */\n  tags?: string[]\n  /** Shader tint overlay. Great for tier-colored variants. */\n  tint?: string\n  /** Active / inactive tint strength \u2014 defaults match `ImageDistortion`. */\n  tintStrength?: { active: number; inactive: number }\n  /** Layout variant. `'vibe'` (default) is full-bleed image; `'dispatch'` is the broadcast-card with sidebar copy. */\n  variant?: PosterVariant\n}\n"],
  "mappings": ";AA2CI,SA2JQ,UApJN,KAPF;AAzCJ,SAAS,WAAW,gBAAgB;AAEpC,OAAO,cAAc;AACrB,SAAS,UAAU;AAEnB,SAAS,aAAa;AACtB,SAAS,uBAAuB;AAChC,SAAS,kBAAkB;AAC3B,SAAS,aAAa;AAItB,MAAM,gBAGF;AAAA,EACF,WAAW,EAAE,eAAe,SAAS,QAAQ,MAAM,OAAO,KAAK;AAAA,EAC/D,UAAU,EAAE,eAAe,SAAS,QAAQ,MAAM,OAAO,KAAK;AAAA,EAC9D,QAAQ,EAAE,eAAe,SAAS,QAAQ,MAAM,OAAO,KAAK;AAAA,EAC5D,OAAO,EAAE,eAAe,WAAW,QAAQ,MAAM,OAAO,KAAK;AAAA,EAC7D,MAAM,EAAE,eAAe,SAAS,QAAQ,KAAK,OAAO,KAAK;AAC3D;AAEA,MAAM,cACH,SAA8B,OAAQ;AAEzC,SAAS,cAAc;AACrB,QAAM,CAAC,KAAK,MAAM,IAAI,SAAsB,IAAI;AAEhD,YAAU,MAAM;AACd,WAAO,oBAAI,KAAK,CAAC;AACjB,UAAM,KAAK,YAAY,MAAM,OAAO,oBAAI,KAAK,CAAC,GAAG,GAAI;AAErD,WAAO,MAAM,cAAc,EAAE;AAAA,EAC/B,GAAG,CAAC,CAAC;AAEL,SAAO,MAAM,IAAI,YAAY,EAAE,MAAM,IAAI,EAAE,IAAI;AACjD;AAEA,SAAS,WAAW,EAAE,UAAU,GAA2B;AACzD,SACE;AAAA,IAAC;AAAA;AAAA,MACC,eAAW;AAAA,MACX,WAAW;AAAA,QACT;AAAA,QACA;AAAA,MACF;AAAA,MAEA;AAAA,4BAAC,UAAK,WAAU,mEAAkE;AAAA,QAElF,oBAAC,UAAK,WAAU,mEAAkE;AAAA;AAAA;AAAA,EACpF;AAEJ;AAEA,SAAS,aAAa;AACpB,SACE,qBAAC,UAAK,WAAU,6BACd;AAAA,wBAAC,UAAK,WAAU,oDAAmD;AAAA,IAEnE,oBAAC,SAAM,WAAU,cAAa,iBAAG;AAAA,KACnC;AAEJ;AAEA,SAAS,kBAAkB;AACzB,SACE;AAAA,IAAC;AAAA;AAAA,MACC,eAAW;AAAA,MACX,WAAU;AAAA,MACV,OAAO;AAAA,QACL,iBACE;AAAA,MACJ;AAAA;AAAA,EACF;AAEJ;AAeO,gBAAS,OAAO;AAAA,EACrB,SAAS;AAAA,EACT,WAAW;AAAA,EACX;AAAA,EACA,SAAS;AAAA,EACT;AAAA,EACA;AAAA,EACA;AAAA,EACA,cAAc;AAAA,EACd;AAAA,EACA,WAAW,CAAC,YAAY,cAAc,WAAW;AAAA,EACjD;AAAA,EACA,QAAQ;AAAA,EACR,OAAO;AAAA,EACP;AAAA,EACA,MAAM;AAAA,EACN;AAAA,EACA;AAAA,EACA;AAAA,EACA,UAAU;AAAA,EACV,GAAG;AACL,GAAgB;AACd,QAAM,SAAS,cAAc,MAAM;AACnC,QAAM,iBAAiB,UAAU,OAAO;AAcxC,QAAM,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMjB,WAAW;AAAA,MACT;AAAA,MACA,UAAU;AAAA,MACV;AAAA,IACF;AAAA,IACA,OAAO;AAAA,MACL,aAAa,GAAG,OAAO,KAAK,MAAM,OAAO,MAAM;AAAA,MAC/C,YAAY;AAAA,MACZ,eAAe;AAAA,MACf,UAAU,GAAI,KAAK,OAAO,QAAS,GAAG;AAAA,MACtC,WAAW;AAAA,MACX,UAAU;AAAA,MACV,OAAO,GAAG,OAAO,QAAQ,KAAK;AAAA,IAChC;AAAA,IACA,GAAG;AAAA,EACL;AAEA,MAAI,YAAY,QAAQ;AACtB,WACE,oBAAC,SAAK,GAAG,YACP;AAAA,MAAC;AAAA;AAAA,QACC;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA;AAAA,IACF,GACF;AAAA,EAEJ;AAEA,QAAM,gBAAgB,MAAM,QAAQ,QAAQ,IAAI,WAAW,CAAC,QAAQ;AAEpE,SACE,qBAAC,SAAK,GAAG,YAAY,WAAW,GAAG,iBAAiB,WAAW,SAAS,GACtE;AAAA,wBAAC,kBAAe,SAAkB;AAAA,IAElC;AAAA,MAAC;AAAA;AAAA,QACC,WAAW;AAAA,UACT;AAAA,UACA,mBAAmB,UACf,6BACA;AAAA,QACN;AAAA,QAEA;AAAA;AAAA,YAAC;AAAA;AAAA,cACC,WAAW;AAAA,gBACT;AAAA,gBACA,mBAAmB,UAAU,aAAa;AAAA,cAC5C;AAAA,cACA,OAAO,EAAE,iBAAiB,oBAAoB;AAAA,cAE9C;AAAA;AAAA,kBAAC;AAAA;AAAA,oBACC;AAAA,oBACA;AAAA,oBACA;AAAA,oBACA;AAAA;AAAA,gBACF;AAAA,gBAEC,eACC,iCACE;AAAA,sCAAC,cAAW,WAAU,gBAAe;AAAA,kBACrC,oBAAC,cAAW,WAAU,iBAAgB;AAAA,kBACtC,oBAAC,cAAW,WAAU,mBAAkB;AAAA,kBACxC,oBAAC,cAAW,WAAU,oBAAmB;AAAA,mBAC3C;AAAA,gBAGF,oBAAC,mBAAgB;AAAA,gBAEjB,oBAAC,SAAM,WAAU,2CAA0C,0BAE3D;AAAA;AAAA;AAAA,UACF;AAAA,UAEA,qBAAC,WAAM,WAAU,4DACf;AAAA,iCAAC,SAAI,WAAU,uBACZ;AAAA,yBACC,qBAAC,SAAI,WAAU,2BACb;AAAA,oCAAC,UAAK,WAAU,+BAA8B;AAAA,gBAE9C,oBAAC,SAAM,WAAU,cAAc,mBAAQ;AAAA,iBACzC;AAAA,cAGD,YACC,iCACE;AAAA;AAAA,kBAAC;AAAA;AAAA,oBACC,IAAG;AAAA,oBACH,WAAU;AAAA,oBACV,UAAQ;AAAA,oBAEP,wBAAc,IAAI,CAAC,MAAM,MACxB,oBAAC,UAAK,WAAU,SACb,kBAD0B,GAAG,IAAI,IAAI,CAAC,EAEzC,CACD;AAAA;AAAA,gBACH;AAAA,gBAEC,QACC,oBAAC,OAAE,WAAU,wEACV,gBACH;AAAA,iBAEJ;AAAA,eAEJ;AAAA,YAEC,QAAQ,KAAK,SAAS,KACrB,oBAAC,QAAG,WAAU,uDACX,eAAK,IAAI,CAAC,KAAK,MACd;AAAA,cAAC;AAAA;AAAA,gBACC,WAAU;AAAA,gBAGV;AAAA,sCAAC,SAAM,WAAU,2BACd,iBAAO,IAAI,CAAC,EAAE,SAAS,GAAG,GAAG,GAChC;AAAA,kBAEA,oBAAC,SAAM,WAAU,cAAc,eAAI;AAAA,kBAEnC,oBAAC,UAAK,WAAU,gFAA+E;AAAA,kBAE/F,qBAAC,SAAM,WAAU,2BACd;AAAA,2BAAO,IAAI,CAAC,EAAE,SAAS,GAAG,GAAG;AAAA,oBAAE;AAAA,oBAC/B,OAAO,KAAK,MAAM,EAAE,SAAS,GAAG,GAAG;AAAA,qBACtC;AAAA;AAAA;AAAA,cAbK,GAAG,GAAG,IAAI,CAAC;AAAA,YAclB,CACD,GACH;AAAA,aAEJ;AAAA;AAAA;AAAA,IACF;AAAA,IAEA,qBAAC,YAAO,WAAU,gFAChB;AAAA,2BAAC,SAAM,WAAU,cACd;AAAA;AAAA,QAED,oBAAC,SAAM;AAAA,SACT;AAAA,MAEA,oBAAC,SAAM,WAAU,2BAA2B,gBAAK;AAAA,OACnD;AAAA,KACF;AAEJ;AAEA,SAAS,eAAe,EAAE,QAAQ,GAAiC;AACjE,QAAM,QAAQ,YAAY;AAE1B,SACE,qBAAC,YAAO,WAAU,gFAChB;AAAA,yBAAC,SAAI,WAAU,2BACb;AAAA,0BAAC,UAAK,WAAU,6CAA4C;AAAA,MAE5D,oBAAC,SAAM,WAAU,cAAc,mBAAQ;AAAA,OACzC;AAAA,IAEA,qBAAC,SAAI,WAAU,2BACb;AAAA,0BAAC,cAAW;AAAA,MAEZ,qBAAC,SAAM,WAAU,2BAA2B;AAAA;AAAA,QAAM;AAAA,SAAI;AAAA,OACxD;AAAA,KACF;AAEJ;AAYA,SAAS,YAAY;AAAA,EACnB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAAqB;AAInB,SACE,qBAAC,SAAI,WAAU,oBACb;AAAA;AAAA,MAAC;AAAA;AAAA,QACC;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA;AAAA,IACF;AAAA,IAEC,eACC,iCACE;AAAA,0BAAC,cAAW,WAAU,gBAAe;AAAA,MACrC,oBAAC,cAAW,WAAU,iBAAgB;AAAA,MACtC,oBAAC,cAAW,WAAU,mBAAkB;AAAA,MACxC,oBAAC,cAAW,WAAU,oBAAmB;AAAA,OAC3C;AAAA,IAGF,oBAAC,mBAAgB;AAAA,IAEhB,WACC,oBAAC,SAAM,WAAU,uDACd,mBACH;AAAA,IAGF,oBAAC,SAAM,WAAU,2DACd,qBACH;AAAA,KACF;AAEJ;",
  "names": []
}


package/dist/ui/components/progress.d.ts

@@ -0,0 +1,9 @@
+import { type TypographyProps } from './typography';
+export declare const Progress: ({ animate, barProps, children, className, speed, value, ...props }: ProgressProps) => import("react").JSX.Element;
+interface ProgressProps extends React.ComponentProps<'div'> {
+    animate?: boolean;
+    barProps?: TypographyProps<'span'>;
+    speed?: number;
+    value: number;
+}
+export {};

package/dist/ui/components/progress.js

@@ -0,0 +1,53 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cn } from "../../utils/index.js";
+import { Typography } from "./typography/index.js";
+export const Progress = ({
+  animate = true,
+  barProps,
+  children,
+  className,
+  speed = 0.4,
+  value,
+  ...props
+}) => /* @__PURE__ */ jsxs(
+  "div",
+  {
+    className: cn(
+      "relative flex min-h-[2.3rem] min-w-0 flex-1 items-stretch overflow-hidden",
+      className
+    ),
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx(
+        Typography,
+        {
+          ...barProps,
+          className: cn(
+            "shrink-0 translate-y-0.5 truncate py-2",
+            "bg-midground/20",
+            children ? "px-2" : "px-0",
+            barProps?.className
+          ),
+          mono: true,
+          style: {
+            ...animate && { transition: `width ${speed}s steps(10, end)` },
+            width: `${value}%`,
+            ...barProps?.style
+          },
+          children
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "flex-1",
+          style: {
+            "--x": ".5rem",
+            backgroundImage: `repeating-linear-gradient(to right, transparent 0 var(--x), color-mix(in srgb, var(--color-midground) 17%, transparent) var(--x) calc(var(--x) + 1px))`
+          }
+        }
+      )
+    ]
+  }
+);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/scene-canvas.d.ts

@@ -0,0 +1,23 @@
+export declare function SceneCanvas({ camera, children, className, contained, frameloop, noEvents, style }: SceneCanvasProps): import("react").JSX.Element;
+interface SceneCanvasProps {
+    camera?: {
+        far?: number;
+        near?: number;
+        position?: [number, number, number];
+        zoom?: number;
+    };
+    children: () => React.ReactNode;
+    className?: string;
+    contained?: boolean;
+    /**
+     * R3F frame-loop mode. Defaults to `'always'` for backwards
+     * compatibility, but `'demand'` is strongly preferred for static
+     * scenes (use `invalidate()` from `useThree` to request frames). The
+     * canvas additionally pauses (forces `'never'`) while the document
+     * is hidden, regardless of this setting.
+     */
+    frameloop?: 'always' | 'demand' | 'never';
+    noEvents?: boolean;
+    style?: React.CSSProperties;
+}
+export {};

package/dist/ui/components/scene-canvas.js

@@ -0,0 +1,179 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Canvas, useFrame, useThree } from "@react-three/fiber";
+import {
+  Suspense,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import * as THREE from "three";
+const GL = {
+  alpha: true,
+  antialias: true,
+  depth: true,
+  outputColorSpace: "srgb",
+  powerPreference: "high-performance",
+  stencil: false
+};
+const tmp = {
+  camDir: new THREE.Vector3(),
+  hit: new THREE.Vector3(),
+  ndc: new THREE.Vector2(),
+  origin: new THREE.Vector3(0, 0, 0),
+  plane: new THREE.Plane(),
+  ray: new THREE.Raycaster()
+};
+function useBounds(target) {
+  const bounds = useRef(null);
+  useLayoutEffect(() => {
+    if (!target) {
+      return;
+    }
+    const measure = () => {
+      const b = target.getBoundingClientRect();
+      bounds.current = {
+        height: b.height,
+        pageX: b.left + window.scrollX,
+        pageY: b.top + window.scrollY,
+        width: b.width
+      };
+    };
+    measure();
+    const ro = new ResizeObserver(measure);
+    ro.observe(target);
+    ro.observe(document.body);
+    window.addEventListener("resize", measure, { passive: true });
+    return () => {
+      ro.disconnect();
+      window.removeEventListener("resize", measure);
+    };
+  }, [target]);
+  return bounds;
+}
+function PositionedGroup({
+  baseZoom,
+  bounds,
+  children
+}) {
+  const ref = useRef(null);
+  const { camera, size, viewport } = useThree();
+  useFrame(() => {
+    const g = ref.current;
+    const b = bounds.current;
+    if (!g || !b) {
+      return;
+    }
+    const left = b.pageX - window.scrollX;
+    const top = b.pageY - window.scrollY;
+    tmp.ndc.set(
+      (left + b.width / 2) / size.width * 2 - 1,
+      1 - (top + b.height / 2) / size.height * 2
+    );
+    camera.getWorldDirection(tmp.camDir);
+    tmp.plane.setFromNormalAndCoplanarPoint(tmp.camDir, tmp.origin);
+    tmp.ray.setFromCamera(tmp.ndc, camera);
+    const hit = tmp.ray.ray.intersectPlane(tmp.plane, tmp.hit);
+    if (hit) {
+      g.position.copy(hit);
+    }
+    const zoom = camera.zoom ?? 1;
+    g.scale.setScalar(
+      Math.min(
+        b.width / size.width * viewport.width,
+        b.height / size.height * viewport.height
+      ) * (baseZoom > 0 ? zoom / baseZoom : 1)
+    );
+  });
+  return /* @__PURE__ */ jsx("group", { ref, children });
+}
+export function SceneCanvas({
+  camera,
+  children,
+  className,
+  contained,
+  frameloop = "always",
+  noEvents,
+  style
+}) {
+  const [container, setContainer] = useState(null);
+  const baseZoom = camera?.zoom ?? 150;
+  const bounds = useBounds(
+    contained ? container?.parentElement ?? null : null
+  );
+  useEffect(() => {
+    const el = contained && !noEvents ? container : null;
+    if (!el) {
+      return;
+    }
+    const lock = () => document.body.style.userSelect = "none";
+    const unlock = () => document.body.style.userSelect = "";
+    el.addEventListener("pointerdown", lock);
+    window.addEventListener("pointerup", unlock);
+    return () => {
+      el.removeEventListener("pointerdown", lock);
+      window.removeEventListener("pointerup", unlock);
+    };
+  }, [container, contained, noEvents]);
+  const [pageHidden, setPageHidden] = useState(
+    typeof document !== "undefined" && document.hidden
+  );
+  useEffect(() => {
+    const onVisibility = () => setPageHidden(document.hidden);
+    document.addEventListener("visibilitychange", onVisibility);
+    return () => document.removeEventListener("visibilitychange", onVisibility);
+  }, []);
+  const effectiveFrameloop = pageHidden ? "never" : frameloop;
+  const cam = useMemo(
+    () => ({
+      far: camera?.far ?? 100,
+      near: camera?.near ?? -100,
+      position: camera?.position ?? [0, 0, 10],
+      zoom: baseZoom * (contained ? 1 : 2)
+    }),
+    [baseZoom, camera, contained]
+  );
+  const canvas = /* @__PURE__ */ jsx(
+    Canvas,
+    {
+      camera: cam,
+      className,
+      dpr: [1, 2],
+      eventPrefix: contained ? "client" : "offset",
+      eventSource: contained ? container ?? void 0 : void 0,
+      frameloop: effectiveFrameloop,
+      gl: GL,
+      orthographic: true,
+      style: contained ? {
+        height: "100dvh",
+        inset: 0,
+        pointerEvents: "none",
+        position: "fixed",
+        width: "100dvw",
+        zIndex: 0,
+        ...style
+      } : { height: "100%", width: "100%", ...style },
+      children: contained ? /* @__PURE__ */ jsx(PositionedGroup, { baseZoom, bounds, children: children() }) : children()
+    }
+  );
+  return contained ? /* @__PURE__ */ jsxs(Suspense, { children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: setContainer,
+        style: {
+          height: "100%",
+          inset: 0,
+          pointerEvents: noEvents ? "none" : "auto",
+          position: "absolute",
+          width: "100%",
+          zIndex: 1
+        }
+      }
+    ),
+    canvas
+  ] }) : canvas;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport { Canvas, useFrame, useThree } from '@react-three/fiber'\nimport {\n  Suspense,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState\n} from 'react'\nimport * as THREE from 'three'\n\nconst GL = {\n  alpha: true,\n  antialias: true,\n  depth: true,\n  outputColorSpace: 'srgb',\n  powerPreference: 'high-performance',\n  stencil: false\n} as const\n\nconst tmp = {\n  camDir: new THREE.Vector3(),\n  hit: new THREE.Vector3(),\n  ndc: new THREE.Vector2(),\n  origin: new THREE.Vector3(0, 0, 0),\n  plane: new THREE.Plane(),\n  ray: new THREE.Raycaster()\n}\n\ntype Bounds = { height: number; pageX: number; pageY: number; width: number }\n\nfunction useBounds(target: HTMLElement | null) {\n  const bounds = useRef<Bounds | null>(null)\n\n  useLayoutEffect(() => {\n    if (!target) {\n      return\n    }\n\n    const measure = () => {\n      const b = target.getBoundingClientRect()\n      bounds.current = {\n        height: b.height,\n        pageX: b.left + window.scrollX,\n        pageY: b.top + window.scrollY,\n        width: b.width\n      }\n    }\n\n    measure()\n\n    const ro = new ResizeObserver(measure)\n    ro.observe(target)\n    ro.observe(document.body)\n    window.addEventListener('resize', measure, { passive: true })\n\n    return () => {\n      ro.disconnect()\n      window.removeEventListener('resize', measure)\n    }\n  }, [target])\n\n  return bounds\n}\n\nfunction PositionedGroup({\n  baseZoom,\n  bounds,\n  children\n}: React.PropsWithChildren<{\n  baseZoom: number\n  bounds: React.RefObject<Bounds | null>\n}>) {\n  const ref = useRef<THREE.Group>(null)\n  const { camera, size, viewport } = useThree()\n\n  useFrame(() => {\n    const g = ref.current\n    const b = bounds.current\n\n    if (!g || !b) {\n      return\n    }\n\n    const left = b.pageX - window.scrollX\n    const top = b.pageY - window.scrollY\n\n    tmp.ndc.set(\n      ((left + b.width / 2) / size.width) * 2 - 1,\n      1 - ((top + b.height / 2) / size.height) * 2\n    )\n\n    camera.getWorldDirection(tmp.camDir)\n    tmp.plane.setFromNormalAndCoplanarPoint(tmp.camDir, tmp.origin)\n    tmp.ray.setFromCamera(tmp.ndc, camera)\n\n    const hit = tmp.ray.ray.intersectPlane(tmp.plane, tmp.hit)\n\n    if (hit) {\n      g.position.copy(hit)\n    }\n\n    const zoom = (camera as THREE.Camera & { zoom?: number }).zoom ?? 1\n\n    g.scale.setScalar(\n      Math.min(\n        (b.width / size.width) * viewport.width,\n        (b.height / size.height) * viewport.height\n      ) * (baseZoom > 0 ? zoom / baseZoom : 1)\n    )\n  })\n\n  return <group ref={ref}>{children}</group>\n}\n\nexport function SceneCanvas({\n  camera,\n  children,\n  className,\n  contained,\n  frameloop = 'always',\n  noEvents,\n  style\n}: SceneCanvasProps) {\n  const [container, setContainer] = useState<HTMLDivElement | null>(null)\n  const baseZoom = camera?.zoom ?? 150\n\n  const bounds = useBounds(\n    contained ? (container?.parentElement ?? null) : null\n  )\n\n  useEffect(() => {\n    const el = contained && !noEvents ? container : null\n\n    if (!el) {\n      return\n    }\n\n    const lock = () => (document.body.style.userSelect = 'none')\n    const unlock = () => (document.body.style.userSelect = '')\n\n    el.addEventListener('pointerdown', lock)\n    window.addEventListener('pointerup', unlock)\n\n    return () => {\n      el.removeEventListener('pointerdown', lock)\n      window.removeEventListener('pointerup', unlock)\n    }\n  }, [container, contained, noEvents])\n\n  // Pause the R3F render loop when the tab is hidden. Even on\n  // `frameloop=\"always\"` scenes we don't want the GPU running while the\n  // user can't see anything \u2014 this is the dominant fix for the \"fans\n  // crank up after hours of idle\" symptom.\n  const [pageHidden, setPageHidden] = useState(\n    typeof document !== 'undefined' && document.hidden\n  )\n\n  useEffect(() => {\n    const onVisibility = () => setPageHidden(document.hidden)\n    document.addEventListener('visibilitychange', onVisibility)\n\n    return () => document.removeEventListener('visibilitychange', onVisibility)\n  }, [])\n\n  const effectiveFrameloop = pageHidden ? 'never' : frameloop\n\n  const cam = useMemo(\n    () => ({\n      far: camera?.far ?? 100,\n      near: camera?.near ?? -100,\n      position: camera?.position ?? ([0, 0, 10] as [number, number, number]),\n      zoom: baseZoom * (contained ? 1 : 2)\n    }),\n    [baseZoom, camera, contained]\n  )\n\n  const canvas = (\n    <Canvas\n      camera={cam}\n      className={className}\n      dpr={[1, 2]}\n      eventPrefix={contained ? 'client' : 'offset'}\n      eventSource={contained ? (container ?? undefined) : undefined}\n      frameloop={effectiveFrameloop}\n      gl={GL}\n      orthographic\n      style={\n        contained\n          ? {\n              height: '100dvh',\n              inset: 0,\n              pointerEvents: 'none',\n              position: 'fixed',\n              width: '100dvw',\n              zIndex: 0,\n              ...style\n            }\n          : { height: '100%', width: '100%', ...style }\n      }\n    >\n      {contained ? (\n        <PositionedGroup baseZoom={baseZoom} bounds={bounds}>\n          {children()}\n        </PositionedGroup>\n      ) : (\n        children()\n      )}\n    </Canvas>\n  )\n\n  return contained ? (\n    <Suspense>\n      <div\n        ref={setContainer}\n        style={{\n          height: '100%',\n          inset: 0,\n          pointerEvents: noEvents ? 'none' : 'auto',\n          position: 'absolute',\n          width: '100%',\n          zIndex: 1\n        }}\n      />\n      {canvas}\n    </Suspense>\n  ) : (\n    canvas\n  )\n}\n\ninterface SceneCanvasProps {\n  camera?: {\n    far?: number\n    near?: number\n    position?: [number, number, number]\n    zoom?: number\n  }\n  children: () => React.ReactNode\n  className?: string\n  contained?: boolean\n  /**\n   * R3F frame-loop mode. Defaults to `'always'` for backwards\n   * compatibility, but `'demand'` is strongly preferred for static\n   * scenes (use `invalidate()` from `useThree` to request frames). The\n   * canvas additionally pauses (forces `'never'`) while the document\n   * is hidden, regardless of this setting.\n   */\n  frameloop?: 'always' | 'demand' | 'never'\n  noEvents?: boolean\n  style?: React.CSSProperties\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/ui/components/scramble.d.ts

@@ -0,0 +1,9 @@
+import type { RefObject } from 'react';
+export declare function Scramble({ children, dur, spread, target }: ScrambleProps): import("react").JSX.Element;
+interface ScrambleProps {
+    children: string;
+    dur?: number;
+    spread?: number;
+    target?: RefObject<HTMLElement | null>;
+}
+export {};