@decocms/nextjs 8.1.0-next.0 → 8.5.0

package/src/config.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DECO_REWRITES, withDeco } from "./config.cjs";
-
-// withDeco()'s declared return type is the standard (loosely typed) Next.js
-// NextConfig, whose `rewrites`/`transpilePackages` are optional and
-// union-typed. The runtime object always has them (withDeco always sets
-// them), so tests assert that with `!` / casts rather than loosening the
-// public declaration.
-describe("withDeco", () => {
-  it("adds rewrites and transpilePackages to a bare config", async () => {
-    const cfg = withDeco({});
-    expect(cfg.transpilePackages).toEqual(
-      expect.arrayContaining(["@decocms/blocks", "@decocms/blocks-admin", "@decocms/nextjs"]),
-    );
-    expect(await cfg.rewrites!()).toEqual(DECO_REWRITES);
-  });
-
-  it("prepends deco rewrites to a user's array-returning rewrites()", async () => {
-    const cfg = withDeco({
-      rewrites: async () => [{ source: "/a", destination: "/b" }],
-    });
-    const out = (await cfg.rewrites!()) as Array<{ source: string; destination: string }>;
-    expect(out.slice(0, DECO_REWRITES.length)).toEqual(DECO_REWRITES);
-    expect(out.at(-1)).toEqual({ source: "/a", destination: "/b" });
-  });
-
-  it("merges into a user's object-form rewrites via beforeFiles", async () => {
-    const cfg = withDeco({
-      rewrites: async () => ({
-        beforeFiles: [{ source: "/x", destination: "/y" }],
-        afterFiles: [],
-        fallback: [],
-      }),
-    });
-    const out = (await cfg.rewrites!()) as {
-      beforeFiles: Array<{ source: string; destination: string }>;
-    };
-    expect(out.beforeFiles.slice(0, DECO_REWRITES.length)).toEqual(DECO_REWRITES);
-    expect(out.beforeFiles.at(-1)).toEqual({ source: "/x", destination: "/y" });
-  });
-
-  it("dedupes transpilePackages", () => {
-    const cfg = withDeco({ transpilePackages: ["@decocms/blocks", "other"] });
-    expect(cfg.transpilePackages!.filter((p: string) => p === "@decocms/blocks")).toHaveLength(1);
-    expect(cfg.transpilePackages).toContain("other");
-  });
-});
-
-describe("withDeco draft headers", () => {
-  it("adds no-store/no-index rules for both draft signals", async () => {
-    const headers = await withDeco({}).headers!();
-    // Two rules, not one: `has` entries within a rule are ANDed, and the query
-    // (entry) and cookie (navigation) signals never coincide.
-    expect(headers).toHaveLength(2);
-    expect(headers[0].has).toEqual([{ type: "query", key: "__draft" }]);
-    expect(headers[1].has).toEqual([{ type: "cookie", key: "__deco_draft" }]);
-
-    for (const rule of headers) {
-      const byKey = Object.fromEntries(rule.headers.map((h) => [h.key, h.value]));
-      // `no-store` is what actually stops a shared cache serving unpublished
-      // content to a real visitor — the pointer being a cookie means draft and
-      // published share a URL.
-      expect(byKey["Cache-Control"]).toBe("no-store, private");
-      expect(byKey.Vary).toBe("Cookie");
-      expect(byKey["X-Robots-Tag"]).toBe("noindex, nofollow");
-    }
-  });
-
-  it("keeps a site's own headers, with the draft rules taking precedence", async () => {
-    const cfg = withDeco({
-      headers: async () => [
-        { source: "/:path*", headers: [{ key: "Cache-Control", value: "public, max-age=3600" }] },
-      ],
-    });
-    const headers = await cfg.headers!();
-    expect(headers).toHaveLength(3);
-    // A site's catch-all cache policy must not out-rank the draft rules.
-    expect(headers[0].has).toBeDefined();
-    expect(headers[1].has).toBeDefined();
-    expect(headers[2].headers[0].value).toBe("public, max-age=3600");
-  });
-
-  it("leaves a site without headers() untouched apart from the draft rules", async () => {
-    expect(await withDeco({}).headers!()).toHaveLength(2);
-  });
-});

