@decocms/nextjs 8.1.0-next.0 → 8.4.0

package/src/DraftPreviewBadge.tsx

@@ -1,16 +0,0 @@
-"use client";
-
-/**
- * The preview-mode badge now lives in the runtime core so both bindings share
- * one implementation — see `@decocms/blocks/preview`. This module is a thin
- * re-export kept for back-compat: sites and `DraftPreviewIndicator` import the
- * badge (and the pure `buildShareUrl`/`buildExitUrl` helpers) from here.
- * `isFramed` stays internal to `@decocms/blocks/preview` — it was never part of
- * this package's public surface.
- */
-export {
-  buildExitUrl,
-  buildShareUrl,
-  DraftPreviewBadge,
-  type DraftPreviewBadgeProps,
-} from "@decocms/blocks/preview";

package/src/SectionRenderer.test.tsx

@@ -1,97 +0,0 @@
-import { registerSection, registerSections, registerSectionsSync } from "@decocms/blocks/cms";
-import { renderToString } from "react-dom/server";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { SectionRenderer } from "./SectionRenderer";
-
-function Hero({ label }: { label?: string }) {
-  return <h1>{`hero-${label ?? "none"}`}</h1>;
-}
-
-// The test environment runs under jsdom (see root vitest.config.ts), where
-// `window` is defined. next/dynamic's internals branch on
-// `typeof window === "undefined"` to decide server vs. client behavior, so
-// under jsdom it always takes the client path — `{ ssr: false }` vs.
-// `{ ssr: true }` produce IDENTICAL rendered output here (both effectively
-// render `null` during a synchronous renderToString call, since the loader's
-// promise can't resolve in time regardless of the ssr option). Asserting on
-// rendered HTML would therefore pass even if ClientOnlySection passed
-// `{ ssr: true }` by mistake — it exercises no real server/window-undefined
-// code path in this environment.
-//
-// Instead we verify the actual contract ClientOnlySection is responsible
-// for: that it calls next/dynamic with `{ ssr: false }`. We spy on the
-// `next/dynamic` module import via `vi.mock` + `vi.hoisted`.
-const { dynamicSpy } = vi.hoisted(() => ({ dynamicSpy: vi.fn() }));
-
-vi.mock("next/dynamic", () => ({
-  default: (loader: unknown, options: unknown) => {
-    dynamicSpy(loader, options);
-    return function DynamicStub() {
-      return null;
-    };
-  },
-}));
-
-beforeEach(() => {
-  dynamicSpy.mockClear();
-});
-
-describe("SectionRenderer (next)", () => {
-  it("renders a sync-registered section directly", async () => {
-    const KEY = "site/sections/NextSyncA.tsx";
-    registerSectionsSync({ [KEY]: { default: Hero } });
-
-    const element = await SectionRenderer({
-      resolved: { key: KEY, component: KEY, props: { label: "a" } } as any,
-    });
-    const html = renderToString(element);
-    expect(html).toContain("hero-a");
-  });
-
-  it("awaits a code-split (non-sync) section's loader", async () => {
-    const KEY = "site/sections/NextLazyA.tsx";
-    registerSections({ [KEY]: () => Promise.resolve({ default: Hero }) });
-
-    const element = await SectionRenderer({
-      resolved: { key: KEY, component: KEY, props: { label: "b" } } as any,
-    });
-    const html = renderToString(element);
-    expect(html).toContain("hero-b");
-  });
-
-  it("routes a clientOnly-registered section through next/dynamic with ssr:false", async () => {
-    const KEY = "site/sections/NextClientOnlyA.tsx";
-    const loader = () => Promise.resolve({ default: Hero });
-    registerSection(KEY, loader, { clientOnly: true });
-
-    const element = await SectionRenderer({
-      resolved: { key: KEY, component: KEY, props: { label: "c" } } as any,
-    });
-    const html = renderToString(element);
-
-    // The actual contract: ClientOnlySection must call next/dynamic with
-    // { ssr: false } for this section's loader. This fails if the
-    // implementation is changed to pass { ssr: true } (or omits the option).
-    expect(dynamicSpy).toHaveBeenCalledWith(loader, { ssr: false });
-
-    // The section shell (wrapping <section> + manifest key) still renders
-    // server-side regardless of the dynamic child's ssr option.
-    expect(html).toContain(`data-manifest-key="${KEY}"`);
-  });
-
-  it("warns and renders nothing for an unregistered section", async () => {
-    const KEY = "site/sections/NextMissingA.tsx";
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-
-    const element = await SectionRenderer({
-      resolved: { key: KEY, component: KEY, props: {} } as any,
-    });
-
-    expect(element).toBeNull();
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining(`No component registered for: ${KEY}`),
-    );
-
-    warnSpy.mockRestore();
-  });
-});

package/src/SectionRenderer.tsx

