The Open Standard for Generative UI
Add the Observability page, waitlist endpoint, and Early Access nav tag (#1057)
Parikshit Deshmukh539f1f5b51f6
diff --git a/docs/app/(home)/cloud/observability/CloudCtaSection.module.css b/docs/app/(home)/cloud/observability/CloudCtaSection.module.cssnew file mode 100644index 000000000..a3af569a8--- /dev/null+++ b/docs/app/(home)/cloud/observability/CloudCtaSection.module.css@@ -0,0 +1,72 @@+.section {+ width: 100%;+ padding: 120px var(--home-section-padding-inline) 0;+ background: var(--openui-foreground);+}++.inner {+ display: flex;+ align-items: center;+ justify-content: space-between;+ gap: 48px;+ width: 100%;+ max-width: 1200px;+ margin-inline: auto;+}++.title {+ flex: 1 1 auto;+ min-width: 0;+ max-width: 40rem;+ margin: 0;+ color: var(--openui-text-neutral-primary);+ font-family: var(--home-font-display);+ font-size: var(--home-title-size);+ font-weight: var(--home-title-weight);+ line-height: var(--home-title-leading);+ letter-spacing: var(--home-title-tracking);+}++.actions {+ display: flex;+ flex: 0 0 auto;+ align-items: center;+ gap: 12px;+}++.separator {+ width: 100%;+ max-width: 1200px;+ height: 1px;+ margin: 120px auto 0;+ background: var(--home-hairline);+}++@media (max-width: 1023px) {+ .section {+ padding-top: 96px;+ }++ .inner {+ flex-direction: column;+ align-items: flex-start;+ gap: 32px;+ }++ .separator {+ margin-top: 96px;+ }+}++@media (max-width: 767px) {+ .inner {+ align-items: center;+ text-align: center;+ }++ .actions {+ flex-direction: column;+ width: 100%;+ max-width: 320px;+ }+}diff --git a/docs/app/(home)/cloud/observability/CloudCtaSection.tsx b/docs/app/(home)/cloud/observability/CloudCtaSection.tsxnew file mode 100644index 000000000..893f74b9a--- /dev/null+++ b/docs/app/(home)/cloud/observability/CloudCtaSection.tsx@@ -0,0 +1,20 @@+import styles from "./CloudCtaSection.module.css";+import { EarlyAccessForm } from "./EarlyAccessForm";++export function CloudCtaSection() {+ return (+ <section className={styles.section} aria-labelledby="cloud-cta-title">+ <div className={styles.inner}>+ <h2 id="cloud-cta-title" className={styles.title}>+ Join waitlist for early access.+ </h2>+ {/* The same capture as the hero, so the page opens and closes on the+ one action. */}+ <div className={styles.actions}>+ <EarlyAccessForm />+ </div>+ </div>+ <div className={styles.separator} aria-hidden="true" />+ </section>+ );+}diff --git a/docs/app/(home)/cloud/observability/EarlyAccessForm.tsx b/docs/app/(home)/cloud/observability/EarlyAccessForm.tsxnew file mode 100644index 000000000..8af7b0f89--- /dev/null+++ b/docs/app/(home)/cloud/observability/EarlyAccessForm.tsx@@ -0,0 +1,128 @@+"use client";++import { ArrowRight } from "@phosphor-icons/react";+import { useEffect, useId, useRef, useState, type FormEvent } from "react";+import styles from "./page.module.css";++/* How long the confirmation hangs around before fading out. Long enough to read+ twice, short enough that it is gone by the time you scroll. */+const NOTICE_MS = 4000;++const SUCCESS = "We have added you to the Waitlist.";+const OFFLINE = "Could not reach the server. Please try again.";+const FALLBACK = "Something went wrong. Please try again.";++type Status = "idle" | "pending" | "done" | "error";++/* The hero's only call to action: an email capture, posted to /api/waitlist.+ *+ * The one rule worth preserving here: never show the confirmation unless the+ * server actually stored the address. A waitlist that reports success while+ * dropping signups is invisibly broken to everyone involved.+ */+export function EarlyAccessForm() {+ const inputId = useId();+ const [email, setEmail] = useState("");+ const [status, setStatus] = useState<Status>("idle");+ const [message, setMessage] = useState(SUCCESS);+ const timer = useRef<number | null>(null);+ const typing = email.trim().length > 0;+ const notice = status === "done" || status === "error";++ /* A pending dismissal must not outlive the component. */+ useEffect(+ () => () => {+ if (timer.current !== null) window.clearTimeout(timer.current);+ },+ [],+ );++ const flash = (text: string, next: Status) => {+ setMessage(text);+ setStatus(next);+ if (timer.current !== null) window.clearTimeout(timer.current);+ timer.current = window.setTimeout(() => setStatus("idle"), NOTICE_MS);+ };++ const submit = async (event: FormEvent<HTMLFormElement>) => {+ event.preventDefault();+ const address = email.trim();+ if (!address || status === "pending") return;++ setStatus("pending");+ try {+ const response = await fetch("/api/waitlist", {+ method: "POST",+ headers: { "content-type": "application/json" },+ body: JSON.stringify({ email: address }),+ });++ if (!response.ok) {+ /* The route sends a human-readable reason; fall back if it did not. */+ const body = (await response.json().catch(() => null)) as { error?: string } | null;+ flash(body?.error ?? FALLBACK, "error");+ return;+ }++ /* Clearing on success only, so a failed attempt keeps what was typed and+ the retry costs nothing. */+ setEmail("");+ flash(SUCCESS, "done");+ } catch {+ flash(OFFLINE, "error");+ }+ };++ return (+ <div className={styles.ctaGroup}>+ <form className={styles.emailForm} onSubmit={submit} noValidate>+ <label className={styles.emailLabel} htmlFor={inputId}>+ Work email+ </label>+ <input+ id={inputId}+ className={styles.emailInput}+ type="email"+ name="email"+ value={email}+ onChange={(event) => setEmail(event.target.value)}+ placeholder="Enter Work Email"+ autoComplete="email"+ required+ />+ {/* Both children stay mounted so the swap can be animated: the arrow+ cross-fades out while the label's track opens from 0fr to 1fr, which+ is the one way to transition to an intrinsic width. CSS picks the+ state, so it can key off viewport as well as typing. */}+ <button+ className={`${styles.emailSubmit} ${typing ? styles.emailSubmitLabelled : ""}`.trim()}+ type="submit"+ aria-label="Get Early Access"+ /* Guards the double-submit; the label does not change, so the control+ keeps its width while the request is in flight. */+ disabled={status === "pending"}+ >+ <ArrowRight className={styles.emailSubmitIcon} size={18} weight="bold" />+ <span className={styles.emailSubmitLabel} aria-hidden={!typing}>+ <span className={styles.emailSubmitText}>Get Early Access</span>+ </span>+ </button>+ </form>++ {/* Floats under the field rather than sitting in the layout, so showing it+ moves nothing. role="status" announces it without stealing focus. */}+ <p+ className={[+ styles.emailNotice,+ notice ? styles.emailNoticeVisible : "",+ status === "error" ? styles.emailNoticeError : "",+ ]+ .filter(Boolean)+ .join(" ")}+ role="status"+ >+ {message}+ </p>+ </div>+ );+}diff --git a/docs/app/(home)/cloud/observability/FeaturesSection.module.css b/docs/app/(home)/cloud/observability/FeaturesSection.module.cssnew file mode 100644index 000000000..52122a840--- /dev/null+++ b/docs/app/(home)/cloud/observability/FeaturesSection.module.css@@ -0,0 +1,167 @@+.section {+ display: flex;+ flex-direction: column;+ gap: 160px;+ width: 100%;+ max-width: 1200px;+ /* Symmetric now. Cloud leaves the bottom at 0 because its capability strip+ follows and supplies the separation; with that strip gone the last card ran+ straight into the CTA. */+ margin: 160px auto;+}++.card {+ display: flex;+ align-items: stretch;+ justify-content: space-between;+ gap: 80px;+ width: 100%;+}++/* Shrinks below the 1200px design width instead of overflowing; the gap above+ is the floor, space-between distributes anything left over. */+.featureImage {+ flex: 0 1 720px;+ align-self: center;+ min-width: 0;+ width: auto;+ height: auto;+ aspect-ratio: 720 / 400;+ border-radius: 24px;+}++.featureImage {+ display: block;+ object-fit: cover;+}++.featureImageDark {+ display: none;+}++[data-theme="dark"] .featureImageLight {+ display: none;+}++[data-theme="dark"] .featureImageDark {+ display: block;+}++.content {+ display: flex;+ flex: 0 0 400px;+ flex-direction: column;+ align-self: stretch;+ justify-content: space-between;+ min-width: 0;+ width: auto;+ text-align: left;+}++.headingGroup {+ display: flex;+ flex-direction: column;+}++.primaryHeading,+.secondaryHeading {+ margin: 0;+ font-family: "Inter Display", sans-serif;+ font-size: var(--home-title-medium-size);+ font-weight: var(--home-title-weight);+ line-height: var(--home-title-leading);+ letter-spacing: var(--home-title-tracking);+}++.primaryHeading {+ color: var(--openui-text-neutral-primary);+}++.secondaryHeading {+ color: var(--openui-text-neutral-secondary);+}++.body {+ margin: 0;+ color: var(--openui-text-neutral-secondary);+ font-family: "Inter Display", sans-serif;+ font-size: var(--home-lead-size);+ font-weight: var(--home-lead-weight);+ line-height: var(--home-lead-leading);+}++.bodyGroup {+ display: flex;+ flex-direction: column;+ align-items: flex-start;+ gap: 20px;+}++.supportingFeatures {+ --home-hairline: var(--openui-border-interactive);++ margin-top: 160px;+ padding-bottom: 160px;+}++/* Below the 1200px design width the section would otherwise run edge to edge.+ Same inset the sibling sections on this page use. */+@media (max-width: 1279px) {+ .section {+ width: calc(100% - 64px);+ }+}++@media (max-width: 1023px) {+ .section {+ gap: 96px;+ margin-top: 96px;+ }++ .card {+ flex-direction: column;+ gap: 32px;+ }++ .featureImage {+ flex: 0 0 auto;+ width: 100%;+ height: auto;+ aspect-ratio: 720 / 400;+ }++ .content {+ flex: 0 0 auto;+ width: 100%;+ }++ .supportingFeatures {+ margin-top: 96px;+ padding-bottom: 96px;+ }+}++@media (max-width: 767px) {+ .section {+ width: calc(100% - 32px);+ }++ .featureImage {+ order: -1;+ border-radius: 12px;+ }++ .content {+ gap: 20px;+ }+}++/* Holds a feature's slot until its artwork lands. Sits on top of .featureImage,+ which supplies the 720x400 sizing. Delete once every card has an image. */+.featurePlaceholder {+ background: rgba(10, 10, 10, 0.04);+}++[data-theme="dark"] .featurePlaceholder {+ background: rgba(255, 255, 255, 0.05);+}diff --git a/docs/app/(home)/cloud/observability/FeaturesSection.tsx b/docs/app/(home)/cloud/observability/FeaturesSection.tsxnew file mode 100644index 000000000..5ad195130--- /dev/null+++ b/docs/app/(home)/cloud/observability/FeaturesSection.tsx@@ -0,0 +1,116 @@+import Image from "next/image";+import type { ReactNode } from "react";+import styles from "./FeaturesSection.module.css";++/* No docs to point at yet, so the copy column ends at the body text. Cloud's+ version closes with a "Read docs" button; add it back per feature once each+ has somewhere to go. */+function FeatureCopy({+ title,+ headline,+ description,+}: {+ title: string;+ headline: ReactNode;+ description: string;+}) {+ return (+ <div className={styles.content}>+ <div className={styles.headingGroup}>+ <h2 className={styles.primaryHeading}>{title}</h2>+ <p className={styles.secondaryHeading}>{headline}</p>+ </div>+ <div className={styles.bodyGroup}>+ <p className={styles.body}>{description}</p>+ </div>+ </div>+ );+}++/* Authored at 1440x800 and declared at half that, so the pair is sharp on a+ retina screen while occupying the 720x400 slot the layout expects. */+function FeatureShot({ shot, alt }: { shot: string; alt: string }) {+ return (+ <>+ <Image+ className={`${styles.featureImage} ${styles.featureImageLight}`}+ src={`/openui-observability/${shot}-light.webp`}+ alt={alt}+ width={720}+ height={400}+ />+ <Image+ className={`${styles.featureImage} ${styles.featureImageDark}`}+ src={`/openui-observability/${shot}-dark.webp`}+ alt=""+ aria-hidden="true"+ width={720}+ height={400}+ />+ </>+ );+}++type Feature = {+ title: string;+ headline: ReactNode;+ description: string;+ /* Basename under /public/openui-observability/, which the light and dark+ files hang off. */+ shot: string;+};++const FEATURES: Feature[] = [+ {+ title: "Session replay",+ shot: "session-replay",+ headline: "See every session as it happened",+ description:+ "Replay conversations with the exact generative UI your users saw, not just the text behind it.",+ },+ {+ title: "Annotations",+ shot: "annotations",+ headline: "Turn sessions into feedback",+ description:+ "Annotate responses, add comments, assign severity, and share feedback with your dev team right where the issue happened.",+ },+ {+ title: "Timeline",+ shot: "timeline",+ headline: "Understand the journey at a glance",+ description:+ "Follow a simplified timeline of queries, actions, responses, and issues without digging through complex traces.",+ },+ {+ title: "Insights",+ shot: "insights",+ headline: "Learn what users want next",+ description:+ "See the skills users rely on most, what\u2019s missing, and which new demands are starting to emerge.",+ },+];++export function FeaturesSection() {+ return (+ <section className={styles.section} aria-label="Features">+ {FEATURES.map((feature, index) => (+ /* Alternating sides, as on Cloud: art leads the odd cards, copy the+ even ones, so the page does not read as one column. */+ <article key={feature.title} className={styles.card}>+ {index % 2 === 0 ? (+ <>+ <FeatureShot shot={feature.shot} alt={`${feature.title} in OpenUI Observability`} />+ <FeatureCopy {...feature} />+ </>+ ) : (+ <>+ <FeatureCopy {...feature} />+ <FeatureShot shot={feature.shot} alt={`${feature.title} in OpenUI Observability`} />+ </>+ )}+ </article>+ ))}+ </section>+ );+}diff --git a/docs/app/(home)/cloud/observability/page.module.css b/docs/app/(home)/cloud/observability/page.module.cssnew file mode 100644index 000000000..6c29b853d--- /dev/null+++ b/docs/app/(home)/cloud/observability/page.module.css@@ -0,0 +1,499 @@+.titleBlock {+ display: flex;+ flex-direction: column;+ align-items: flex-start;+ gap: 20px;+}++.eyebrow {+ display: inline-flex;+ align-items: center;+ gap: 8px;+ margin-left: 2px;+ font-size: 20px;+ font-weight: 500;+ line-height: 1;+ letter-spacing: normal;+}++.title {+ display: block;+ font-size: 60px;+ font-weight: 600;+ line-height: 1.15;+ text-wrap: balance;+}++/* Both hero lockups render this same title node, so the break is switched off+ by default and only enabled at the width where the desktop hero takes over+ (HeroSection swaps at min-width: 1024px). Below that the title wraps on its+ own and a hard break would land in the wrong place. */+.titleBreak {+ display: none;+}++@media (min-width: 1024px) {+ .titleBreak {+ display: inline;+ }+}++.cloudTag {+ display: inline-flex;+ align-items: center;+ margin-top: -3px;+ padding: 2px 6px 3px;+ border: 1px solid currentColor;+ border-radius: 5px;+ font-size: 17px;+ line-height: 1;+ vertical-align: middle;+}++/* Narrows the shared tagline's measure without touching the home page, which+ uses the same component at its full 75rem width. */+.taglineText {+ display: block;+ max-width: 46rem;+ margin-inline: auto;+ text-wrap: balance;+}++/* Reads as a caption under the tagline, so it drops out of the display scale+ and back to body type. */+.taglineNote {+ display: block;+ margin-top: 1rem;+ font-size: 1.125rem;+ font-weight: 400;+ line-height: 1.4;+ letter-spacing: 0;+ color: var(--openui-text-neutral-secondary);+}++[data-theme="dark"] .taglineNote {+ color: rgba(255, 255, 255, 0.55);+}++.subtitle {+ display: block;+ flex: 0 0 400px;+ width: 400px;+ max-width: 400px;+ margin-top: 40px;+ margin-left: auto;+ padding-top: 12px;+ font-size: 22px;+ font-weight: var(--home-heading-weight);+ line-height: var(--home-lead-leading);+ letter-spacing: var(--home-heading-tracking);+ text-wrap: balance;+}++.ctaGroup {+ position: relative;+ display: flex;+ align-items: center;+ gap: 12px;+}++.heroImage {+ display: block;+ width: 100%;+ height: auto;+}++.heroImageDark {+ display: none;+}++[data-theme="dark"] .heroImageLight {+ display: none;+}++[data-theme="dark"] .heroImageDark {+ display: block;+}++@media (max-width: 1023px) {+ .title {+ font-size: inherit;+ }++ .subtitle {+ margin-top: 0;+ padding-top: 0;+ }++ .ctaGroup {+ flex-direction: column;+ width: 320px;+ max-width: 100%;+ }+}++@media (max-width: 767px) {+ .titleBlock {+ align-items: center;+ gap: 12px;+ }++ .subtitle {+ /* The base rule pins this to 400px, which is wider than a small phone and+ bled off both edges. Let it track the hero width instead. */+ flex: 0 1 auto;+ width: 100%;+ max-width: none;+ margin-left: 0;+ font-size: 18px;+ font-weight: 500;+ line-height: 1.2;+ letter-spacing: normal;+ }+}++/* Holds the hero's space until the artwork lands. Same 1280x600 the Cloud hero+ image uses, so swapping in the <Image> pair changes nothing about the layout.+ Delete this rule once it is replaced. */+.heroPlaceholder {+ width: 100%;+ aspect-ratio: 1280 / 600;+ border-radius: 24px;+ background: rgba(10, 10, 10, 0.04);+}++[data-theme="dark"] .heroPlaceholder {+ background: rgba(255, 255, 255, 0.05);+}++/* ---- Hero email capture ----+ Input and submit share one pill, so the pair reads as a single control beside+ the secondary button rather than as two competing ones. */+.emailForm {+ display: flex;+ align-items: center;+ gap: 8px;+ min-width: 0;+ padding: 4px 4px 4px 18px;+ /* Stronger than the shared hairline token, which is ~6% and disappears on+ this surface. An input has to read as something you can type into. Stays+ below the focus-within step below, so focus is still a visible change. */+ border: 1px solid rgba(10, 10, 10, 0.16);+ border-radius: 999px;+ /* A hint of fill rather than the plain surface, so the field reads as an input+ on a page that is otherwise the same colour. */+ background: rgba(10, 10, 10, 0.03);+}++[data-theme="dark"] .emailForm {+ border-color: rgba(255, 255, 255, 0.2);+ background: rgba(255, 255, 255, 0.04);+}++.emailForm:focus-within {+ border-color: rgba(10, 10, 10, 0.28);+}++[data-theme="dark"] .emailForm:focus-within {+ border-color: rgba(255, 255, 255, 0.32);+}++/* The placeholder names the field for everyone else; this is for screen readers,+ which should not have to rely on it. */+.emailLabel {+ position: absolute;+ width: 1px;+ height: 1px;+ overflow: hidden;+ clip-path: inset(50%);+ white-space: nowrap;+}++.emailInput {+ /* Fixed, so swapping the icon button for a labelled one grows the pill rather+ than squeezing the field. */+ flex: 0 0 auto;+ min-width: 0;+ width: 17.5rem;+ border: 0;+ background: none;+ outline: none;+ font-family: var(--home-font-text);+ font-size: 15px;+ line-height: 1.4;+ color: var(--openui-text-neutral-primary);+}++.emailInput::placeholder {+ color: var(--openui-text-neutral-secondary);+}++.emailInput:disabled {+ opacity: 0.6;+}++/* The hero art dissolves into the page at its lower edge instead of stopping on+ a straight line. Masked rather than overlaid with a gradient, so it works on+ either theme without matching a background colour. */+.heroImage {+ -webkit-mask-image: linear-gradient(to bottom, #000 62%, transparent 100%);+ mask-image: linear-gradient(to bottom, #000 62%, transparent 100%);+}++/* Icon-only submit, sized and coloured like BevelButton's badge so it reads as+ the same family of control. Inverted against the field: dark disc on light,+ light disc on dark. */+.emailSubmit {+ --email-ease: cubic-bezier(0.45, 0.05, 0.15, 1);+ flex: none;+ position: relative;+ display: inline-flex;+ align-items: center;+ justify-content: center;+ /* A circle at minimum. Width is left to the content so the label can push it+ wider, and min-width holds the disc shape while there is no label. */+ min-width: 2.25rem;+ height: 2.25rem;+ padding: 0;+ border: 0;+ border-radius: 9999px;+ background: #0a0a0a;+ color: #ffffff;+ cursor: pointer;+ transition:+ padding var(--email-swap, 0.36s) var(--email-ease),+ opacity 0.15s ease,+ transform 0.15s ease;+}++[data-theme="dark"] .emailSubmit {+ background: #f3f3f4;+ color: #0d0d0f;+}++.emailSubmit:hover:not(:disabled) {+ opacity: 0.88;+}++.emailSubmit:active:not(:disabled) {+ transform: scale(0.96);+}++.emailSubmit:disabled {+ cursor: default;+ opacity: 0.55;+}++/* A tooltip under the field, not a line in the layout: absolutely positioned, so+ it appears and disappears without moving the control above it. Kept mounted+ and faded rather than swapped in, so screen readers announce it once.++ Centred on the field via the 50% + translate pair, which works whatever the+ notice's own width turns out to be. */+.emailNotice {+ position: absolute;+ top: calc(100% + 8px);+ left: 50%;+ z-index: 5;+ margin: 0;+ padding: 5px 12px;+ border-radius: 9999px;+ background: var(--openui-foreground);+ box-shadow:+ 0 6px 20px -10px rgb(0 0 0 / 0.2),+ 0 2px 6px -3px rgb(0 0 0 / 0.1);+ font-family: var(--home-font-text);+ font-size: 12px;+ line-height: 1.4;+ white-space: nowrap;+ color: var(--openui-text-neutral-primary);+ pointer-events: none;+ opacity: 0;+ /* The -50% centres it; the 4px is the slide, so both live in one transform. */+ transform: translate(-50%, -4px);+ visibility: hidden;+ transition:+ opacity 0.2s ease,+ transform 0.2s ease,+ visibility 0s linear 0.2s;+}++[data-theme="dark"] .emailNotice {+ background: #24242a;+}++/* A failure has to look different from a confirmation, or the two read as the+ same event. Same pill, different text colour. */+.emailNoticeError {+ color: #b42318;+}++[data-theme="dark"] .emailNoticeError {+ color: #f97066;+}++.emailNoticeVisible {+ opacity: 1;+ transform: translate(-50%, 0);+ visibility: visible;+ transition:+ opacity 0.2s ease,+ transform 0.2s ease,+ visibility 0s;+}++/* The fade is decoration; anyone who has asked for less motion still gets the+ message, just without the slide. */+@media (prefers-reduced-motion: reduce) {+ .emailNotice {+ transform: translate(-50%, 0);+ }++ /* The button still changes shape, it just does so at once. Set on the button+ rather than :root, both because a CSS Module selector must carry a local+ class and because the label and icon inherit these from here anyway. */+ .emailSubmit {+ --email-swap: 0.01s;+ --email-swap-in: 0s;+ }++ .emailSubmitIcon,+ .emailSubmitText {+ transition-duration: 0.01s;+ }+}++/* ---- Arrow <-> label ----+ `display: none` cannot be transitioned and `width: auto` cannot be animated+ to, so neither is used. Instead the label sits in a one-column grid whose+ track goes 0fr -> 1fr: that IS animatable and resolves to the text's natural+ width, so the button, and the pill around it, grow smoothly. The arrow is+ taken out of flow so it contributes no width and can simply cross-fade. */+.emailSubmitLabel {+ /* Both halves of the swap share one duration and one curve, so the arrow, the+ label and the pill all settle together. */+ --email-ease: cubic-bezier(0.45, 0.05, 0.15, 1);+ display: grid;+ grid-template-columns: 0fr;+ transition: grid-template-columns var(--email-swap, 0.36s) var(--email-ease);+}++.emailSubmitText {+ overflow: hidden;+ min-width: 0;+ font-family: var(--home-font-text);+ font-size: 14px;+ font-weight: 500;+ line-height: 1;+ white-space: nowrap;+ opacity: 0;+ /* Leaving: fade out at once, ahead of the collapse. */+ transition: opacity 0.12s ease;+}++.emailSubmitIcon {+ position: absolute;+ opacity: 1;+ /* Arriving: hold until the label has collapsed out of the way. */+ transition:+ opacity 0.16s ease var(--email-swap-in, 0.18s),+ transform 0.24s var(--email-ease) var(--email-swap-in, 0.18s);+}++.emailSubmitLabelled {+ padding: 0 1rem;+}++.emailSubmitLabelled .emailSubmitLabel {+ grid-template-columns: 1fr;+}++.emailSubmitLabelled .emailSubmitText {+ opacity: 1;+ /* Arriving: wait for the track to open, then fade into space already made. */+ transition: opacity 0.18s ease var(--email-swap-in, 0.18s);+}++/* Leaving: goes at once, and along its own axis rather than just vanishing. */+.emailSubmitLabelled .emailSubmitIcon {+ opacity: 0;+ transform: translateX(6px);+ transition:+ opacity 0.14s ease,+ transform 0.2s var(--email-ease);+}++/* ---- Phone ----+ The pill splits: the field is its own input, and the button sits under it at+ full width, always labelled. Swapping an icon in a shared pill is a desktop+ affordance; on a phone the button wants its own tap target. */+@media (max-width: 767px) {+ .emailForm {+ flex-direction: column;+ align-items: stretch;+ gap: 10px;+ width: 100%;+ padding: 0;+ border: 0;+ background: none;+ }++ /* The dark rules above are [data-theme] + class, and a media query adds no+ specificity, so plain `.emailForm` here loses to them and the pill's fill+ survives as a ghost panel behind the stack. Match the specificity to clear+ it. */+ [data-theme="dark"] .emailForm,+ .emailForm:focus-within,+ [data-theme="dark"] .emailForm:focus-within {+ border-color: transparent;+ background: none;+ }++ .emailInput {+ flex: 1 1 auto;+ width: 100%;+ padding: 13px 18px;+ border: 1px solid rgba(10, 10, 10, 0.16);+ border-radius: 9999px;+ background: rgba(10, 10, 10, 0.03);+ }++ .emailSubmit {+ width: 100%;+ height: 2.875rem;+ padding: 0 1rem;+ border-radius: 9999px;+ font-family: var(--home-font-text);+ font-size: 15px;+ font-weight: 500;+ line-height: 1;+ }++ /* No swap here, the button is only ever the labelled one. */+ .emailSubmitIcon {+ display: none;+ }++ .emailSubmitLabel {+ grid-template-columns: 1fr;+ transition: none;+ }++ .emailSubmitText {+ font-size: 15px;+ opacity: 1;+ transition: none;+ }++ /* The field carries the border the shared pill used to. */+ [data-theme="dark"] .emailInput {+ border-color: rgba(255, 255, 255, 0.2);+ background: rgba(255, 255, 255, 0.04);+ }++ /* Centred under the stack rather than under the field alone. */+ .emailNotice {+ white-space: normal;+ text-align: center;+ }+}diff --git a/docs/app/(home)/cloud/observability/page.tsx b/docs/app/(home)/cloud/observability/page.tsxnew file mode 100644index 000000000..e0ab4636c--- /dev/null+++ b/docs/app/(home)/cloud/observability/page.tsx@@ -0,0 +1,117 @@+import type { Metadata } from "next";+import Image from "next/image";+import styles from "../../page.module.css";+import { Footer } from "../../sections/Footer/Footer";+import { HeroSection, Tagline } from "../../sections/HeroSection/HeroSection";+import { CloudCtaSection } from "./CloudCtaSection";+import { EarlyAccessForm } from "./EarlyAccessForm";+import { FeaturesSection } from "./FeaturesSection";+import cloudStyles from "./page.module.css";++export const metadata: Metadata = {+ title: "OpenUI Observability - User insights for AI agents",+ description: "Understand what users need, where your agent falls short, and what to build next.",+ alternates: { canonical: "/cloud/observability" },+};++/* A structural copy of the OpenUI Cloud page with its copy and artwork removed.+ Every section component beside this file is a local copy too, so editing one+ here cannot affect /cloud.++ Fill it in a section at a time: each section's copy lives in its own file, and+ the order below is the page order. Sections you decide against can be deleted+ from this list and their file removed.++ LogoStrip is dropped for now; add it back beside the hero if this page wants+ one. */+export default function ObservabilityPage() {+ return (+ <div className={styles.page}>+ <div className={styles.heroShell}>+ <HeroSection+ align="left"+ title={+ <span className={cloudStyles.titleBlock}>+ {/* The same lockup Cloud uses, with the product name in the tag. */}+ <span className={cloudStyles.eyebrow}>+ OpenUI <span className={cloudStyles.cloudTag}>Observability</span>+ </span>+ {/* The break is real markup but only takes effect on the desktop+ lockup; the mobile one shares this node and wraps on its own. */}+ <span className={cloudStyles.title}>+ User insights <br className={cloudStyles.titleBreak} />+ for AI agents+ </span>+ </span>+ }+ subtitle={+ <span className={cloudStyles.subtitle}>+ Understand what users need, where your agent falls short, and what to build next.+ </span>+ }+ smallSubtitle+ tightDesktopSpacing={false}+ splitLockup+ flushInnerInlinePadding+ commandSlot={<EarlyAccessForm />}+ showPlaygroundButton={false}+ showGitHubBanner={false}+ showTagline={false}+ desktopPreviewSlot={+ <>+ <Image+ className={`${cloudStyles.heroImage} ${cloudStyles.heroImageLight}`}+ src="/openui-observability/hero-light.webp"+ alt="OpenUI Observability insights preview"+ width={1280}+ height={600}+ priority+ />+ <Image+ className={`${cloudStyles.heroImage} ${cloudStyles.heroImageDark}`}+ src="/openui-observability/hero-dark.webp"+ alt=""+ aria-hidden="true"+ width={1280}+ height={600}+ priority+ />+ </>+ }+ mobilePreviewSlot={+ <>+ <Image+ className={`${cloudStyles.heroImage} ${cloudStyles.heroImageLight}`}+ src="/openui-observability/hero-mobile-light.webp"+ alt="OpenUI Observability insights preview"+ width={924}+ height={1040}+ priority+ />+ <Image+ className={`${cloudStyles.heroImage} ${cloudStyles.heroImageDark}`}+ src="/openui-observability/hero-mobile-dark.webp"+ alt=""+ aria-hidden="true"+ width={924}+ height={1040}+ priority+ />+ </>+ }+ />++ {/* The large centred statement. */}+ <Tagline>+ Product Analytics that goes beyond traces.+ <br />+ For Product teams and SMEs.+ </Tagline>++ <FeaturesSection />+ <CloudCtaSection />+ </div>+ <Footer />+ </div>+ );+}diff --git a/docs/app/api/waitlist/route.ts b/docs/app/api/waitlist/route.tsnew file mode 100644index 000000000..175ed528d--- /dev/null+++ b/docs/app/api/waitlist/route.ts@@ -0,0 +1,57 @@+import { hasAllowedOrigin, hasJsonContentType } from "@/lib/openui-cloud/request";+import { addToWaitlist } from "@/lib/waitlist/store";++/* Public and unauthenticated. It checks that a request came from this site and+ carries a plausible address, then hands off; volume control is left to Tally,+ which does its own spam handling and is the thing actually being protected.++ The origin helper lives under openui-cloud only because that is where it was+ written; it is generic, and its default allowlist is this site's own origin,+ which is exactly what a same-origin form post needs. */++const MAX_BODY_BYTES = 1024;+/* RFC 5321's cap on a forward path. */+const MAX_EMAIL_LENGTH = 254;++function json(body: unknown, status: number): Response {+ return Response.json(body, { status, headers: { "Cache-Control": "no-store" } });+}++/* Not a full RFC 5322 parser, and not trying to be. It rejects the obvious+ nonsense so the provider is not called for it; the provider stays the+ authority on whether an address is real. */+const EMAIL = /^[^\s@]+@[^\s@.]+(\.[^\s@.]+)+$/;++export async function POST(request: Request): Promise<Response> {+ if (!hasAllowedOrigin(request)) return json({ error: "Forbidden" }, 403);+ if (!hasJsonContentType(request)) return json({ error: "Expected application/json" }, 415);++ const declaredLength = Number(request.headers.get("content-length") ?? 0);+ if (declaredLength > MAX_BODY_BYTES) return json({ error: "Body too large" }, 413);++ let payload: { email?: unknown };+ try {+ payload = (await request.json()) as { email?: unknown };+ } catch {+ return json({ error: "Malformed JSON" }, 400);+ }++ if (typeof payload?.email !== "string") return json({ error: "Email is required" }, 400);+ const email = payload.email.trim().toLowerCase();+ if (email.length > MAX_EMAIL_LENGTH || !EMAIL.test(email)) {+ return json({ error: "Enter a valid email address." }, 400);+ }++ const result = await addToWaitlist(email, request.signal);+ if (result.ok) return json({ ok: true }, 200);++ /* Both remaining outcomes are the server's problem, not the visitor's, and+ neither may be reported as success: a silently dropped signup is invisible+ to the person signing up and to us. */+ if (result.reason === "unconfigured") {+ console.error(+ "[waitlist] TALLY_FORM_ID / TALLY_EMAIL_FIELD are not set; the signup was not stored.",+ );+ }+ return json({ error: "Could not save that right now. Please try again." }, 503);+}diff --git a/docs/components/site-marketing-header.tsx b/docs/components/site-marketing-header.tsxindex ceae04eb9..155f7f3f7 100644--- a/docs/components/site-marketing-header.tsx+++ b/docs/components/site-marketing-header.tsx@@ -102,6 +102,10 @@ function MobileMenu({ onClose }: { onClose: () => void }) {href: string;newTab?: boolean;badge?: string;+ /* The dropdown's status chip, carried through from the nav data. A tray row+ has no description to sit under, so unlike the desktop card it shares the+ badge slot beside the title. */+ tag?: string;comingSoon?: true;}) =>/* Matches the desktop menu: announced, tagged, and not a link. */@@ -123,7 +127,12 @@ function MobileMenu({ onClose }: { onClose: () => void }) {{...(entry.newTab ? { target: "_blank", rel: "noopener noreferrer" } : {})}><span>{entry.title}</span>- {entry.badge && <span className={styles.mobileTrayBadge}>{entry.badge}</span>}+ {/* A top-level badge wins if an item somehow carries both; in practice+ they never do, since badges come from leaf links and tags from+ dropdown children. */}+ {(entry.badge ?? entry.tag) && (+ <span className={styles.mobileTrayBadge}>{entry.badge ?? entry.tag}</span>+ )}</Link>);diff --git a/docs/components/site-primary-nav.module.css b/docs/components/site-primary-nav.module.cssindex 48f3eafb3..fa3436e54 100644--- a/docs/components/site-primary-nav.module.css+++ b/docs/components/site-primary-nav.module.css@@ -391,9 +391,10 @@background: var(--openui-highlight-strong);}-/* Same chip as the header's New badge: solid and inverted, so the two statuses- in the nav read as one kind of thing. */-.comingSoon {+/* Same chip as the header's New badge: solid and inverted, so every status in+ the nav reads as one kind of thing. Shared by "Coming soon" and "Early+ access"; the text is uppercased here rather than in the data. */+.itemTag {/* Hugs its text instead of stretching, now that it sits on its own line in thecard's text column. */flex: none;@@ -412,7 +413,7 @@white-space: nowrap;}-[data-theme="dark"] .comingSoon {+[data-theme="dark"] .itemTag {background: #f3f3f4;color: #0d0d0f;}diff --git a/docs/components/site-primary-nav.tsx b/docs/components/site-primary-nav.tsxindex ac5180421..82d933183 100644--- a/docs/components/site-primary-nav.tsx+++ b/docs/components/site-primary-nav.tsx@@ -47,6 +47,11 @@ type NavDropdownChild = {a link, so there is nothing to click and nothing to tab to. The href staysput: clearing this flag is all it takes to turn it back on. */comingSoon?: true;+ /* A short status chip under the card's copy, on an item that is otherwise a+ normal link. Unlike `comingSoon` this changes no behaviour: the arrow, the+ hover and the destination all stay. Rendered uppercase by the stylesheet,+ so write it in sentence case. */+ tag?: string;};/* A labelled run of cards inside one menu, for a menu whose cards divide along a@@ -130,7 +135,7 @@ export const PRIMARY_SITE_NAV_ITEMS: NavItem[] = [title: "Observability",description: "Product analytics and user insights for AI agents.",href: "/cloud/observability",- comingSoon: true,+ tag: "Early access",},],},@@ -352,15 +357,20 @@ function renderBody(child: NavDropdownChild, layout: "cards" | "list") {)}{/* Under the copy rather than beside the title: it is the last thing toread, once you know what the thing is. */}- {child.comingSoon && <ComingSoonTag />}+ {child.comingSoon ? (+ <ItemTag label="Coming soon" />+ ) : child.tag ? (+ <ItemTag label={child.tag} />+ ) : null}</span></>);}-/* The tag beside a title that is not yet a destination. */-function ComingSoonTag() {- return <span className={styles.comingSoon}>Coming soon</span>;+/* The status chip under a card's copy. Carries no behaviour of its own: whether+ the item is clickable is decided by `comingSoon`, not by this. */+function ItemTag({ label }: { label: string }) {+ return <span className={styles.itemTag}>{label}</span>;}function DropdownCard({diff --git a/docs/lib/waitlist/store.ts b/docs/lib/waitlist/store.tsnew file mode 100644index 000000000..3fbad5de2--- /dev/null+++ b/docs/lib/waitlist/store.ts@@ -0,0 +1,87 @@+/* Where a waitlist address actually goes.+ *+ * One function behind one result type, so the route handler never learns which+ * service is on the other end and changing providers is a change to this file+ * alone. Plain fetch, so no new dependency and no build-time coupling.+ *+ * Currently Tally, posting to the endpoint Tally's own form page uses. We call+ * it server side, which is why the form on our page can keep its own design:+ * nothing of Tally's is ever rendered, and no iframe or popup is involved.+ *+ * CAVEATS, worth knowing before debugging this:+ *+ * - The endpoint is undocumented. Tally's public REST API can list, fetch and+ * delete submissions but cannot create one, so this is the only way to hand+ * it an address from our own UI. It is stable in practice; it is not a+ * contract.+ * - Tally does NOT validate server side. A wrong TALLY_EMAIL_FIELD still+ * returns 200 and records an empty submission rather than an error, even+ * though the question is marked required in the form. That makes the field+ * id a one-time configuration risk: get it wrong and signups arrive blank+ * and silent. Verified by a live submission when it was set, and worth+ * re-verifying if the form is ever rebuilt, since the id changes with it.+ * - Duplicates are not detected. The same address twice records twice.+ *+ * Unlike a Google Form, Tally answers with JSON carrying a submissionId, so we+ * can require that rather than trusting the status code alone.+ */++/* Upper bound on how long a signup may block the request. */+const TIMEOUT_MS = 8000;++export type WaitlistResult = { ok: true } | { ok: false; reason: "unconfigured" | "upstream" };++export async function addToWaitlist(email: string, signal?: AbortSignal): Promise<WaitlistResult> {+ const formId = process.env.TALLY_FORM_ID?.trim();+ /* The uuid Tally keys the answer by: the question's `groupUuid`, which is also+ the id attribute on the rendered input. Not the block uuid. */+ const field = process.env.TALLY_EMAIL_FIELD?.trim();+ /* Missing config means the address has nowhere to go. Say so, rather than+ returning a success the caller would show to someone whose signup was+ discarded. */+ if (!formId || !field) return { ok: false, reason: "unconfigured" };++ /* Give up rather than hold the request open if Tally stalls. Combined with the+ caller's own signal, so a disconnected client cancels too. */+ const timeout = AbortSignal.timeout(TIMEOUT_MS);+ const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;++ let response: Response;+ try {+ response = await fetch(`https://api.tally.so/forms/${formId}/respond`, {+ method: "POST",+ headers: {+ "content-type": "application/json",+ /* Some runtimes send no User-Agent by default, which is likelier to be+ rejected. */+ "user-agent": "openui-website-waitlist",+ },+ body: JSON.stringify({+ /* One-shot submission, so the session and respondent are per-request.+ Tally uses these to stitch partial responses together; we never send+ a partial one. */+ sessionUuid: crypto.randomUUID(),+ respondentUuid: crypto.randomUUID(),+ responses: { [field]: email },+ captchas: {},+ isCompleted: true,+ password: null,+ }),+ signal: combined,+ });+ } catch {+ return { ok: false, reason: "upstream" };+ }++ if (!response.ok) return { ok: false, reason: "upstream" };++ /* Require the recorded id rather than trusting the status: a 200 carrying+ anything else means Tally did not record what we think it did. */+ try {+ const body = (await response.json()) as { submissionId?: unknown };+ if (typeof body?.submissionId === "string" && body.submissionId) return { ok: true };+ } catch {+ /* Fall through: a 200 that is not the JSON we expect is not a success. */+ }+ return { ok: false, reason: "upstream" };+}diff --git a/docs/public/openui-observability/annotations-dark.webp b/docs/public/openui-observability/annotations-dark.webpnew file mode 100644index 000000000..83ad40612Binary files /dev/null and b/docs/public/openui-observability/annotations-dark.webp differdiff --git a/docs/public/openui-observability/annotations-light.webp b/docs/public/openui-observability/annotations-light.webpnew file mode 100644index 000000000..af16f73dbBinary files /dev/null and b/docs/public/openui-observability/annotations-light.webp differdiff --git a/docs/public/openui-observability/hero-dark.webp b/docs/public/openui-observability/hero-dark.webpnew file mode 100644index 000000000..cf904df98Binary files /dev/null and b/docs/public/openui-observability/hero-dark.webp differdiff --git a/docs/public/openui-observability/hero-light.webp b/docs/public/openui-observability/hero-light.webpnew file mode 100644index 000000000..36111c73fBinary files /dev/null and b/docs/public/openui-observability/hero-light.webp differdiff --git a/docs/public/openui-observability/hero-mobile-dark.webp b/docs/public/openui-observability/hero-mobile-dark.webpnew file mode 100644index 000000000..fd1a54e81Binary files /dev/null and b/docs/public/openui-observability/hero-mobile-dark.webp differdiff --git a/docs/public/openui-observability/hero-mobile-light.webp b/docs/public/openui-observability/hero-mobile-light.webpnew file mode 100644index 000000000..ab89e0817Binary files /dev/null and b/docs/public/openui-observability/hero-mobile-light.webp differdiff --git a/docs/public/openui-observability/insights-dark.webp b/docs/public/openui-observability/insights-dark.webpnew file mode 100644index 000000000..c4a21726eBinary files /dev/null and b/docs/public/openui-observability/insights-dark.webp differdiff --git a/docs/public/openui-observability/insights-light.webp b/docs/public/openui-observability/insights-light.webpnew file mode 100644index 000000000..66b9c0cbcBinary files /dev/null and b/docs/public/openui-observability/insights-light.webp differdiff --git a/docs/public/openui-observability/session-replay-dark.webp b/docs/public/openui-observability/session-replay-dark.webpnew file mode 100644index 000000000..b30268409Binary files /dev/null and b/docs/public/openui-observability/session-replay-dark.webp differdiff --git a/docs/public/openui-observability/session-replay-light.webp b/docs/public/openui-observability/session-replay-light.webpnew file mode 100644index 000000000..b5b3750a5Binary files /dev/null and b/docs/public/openui-observability/session-replay-light.webp differdiff --git a/docs/public/openui-observability/timeline-dark.webp b/docs/public/openui-observability/timeline-dark.webpnew file mode 100644index 000000000..cb7ad2665Binary files /dev/null and b/docs/public/openui-observability/timeline-dark.webp differdiff --git a/docs/public/openui-observability/timeline-light.webp b/docs/public/openui-observability/timeline-light.webpnew file mode 100644index 000000000..493b43fd7Binary files /dev/null and b/docs/public/openui-observability/timeline-light.webp differ