package/src/createDecoPage.draft.test.tsx

@@ -1,91 +0,0 @@
-/**
- * Draft-preview wiring in `createDecoPage`.
- *
- * Separate from `createDecoPage.test.tsx` because this file has to mock
- * `next/headers`, and that mock would otherwise apply to the plain
- * (non-draft) cases too — which are worth keeping honest about never
- * touching a dynamic API at all.
- */
-
-import { registerSections, setBlocks } from "@decocms/blocks/cms";
-import { renderToString } from "react-dom/server";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-// The gate must stop us reaching cookies() at all when the feature is off.
-const cookiesMock = vi.fn(async () => ({ get: () => undefined }));
-vi.mock("next/headers", () => ({
-  cookies: () => cookiesMock(),
-  headers: async () => new Headers(),
-}));
-
-// `connection()` is Next's runtime opt-out from static rendering; outside a
-// request scope it throws, so it is stubbed to a no-op here.
-const connectionMock = vi.fn(async () => {});
-vi.mock("next/server", () => ({ connection: () => connectionMock() }));
-
-const { createDecoPage } = await import("./createDecoPage");
-
-function Hero({ label }: { label?: string }) {
-  return <h1>{`hero-${label ?? "none"}`}</h1>;
-}
-
-function seedPublishedHome() {
-  registerSections({ "site/sections/DraftHero.tsx": async () => ({ default: Hero }) });
-  setBlocks({
-    "pages-home": {
-      path: "/",
-      sections: [{ __resolveType: "site/sections/DraftHero.tsx", label: "published" }],
-    },
-  });
-}
-
-afterEach(() => {
-  cookiesMock.mockClear();
-  connectionMock.mockClear();
-  delete process.env.DECO_ALLOWED_PREVIEW_HOSTS;
-  delete process.env.DECO_SANDBOX_ORIGIN_SUFFIXES;
-});
-
-describe("createDecoPage — draft preview gate", () => {
-  it("never reads cookies() when the feature is off", async () => {
-    // Load-bearing, not a micro-optimisation: cookies() is a dynamic API, so
-    // calling it unconditionally would opt EVERY page of EVERY site out of
-    // static/ISR rendering the moment this package is upgraded.
-    seedPublishedHome();
-
-    const { default: Page } = createDecoPage({ siteName: "test-site" });
-    const html = renderToString(await Page({ params: Promise.resolve({ slug: [] }) }));
-
-    expect(html).toContain("hero-published");
-    expect(cookiesMock).not.toHaveBeenCalled();
-    expect(connectionMock).not.toHaveBeenCalled();
-  });
-
-  it("stays off when the flag is set but no origin suffix is configured", async () => {
-    // Both halves are required — a bare flag with nowhere to fetch from is
-    // inert, mirroring Fast Deploy's opt-in.
-    process.env.DECO_DRAFT_PREVIEW = "1";
-    seedPublishedHome();
-
-    const { default: Page } = createDecoPage({ siteName: "test-site" });
-    const html = renderToString(await Page({ params: Promise.resolve({ slug: [] }) }));
-
-    expect(html).toContain("hero-published");
-    expect(cookiesMock).not.toHaveBeenCalled();
-  });
-
-  it("reads cookies() once the feature is fully configured", async () => {
-    process.env.DECO_ALLOWED_PREVIEW_HOSTS = "preview.example";
-    seedPublishedHome();
-
-    const { default: Page } = createDecoPage({ siteName: "test-site" });
-    const html = renderToString(await Page({ params: Promise.resolve({ slug: [] }) }));
-
-    // No draft pointer on the request, so the page still renders published —
-    // enabling the feature must not change what an ordinary visitor sees.
-    expect(html).toContain("hero-published");
-    expect(cookiesMock).toHaveBeenCalled();
-    // Nothing was bound, so no need to force the page dynamic.
-    expect(connectionMock).not.toHaveBeenCalled();
-  });
-});

package/src/createDecoPage.test.tsx