@@ -1,58 +0,0 @@
-import type { ResolvedSection } from "@decocms/blocks/cms";
-import { getSection, getSectionOptions, getSyncComponent } from "@decocms/blocks/cms";
-import { SectionErrorBoundary } from "@decocms/blocks/hooks";
-import { createElement, type ReactNode } from "react";
-import { ClientOnlySection } from "./ClientOnlySection";
-
-interface SectionRendererProps {
-  resolved: ResolvedSection;
-  errorFallback?: ReactNode;
-}
-
-/**
- * Renders one resolved section. Runs inside an async Server Component tree,
- * so code-split sections are loaded via a plain await — no client-side
- * React.lazy/Suspense needed for content in the initial response.
- */
-export async function SectionRenderer({ resolved, errorFallback }: SectionRendererProps) {
-  const sectionId = resolved.key
-    .replace(/\//g, "-")
-    .replace(/\.tsx$/, "")
-    .replace(/^site-sections-/, "");
-
-  const options = getSectionOptions(resolved.component);
-  const errFallback = options?.errorFallback
-    ? createElement(options.errorFallback, { error: new Error("") })
-    : errorFallback;
-
-  const isClientOnly = options?.clientOnly === true;
-  const SyncComp = getSyncComponent(resolved.component);
-  let content: ReactNode;
-
-  if (isClientOnly) {
-    const loader = getSection(resolved.component);
-    if (!loader) {
-      console.warn(`[SectionRenderer] No component registered for: ${resolved.component}`);
-      return null;
-    }
-    content = <ClientOnlySection loader={loader} props={resolved.props} />;
-  } else if (SyncComp) {
-    content = createElement(SyncComp, resolved.props);
-  } else {
-    const loader = getSection(resolved.component);
-    if (!loader) {
-      console.warn(`[SectionRenderer] No component registered for: ${resolved.component}`);
-      return null;
-    }
-    const mod = await loader();
-    content = createElement(mod.default, resolved.props);
-  }
-
-  return (
-    <section id={sectionId} data-manifest-key={resolved.key}>
-      <SectionErrorBoundary sectionKey={resolved.key} fallback={errFallback}>
-        {content}
-      </SectionErrorBoundary>
-    </section>
-  );
-}

package/src/__conformance__/observability.test.ts

@@ -1,66 +0,0 @@
-// @vitest-environment node
-/**
- * Conformance: the Next.js half of caching.mdx ("Upstream data": requests go
- * through Next's data cache, no cache of the binding's own) and of
- * telemetry.mdx ("What's sent": the bindings add no measurements of their own;
- * inbound requests come from Next's own OpenTelemetry setup).
- */
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { createInstrumentedFetch } from "@decocms/blocks/fetch";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const SRC = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-
-function sources(): { file: string; text: string }[] {
-  const out: { file: string; text: string }[] = [];
-  const walk = (dir: string) => {
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name !== "__conformance__" && entry.name !== "__tests__") walk(full);
-      } else if (/\.(ts|tsx|cjs|js)$/.test(entry.name) && !/\.test\./.test(entry.name)) {
-        out.push({ file: path.relative(SRC, full), text: fs.readFileSync(full, "utf8") });
-      }
-    }
-  };
-  walk(SRC);
-  return out;
-}
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-describe("upstream data on Next.js (caching.mdx)", () => {
-  it("cache-04: the instrumented fetch goes through the fetch Next patches, with Next's cache options intact", async () => {
-    const instrumented = createInstrumentedFetch({ provider: "acme-search" });
-    // Next replaces globalThis.fetch after modules load; the instrumented fetch must use it.
-    const nextFetch = vi.fn(async () => new Response("{}"));
-    vi.stubGlobal("fetch", nextFetch);
-    await instrumented("https://search.example/q", {
-      operation: "search",
-      next: { revalidate: 60, tags: ["search"] },
-    } as RequestInit & { operation: string });
-    expect(nextFetch).toHaveBeenCalledTimes(1);
-    const init = (nextFetch.mock.calls[0] as unknown as [unknown, Record<string, unknown>])[1];
-    expect(init.next).toEqual({ revalidate: 60, tags: ["search"] });
-  });
-
-  it("cache-04: @decocms/nextjs has no upstream cache of its own", () => {
-    const own = sources().filter(({ text }) =>
-      /caches\.default|caches\.open|createFetchCache|fetchWithCache/.test(text),
-    );
-    expect(own.map((s) => s.file)).toEqual([]);
-  });
-});
-
-describe("what the binding adds (telemetry.mdx › What's sent)", () => {
-  it("tel-09: @decocms/nextjs adds no measurements of its own (no inbound or page-cache metrics)", () => {
-    const reporters = sources().filter(({ text }) =>
-      /http\.server\.request\.duration|decocms\.blocks\.telemetry/.test(text),
-    );
-    expect(reporters.map((s) => s.file)).toEqual([]);
-  });
-});

package/src/config.cjs