@@ -1,63 +0,0 @@
-import { registerSections, setBlocks } from "@decocms/blocks/cms";
-import { renderToString } from "react-dom/server";
-import { describe, expect, it } from "vitest";
-import { createDecoPage } from "./createDecoPage";
-
-function Hero({ label }: { label?: string }) {
-  return <h1>{`hero-${label ?? "none"}`}</h1>;
-}
-
-describe("createDecoPage (next)", () => {
-  it("resolves and renders the page for the current path", async () => {
-    // registerSections (the async-loader registry, packages/blocks/src/cms/registry.ts)
-    // — NOT registerSectionsSync — is what resolveDecoPage's pipeline reads:
-    // resolveRawSection() gates each raw CMS section through getSection(),
-    // which only consults the registry registerSections populates.
-    // registerSectionsSync populates a separate `syncComponents` map that
-    // SectionRenderer checks first for already-rendered pages, but a section
-    // registered ONLY via registerSectionsSync is silently dropped (with a
-    // "[CMS] No component registered for: ..." warning) during CMS
-    // resolution itself — confirmed by running this test against the plan's
-    // original registerSectionsSync-based sketch.
-    registerSections({ "site/sections/CreateDecoPageHero.tsx": async () => ({ default: Hero }) });
-    // Block key MUST start with "pages-" — that's the prefix getAllPages()
-    // (packages/blocks/src/cms/loader.ts) filters on. The plan's sketch used
-    // "pages/home.json", which getAllPages() would silently skip, so
-    // resolveDecoPage would return null and this test would fail even with a
-    // correct implementation.
-    setBlocks({
-      "pages-home": {
-        path: "/",
-        sections: [{ __resolveType: "site/sections/CreateDecoPageHero.tsx", label: "home" }],
-        seo: {
-          __resolveType: "website/sections/Seo/SeoV2.tsx",
-          title: "Home title",
-          description: "Home description",
-        },
-      },
-    });
-
-    const { generateMetadata, default: Page } = createDecoPage({ siteName: "test-site" });
-
-    const element = await Page({ params: Promise.resolve({ slug: [] }) });
-    const html = renderToString(element);
-    expect(html).toContain("hero-home");
-
-    const metadata = await generateMetadata({ params: Promise.resolve({ slug: [] }) });
-    expect(metadata.title).toBe("Home title");
-    expect(metadata.description).toBe("Home description");
-  });
-
-  it("calls next/navigation notFound() when no page matches the path", async () => {
-    setBlocks({
-      "pages-home": {
-        path: "/",
-        sections: [{ __resolveType: "site/sections/CreateDecoPageHero.tsx", label: "home" }],
-      },
-    });
-
-    const { default: Page } = createDecoPage({ siteName: "test-site" });
-
-    await expect(Page({ params: Promise.resolve({ slug: ["missing"] }) })).rejects.toThrow();
-  });
-});

package/src/createDecoPage.tsx

@@ -1,173 +0,0 @@
-import {
-  type DecoPageResult,
-  extractSeoFromProps,
-  extractSeoFromSections,
-  isDraftPreviewEnabled,
-  type PageSeo,
-  resolveDecoPage,
-} from "@decocms/blocks/cms";
-import type { Metadata } from "next";
-import { notFound } from "next/navigation";
-import { connection } from "next/server";
-import { cache } from "react";
-import { DecoPageRenderer } from "./DecoPageRenderer";
-import { DraftPreviewIndicator } from "./DraftPreviewIndicator";
-import { type DraftSearchParams, ensureDraft } from "./draft";
-
-interface CreateDecoPageOptions {
-  siteName: string;
-}
-
-interface PageProps {
-  params: Promise<{ slug?: string[] }>;
-  /**
-   * Next always supplies this; optional here so existing callers (and unit
-   * tests) that construct props by hand keep compiling. Draft preview reads
-   * `?__draft=` from it — see bindDraftOnce.
-   */
-  searchParams?: Promise<DraftSearchParams>;
-}
-
-function pathFromSlug(slug: string[] | undefined): string {
-  return `/${(slug ?? []).join("/")}`;
-}
-
-/**
- * Merge page-level SEO (the `seo` block resolved into `DecoPageResult.seoSection`)
- * with section-contributed SEO (sections registered via `registerSeoSections`
- * whose resolved props also carry SEO fields — e.g. a PDP SEO section). Page
- * level fields win on conflict, mirroring `buildPageSeo` in the TanStack
- * binding (packages/tanstack/src/routes/cmsRoute.ts:408-484).
- *
- * Deliberately narrower than that binding's version: it does NOT run
- * `seoSection` through its own section loader (so commerce-loader-backed
- * jsonLD on the seo block won't resolve here) and does NOT fall back to
- * site-wide SEO defaults or apply title/description templates. Those are
- * out of scope for this minimal page.tsx wiring.
- */
-function buildSeo(page: DecoPageResult): PageSeo {
-  const sectionSeo = extractSeoFromSections(page.resolvedSections);
-  const pageSeo = page.seoSection ? extractSeoFromProps(page.seoSection.props) : {};
-  return { ...sectionSeo, ...pageSeo };
-}
-
-/**
- * Creates the { generateMetadata, default } pair a site spreads into
- * app/[[...slug]]/page.tsx. Mirrors `@decocms/tanstack`'s `cmsRouteConfig`.
- *
- * `resolveForPath` is wrapped in React's `cache()` so `generateMetadata` and
- * the page body share one `resolveDecoPage` call per request instead of
- * resolving twice — the same pattern a production Next.js site's own
- * `resolveCmsPageByPath` already used against the old /next tier. This relies
- * on Next's RSC renderer establishing a per-request cache boundary that
- * `cache()` memoizes against: calling the returned functions directly outside
- * that renderer (e.g. in a plain unit test) will NOT dedupe, since there is
- * no active cache boundary for `cache()` to key off — verified empirically
- * against this repo's `react` version. The functions still return correct,
- * independent results either way; only the single-request sharing is
- * untestable outside Next's own pipeline.
- */
-export function createDecoPage({ siteName }: CreateDecoPageOptions) {
-  // `siteName` is unused here. `MatcherContext` (packages/blocks/src/cms/resolve.ts)
-  // has no siteName field, so there's nothing to thread it into `resolveDecoPage`.
-  // It's kept in the options shape to mirror `cmsRouteConfig({ siteName })`'s call
-  // signature and as the extension point for Task 7's root layout
-  // (LiveControls/analytics wiring) — genuinely unused in this file.
-  void siteName;
-
-  const resolveForPath = cache(async (pathname: string) => resolveDecoPage(pathname, {}));
-
-  /**
-   * Bind this request's draft decofile, at most once, BEFORE anything resolves
-   * a page.
-   *
-   * Ordering is load-bearing twice over:
-   *
-   *  1. `resolveDecoPage` calls `loadBlocks()`, so a draft bound afterwards
-   *     would resolve the page against published content and silently render
-   *     the wrong thing.
-   *  2. `resolveForPath` is `cache()`d per request and Next may run
-   *     `generateMetadata` and the page body concurrently — whichever resolves
-   *     first wins for both. So this must be awaited at the top of BOTH, not
-   *     just the page. `cache()` here makes the second call free.
-   *
-   * Gated on `isDraftPreviewEnabled()` (DECO_ALLOWED_PREVIEW_HOSTS non-empty) — a
-   * plain env read, not a dynamic API —
-   * so sites that never opt in behave exactly as before. That gate is doing
-   * real work: `cookies()` and `searchParams` are both dynamic, and touching
-   * them unconditionally would opt EVERY page out of static/ISR rendering.
-   *
-   * KNOWN COST: with the flag on, every page served by this route becomes
-   * dynamic, because reading the pointer requires `cookies()`. Acceptable
-   * while the feature is opt-in; the fix, when it needs to run on a
-   * statically-rendered production site, is for middleware to rewrite draft
-   * requests onto a separate dynamic route so ordinary traffic keeps its cache.
-   */
-  const bindDraftOnce = cache(async (searchParams?: DraftSearchParams): Promise<boolean> => {
-    if (!isDraftPreviewEnabled()) return false;
-
-    const bound = await ensureDraft(searchParams);
-
-    // A draft render must never be cached — ISR or the Full Route Cache would
-    // hand unpublished content to a real visitor. `revalidate` is a static
-    // export and cannot vary per request, so opt out at runtime instead.
-    if (bound) await connection();
-
-    return bound;
-  });
-
-  async function generateMetadata({ params, searchParams }: PageProps): Promise<Metadata> {
-    const { slug } = await params;
-    await bindDraftOnce(await searchParams);
-    const page = await resolveForPath(pathFromSlug(slug));
-    if (!page) return {};
-
-    const seo = buildSeo(page);
-    return {
-      title: seo.title,
-      description: seo.description,
-      alternates: seo.canonical ? { canonical: seo.canonical } : undefined,
-      robots: seo.noIndexing ? { index: false, follow: false } : undefined,
-    };
-  }
-
-  async function Page({ params, searchParams }: PageProps) {
-    const { slug } = await params;
-    const pathname = pathFromSlug(slug);
-    // Before resolveForPath — see bindDraftOnce.
-    const isDraft = await bindDraftOnce(await searchParams);
-    const page = await resolveForPath(pathname);
-    if (!page) notFound();
-
-    // Call DecoPageRenderer directly (await its result) rather than nesting
-    // it as `<DecoPageRenderer .../>` JSX. DecoPageRenderer.tsx documents why:
-    // it's an async function, and Next's real RSC renderer awaits async
-    // components anywhere in the tree — but react-dom/server's synchronous
-    // renderer (used by this package's unit tests, and by any consumer not
-    // going through Next's RSC pipeline) throws when an async component
-    // suspends outside a <Suspense> boundary. Awaiting it here directly
-    // keeps both paths working, matching the same convention
-    // DecoPageRenderer itself uses for SectionRenderer.
-    const content = await DecoPageRenderer({
-      sections: page.resolvedSections,
-      deferredSections: page.deferredSections,
-      pagePath: pathname,
-    });
-
-    // In draft mode, float the preview-mode badge over the page so the
-    // reviewer can never mistake unpublished content for what is live.
-    // `DraftPreviewIndicator` self-gates on the request-scoped pointer; the
-    // `isDraft` short-circuit keeps the extra element out of every published
-    // render. Rendered here (page subtree, after bindDraftOnce) — not a layout,
-    // whose children render concurrently — so the pointer slot is already set.
-    if (!isDraft) return content;
-    return (
-      <>
-        {content}
-        <DraftPreviewIndicator />
-      </>
-    );
-  }
-
-  return { generateMetadata, default: Page };
-}