@@ -1,92 +0,0 @@
-/**
- * next.config wrapper for Deco sites. CommonJS on purpose: next.config.js
- * is CJS in most sites and this package is "type": "module", so a .js
- * file here would be ESM and unrequireable on Node < 22.
- *
- * Adds:
- * 1. Rewrites for the Studio-protocol URLs Next cannot express as route
- *    segments — `/.decofile` (segments can't start with a dot) and
- *    `/live/_meta` (`_`-prefixed segments are Next "private folders",
- *    silently excluded from routing) — plus `/live/previews/*`, all
- *    funneled to `/deco/*` where a single catch-all route
- *    (`app/deco/[[...deco]]/route.ts` + createDecoRouteHandlers) serves
- *    the whole protocol.
- * 2. transpilePackages for the raw-TS @decocms packages.
- * 3. Response headers that keep a draft-preview render out of every cache.
- */
-const DECO_REWRITES = [
-  { source: "/.decofile", destination: "/deco/decofile" },
-  { source: "/live/_meta", destination: "/deco/meta" },
-  { source: "/live/previews/:path*", destination: "/deco/previews/:path*" },
-];
-
-const DECO_TRANSPILE = ["@decocms/blocks", "@decocms/blocks-admin", "@decocms/nextjs"];
-
-/**
- * A draft render must never be cached or indexed: with the pointer in a cookie
- * it shares a URL with the published page, so a shared cache keyed on URL alone
- * would serve unpublished content to a real visitor.
- *
- * Two rules, not one: `has` entries within a rule are ANDed, and the two
- * signals never coincide. On ENTRY the pointer is in the query and the cookie
- * has not been set yet (middleware sets it in the response); on every
- * navigation after that it is the cookie and the query is gone.
- *
- * MEASURED LIMIT — do not assume `no-store` is in force. On a *dynamic* App
- * Router response Next reserves `Cache-Control` and `Vary` and overwrites
- * whatever we set, from here AND from middleware: the wire shows
- * `Cache-Control: no-cache, must-revalidate` and
- * `Vary: rsc, next-router-state-tree, …`. Verified that these rules do match
- * (a marker header on the same rules came through on both signals and was
- * correctly absent otherwise) — it is those two header names specifically that
- * Next owns. `X-Robots-Tag` does get through.
- *
- * Why that is still safe: `no-cache` is not "don't cache", it is "never reuse
- * without revalidating with the origin", so a compliant shared cache cannot
- * serve a stored draft to a different visitor — it has to ask us first, and we
- * answer per-request. That also covers the loss of `Vary: Cookie`. The residual
- * risk is a cache that ignores `no-cache`; closing that needs a CDN-level rule,
- * which is a deployment concern rather than something this package can set.
- * `Cache-Control`/`Vary` are kept here so the intent is explicit and so they
- * apply anywhere Next is not overriding them.
- */
-const DRAFT_NO_STORE_HEADERS = [
-  { key: "Cache-Control", value: "no-store, private" },
-  { key: "Vary", value: "Cookie" },
-  { key: "X-Robots-Tag", value: "noindex, nofollow" },
-];
-
-const DECO_DRAFT_HEADERS = [
-  {
-    source: "/:path*",
-    has: [{ type: "query", key: "__draft" }],
-    headers: DRAFT_NO_STORE_HEADERS,
-  },
-  {
-    source: "/:path*",
-    has: [{ type: "cookie", key: "__deco_draft" }],
-    headers: DRAFT_NO_STORE_HEADERS,
-  },
-];
-
-function withDeco(nextConfig = {}) {
-  const userRewrites = nextConfig.rewrites;
-  const userHeaders = nextConfig.headers;
-  return {
-    ...nextConfig,
-    transpilePackages: [...new Set([...(nextConfig.transpilePackages ?? []), ...DECO_TRANSPILE])],
-    async rewrites() {
-      const user = typeof userRewrites === "function" ? await userRewrites() : (userRewrites ?? []);
-      if (Array.isArray(user)) return [...DECO_REWRITES, ...user];
-      return { ...user, beforeFiles: [...DECO_REWRITES, ...(user.beforeFiles ?? [])] };
-    },
-    async headers() {
-      const user = typeof userHeaders === "function" ? await userHeaders() : (userHeaders ?? []);
-      // Draft rules first: a site's own catch-all Cache-Control must not win
-      // over the one thing standing between a draft and a shared cache.
-      return [...DECO_DRAFT_HEADERS, ...user];
-    },
-  };
-}
-
-module.exports = { withDeco, DECO_REWRITES, DECO_DRAFT_HEADERS };

package/src/config.d.cts

@@ -1,4 +0,0 @@
-import type { NextConfig } from "next";
-
-export declare const DECO_REWRITES: Array<{ source: string; destination: string }>;
-export declare function withDeco(nextConfig?: NextConfig): NextConfig;

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();
-  });
-});