package/src/createDecoPreviewPage.test.tsx

@@ -1,71 +0,0 @@
-// @vitest-environment node
-
-import { registerSection, setBlocks } from "@decocms/blocks/cms";
-import { setRenderShell } from "@decocms/blocks-admin";
-import { renderToString } from "react-dom/server";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { createDecoPreviewPage } from "./createDecoPreviewPage";
-import * as nextjs from "./index";
-
-vi.mock("next/headers", () => ({
-  headers: vi.fn(
-    async () =>
-      new Headers({
-        host: "store.test",
-        "x-forwarded-proto": "https",
-        "user-agent": "preview-test",
-      }),
-  ),
-}));
-
-const HERO = "site/sections/PreviewHero.tsx";
-
-beforeEach(() => {
-  setBlocks({
-    "Preview Hero": { __resolveType: HERO, label: "rsc" },
-  });
-  registerSection(HERO, async () => ({
-    default: ({ label }: { label?: string }) => <h1>{`hero-${label}`}</h1>,
-  }));
-  setRenderShell({
-    css: "/preview.css",
-    fonts: ["/font.css"],
-    theme: "light",
-    bodyClass: "preview-body",
-  });
-});
-
-describe("createDecoPreviewPage", () => {
-  it("is exposed by the Next.js binding", () => {
-    expect((nextjs as Record<string, unknown>).createDecoPreviewPage).toBeTypeOf("function");
-  });
-
-  it("resolves and renders a section through the RSC-aware SectionRenderer", async () => {
-    const setup = vi.fn(async () => {});
-    const Page = createDecoPreviewPage({ setup });
-    const element = await Page({
-      params: Promise.resolve({ path: ["Preview Hero"] }),
-      searchParams: Promise.resolve({ deviceHint: "desktop" }),
-    });
-    const html = renderToString(element);
-
-    expect(setup).toHaveBeenCalledOnce();
-    expect(html).toContain("hero-rsc");
-    expect(html).toContain('data-manifest-key="site/sections/PreviewHero.tsx"');
-    expect(html).toContain('href="/preview.css"');
-    expect(html).toContain('href="/font.css"');
-    expect(html).toContain('data-theme="light"');
-    expect(html).toContain("preview-body");
-    expect(html).toContain("editor::inject");
-  });
-
-  it("renders a visible diagnostic for an unknown section", async () => {
-    const Page = createDecoPreviewPage();
-    const element = await Page({
-      params: Promise.resolve({ path: ["Missing"] }),
-      searchParams: Promise.resolve({}),
-    });
-
-    expect(renderToString(element)).toContain("Unknown section: Missing");
-  });
-});

package/src/createDecoPreviewPage.tsx

@@ -1,108 +0,0 @@
-import { LIVE_CONTROLS_SCRIPT, resolvePreviewRequest } from "@decocms/blocks-admin";
-import { getPreviewWrapper, getRenderShellConfig } from "@decocms/blocks-admin/admin/setup";
-import { headers } from "next/headers";
-import { cloneElement, createElement, type ReactElement, type ReactNode } from "react";
-import { SectionRenderer } from "./SectionRenderer";
-
-export interface CreateDecoPreviewPageOptions {
-  setup?: () => Promise<void>;
-}
-
-export interface DecoPreviewPageProps {
-  params: Promise<{ path?: string[] }>;
-  searchParams: Promise<Record<string, string | string[] | undefined>>;
-}
-
-function appendSearchParams(
-  target: URLSearchParams,
-  source: Record<string, string | string[] | undefined>,
-) {
-  for (const [key, value] of Object.entries(source)) {
-    if (Array.isArray(value)) {
-      for (const item of value) target.append(key, item);
-    } else if (value !== undefined) {
-      target.set(key, value);
-    }
-  }
-}
-
-async function buildPreviewRequest(props: DecoPreviewPageProps): Promise<Request> {
-  const [params, searchParams, requestHeaders] = await Promise.all([
-    props.params,
-    props.searchParams,
-    headers(),
-  ]);
-  const host = requestHeaders.get("x-forwarded-host") ?? requestHeaders.get("host") ?? "localhost";
-  const protocol = requestHeaders.get("x-forwarded-proto") ?? "http";
-  const encodedPath = (params.path ?? []).map(encodeURIComponent).join("/");
-  const url = new URL(`/live/previews/${encodedPath}`, `${protocol}://${host}`);
-  appendSearchParams(url.searchParams, searchParams);
-  return new Request(url, { headers: new Headers(requestHeaders) });
-}
-
-function PreviewResources() {
-  const { cssHref, fontHrefs } = getRenderShellConfig();
-  return (
-    <>
-      {fontHrefs.map((href) => (
-        <link key={href} rel="stylesheet" href={href} />
-      ))}
-      {cssHref ? <link rel="stylesheet" href={cssHref} /> : null}
-    </>
-  );
-}
-
-function PreviewFrame({ children }: { children: ReactNode }) {
-  const { themeName, bodyClass } = getRenderShellConfig();
-  const Wrapper = getPreviewWrapper();
-  const content = Wrapper ? createElement(Wrapper, null, children) : children;
-
-  return (
-    <>
-      <PreviewResources />
-      <div data-theme={themeName || "light"} className={bodyClass || undefined}>
-        {content}
-      </div>
-      <script dangerouslySetInnerHTML={{ __html: LIVE_CONTROLS_SCRIPT }} />
-    </>
-  );
-}
-
-function PreviewDiagnostic({ children }: { children: ReactNode }) {
-  return <div style={{ padding: 20, color: "red" }}>{children}</div>;
-}
-
-export function createDecoPreviewPage(options: CreateDecoPreviewPageOptions = {}) {
-  return async function DecoPreviewPage(props: DecoPreviewPageProps) {
-    await options.setup?.();
-
-    try {
-      const request = await buildPreviewRequest(props);
-      const resolution = await resolvePreviewRequest(request);
-      if (resolution.type === "unknown") {
-        return (
-          <PreviewFrame>
-            <PreviewDiagnostic>{`Unknown section: ${resolution.component}`}</PreviewDiagnostic>
-          </PreviewFrame>
-        );
-      }
-
-      const rendered = await Promise.all(
-        resolution.sections.map(async (section, index): Promise<ReactElement | null> => {
-          const element = await SectionRenderer({ resolved: section });
-          return element
-            ? cloneElement(element, { key: `${section.key}-${section.index ?? index}` })
-            : null;
-        }),
-      );
-
-      return <PreviewFrame>{rendered}</PreviewFrame>;
-    } catch (error) {
-      return (
-        <PreviewFrame>
-          <PreviewDiagnostic>{`Render error: ${(error as Error).message}`}</PreviewDiagnostic>
-        </PreviewFrame>
-      );
-    }
-  };
-}

package/src/draft.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { DRAFT_COOKIE_OPTIONS, DRAFT_PARAM, decideDraft } from "./draft";
-
-function urlWith(param?: string): URL {
-  const url = new URL("https://site.example/some/page");
-  if (param !== undefined) url.searchParams.set(DRAFT_PARAM, param);
-  return url;
-}
-
-describe("decideDraft", () => {
-  it("enters draft mode from the param and sets the cookie", () => {
-    expect(decideDraft(urlWith("abc@v1"), null)).toEqual({
-      pointer: "abc@v1",
-      setCookie: "abc@v1",
-      clearCookie: false,
-    });
-  });
-
-  it("carries the draft across navigation via the cookie alone", () => {
-    // The param is gone — this is the in-preview link click that a
-    // param-only design would silently drop back to published.
-    expect(decideDraft(urlWith(), "abc@v1")).toEqual({
-      pointer: "abc@v1",
-      setCookie: null,
-      clearCookie: false,
-    });
-  });
-
-  it("lets the param override a stale cookie", () => {
-    // Studio navigating to a newer version must win over the older pointer
-    // still sitting in the cookie, or a save would never be reflected.
-    expect(decideDraft(urlWith("abc@v2"), "abc@v1")).toEqual({
-      pointer: "abc@v2",
-      setCookie: "abc@v2",
-      clearCookie: false,
-    });
-  });
-
-  it("leaves draft mode on ?__draft=off, even with a cookie set", () => {
-    expect(decideDraft(urlWith("off"), "abc@v1")).toEqual({
-      pointer: null,
-      setCookie: null,
-      clearCookie: true,
-    });
-  });
-
-  it("is inert for an ordinary request", () => {
-    expect(decideDraft(urlWith(), null)).toEqual({
-      pointer: null,
-      setCookie: null,
-      clearCookie: false,
-    });
-  });
-});
-
-describe("DRAFT_COOKIE_OPTIONS", () => {
-  it("is set up to survive a cross-site preview iframe", () => {
-    // The preview iframe is cross-site (Studio embeds the production origin),
-    // so the cookie is third-party. Without SameSite=None+Secure it is never
-    // sent; without Partitioned (CHIPS) it is dropped as browsers wind down
-    // unpartitioned third-party cookies. These attributes are load-bearing,
-    // not incidental.
-    expect(DRAFT_COOKIE_OPTIONS.sameSite).toBe("none");
-    expect(DRAFT_COOKIE_OPTIONS.secure).toBe(true);
-    expect(DRAFT_COOKIE_OPTIONS.partitioned).toBe(true);
-    expect(DRAFT_COOKIE_OPTIONS.httpOnly).toBe(true);
-  });
-
-  it("is short-lived so a stale pointer can't pin an old version", () => {
-    expect(DRAFT_COOKIE_OPTIONS.maxAge).toBeLessThanOrEqual(60 * 60);
-  });
-});