@decocms/nextjs 8.1.0-next.0 → 8.5.0

package/src/DecoPageRenderer.test.tsx

@@ -1,37 +0,0 @@
-import { registerSectionsSync } from "@decocms/blocks/cms";
-import { renderToString } from "react-dom/server";
-import { describe, expect, it } from "vitest";
-import { DecoPageRenderer } from "./DecoPageRenderer";
-
-function Hero({ label }: { label?: string }) {
-  return <h1>{`hero-${label ?? "none"}`}</h1>;
-}
-
-describe("DecoPageRenderer (next)", () => {
-  it("renders eager sections in order", async () => {
-    registerSectionsSync({
-      "site/sections/NextPageA.tsx": { default: Hero },
-      "site/sections/NextPageB.tsx": { default: Hero },
-    });
-
-    const element = await DecoPageRenderer({
-      sections: [
-        {
-          key: "site/sections/NextPageA.tsx",
-          component: "site/sections/NextPageA.tsx",
-          props: { label: "first" },
-          index: 0,
-        } as any,
-        {
-          key: "site/sections/NextPageB.tsx",
-          component: "site/sections/NextPageB.tsx",
-          props: { label: "second" },
-          index: 1,
-        } as any,
-      ],
-      pagePath: "/",
-    });
-    const html = renderToString(element);
-    expect(html.indexOf("hero-first")).toBeLessThan(html.indexOf("hero-second"));
-  });
-});

package/src/DecoPageRenderer.tsx

@@ -1,107 +0,0 @@
-import type { DeferredSection, ResolvedSection } from "@decocms/blocks/cms";
-import { resolveDeferredSection } from "@decocms/blocks/cms";
-import { cloneElement, type ReactElement, type ReactNode } from "react";
-import { DeferredSectionBoundary } from "./DeferredSection";
-import { SectionRenderer } from "./SectionRenderer";
-
-interface DecoPageRendererProps {
-  sections: ResolvedSection[];
-  deferredSections?: DeferredSection[];
-  pagePath: string;
-  pageUrl?: string;
-  loadingFallback?: ReactNode;
-  errorFallback?: ReactNode;
-}
-
-type PageItem =
-  | { type: "eager"; section: ResolvedSection; sort: number }
-  | { type: "deferred"; deferred: DeferredSection; sort: number };
-
-function mergeSections(resolved: ResolvedSection[], deferred: DeferredSection[]): PageItem[] {
-  const items: PageItem[] = [];
-  resolved.forEach((section, i) =>
-    items.push({ type: "eager", section, sort: section.index ?? i }),
-  );
-  for (const d of deferred) items.push({ type: "deferred", deferred: d, sort: d.index });
-  items.sort((a, b) => a.sort - b.sort);
-  return items;
-}
-
-/**
- * Top-level renderer for a resolved CMS page. Kicks off (but does not await)
- * each deferred section's resolve promise immediately, so they resolve
- * concurrently with the eager sections' own rendering — React's streaming
- * SSR then flushes each <Suspense> boundary as its promise settles.
- */
-export async function DecoPageRenderer({
-  sections,
-  deferredSections = [],
-  pagePath,
-  pageUrl,
-  loadingFallback,
-  errorFallback,
-}: DecoPageRendererProps) {
-  const items = mergeSections(sections, deferredSections);
-
-  // `resolveDeferredSection`'s real signature (packages/blocks/src/cms/resolve.ts)
-  // takes positional args `(component, rawProps, pagePath, matcherCtx?)` and
-  // returns a `ResolvedSection` WITHOUT `index` set — unlike the object-shaped
-  // call the plan sketch assumed. `pageUrl` isn't a direct parameter either; it
-  // flows in via `matcherCtx.url`, mirroring how the TanStack route loader
-  // builds `matcherCtx` for `loadDeferredSection` (packages/tanstack/src/routes/cmsRoute.ts).
-  // We also stamp `index` onto the resolved section ourselves (mirroring what
-  // `resolveDeferredSectionFull` does) so downstream consumers can rely on it.
-  const matcherCtx = pageUrl ? { url: pageUrl } : undefined;
-  const deferredPromises = new Map<number, Promise<ResolvedSection | null>>();
-  for (const d of deferredSections) {
-    deferredPromises.set(
-      d.index,
-      resolveDeferredSection(d.component, d.rawProps ?? {}, pagePath, matcherCtx).then(
-        (resolved) => {
-          if (!resolved) return null;
-          return { ...resolved, index: d.index };
-        },
-      ),
-    );
-  }
-
-  // Eager sections are resolved via a direct (awaited) function call rather
-  // than nested as a `<SectionRenderer />` JSX child. `SectionRenderer` is an
-  // async function; Next's real RSC renderer awaits async components nested
-  // anywhere in the tree, but that's specific to the RSC streaming renderer —
-  // plain `react-dom/server` (used by this package's unit tests, and by any
-  // consumer that isn't going through Next's RSC pipeline) throws ("A
-  // component suspended while responding to synchronous input") when an async
-  // component suspends outside a `<Suspense>` boundary. Deferred sections are
-  // deliberately exempt: `DeferredSectionBoundary` wraps its async child in a
-  // `<Suspense>`, so letting it suspend there is exactly the intended
-  // behavior (renders the fallback synchronously, then streams in later).
-  //
-  // `deferredPromises` above is already populated before this `Promise.all`
-  // runs, so every deferred resolve is in flight concurrently with eager
-  // section rendering — nothing here blocks on it.
-  const rendered = await Promise.all(
-    items.map(async (item): Promise<ReactElement | null> => {
-      if (item.type === "eager") {
-        const element = await SectionRenderer({
-          resolved: item.section,
-          errorFallback,
-        });
-        if (!element) return null;
-        return cloneElement(element, { key: `${item.section.key}-${item.section.index}` });
-      }
-      return (
-        <DeferredSectionBoundary
-          key={`deferred-${item.deferred.key}-${item.deferred.index}`}
-          deferred={item.deferred}
-          promise={deferredPromises.get(item.deferred.index)!}
-          pagePath={pagePath}
-          fallback={loadingFallback}
-          errorFallback={errorFallback}
-        />
-      );
-    }),
-  );
-
-  return <>{rendered}</>;
-}

package/src/DecoRootLayout.test.tsx

@@ -1,22 +0,0 @@
-import { renderToString } from "react-dom/server";
-import { describe, expect, it } from "vitest";
-import { DecoRootLayout } from "./DecoRootLayout";
-
-describe("DecoRootLayout (next)", () => {
-  it("renders the html shell with LiveControls and the analytics bootstrap script", () => {
-    const html = renderToString(
-      <DecoRootLayout siteName="test-site">
-        <div>page content</div>
-      </DecoRootLayout>,
-    );
-    expect(html).toContain("page content");
-    expect(html).toContain("__DECO_STATE");
-    // "window.DECO" alone is a false-positive trap: it also appears twice in
-    // this component's own inline bootstrap script (buildDecoEventsBootstrap's
-    // `window.DECO = window.DECO || {}` and `window.DECO.events = ...`), so it
-    // would still pass even if the ANALYTICS_SCRIPT <script> tag were deleted
-    // entirely. "IntersectionObserver" only exists inside ANALYTICS_SCRIPT
-    // (packages/blocks/src/sdk/analytics.ts) — it genuinely pins that script.
-    expect(html).toContain("IntersectionObserver");
-  });
-});

package/src/DecoRootLayout.tsx

@@ -1,82 +0,0 @@
-import { LiveControls } from "@decocms/blocks/hooks";
-import { ANALYTICS_SCRIPT } from "@decocms/blocks/sdk/analytics";
-import type { ReactNode } from "react";
-
-function buildDecoEventsBootstrap(account?: string): string {
-  const accountJson = JSON.stringify(account ?? "");
-  return `
-window.__RUNTIME__ = window.__RUNTIME__ || { account: ${accountJson} };
-window.DECO = window.DECO || {};
-window.DECO.events = window.DECO.events || {
-  _q: [],
-  _subs: [],
-  dispatch: function(e) {
-    this._q.push(e);
-    for (var i = 0; i < this._subs.length; i++) {
-      try { this._subs[i](e); } catch(err) { console.error('[DECO.events]', err); }
-    }
-  },
-  subscribe: function(fn) {
-    this._subs.push(fn);
-    for (var i = 0; i < this._q.length; i++) {
-      try { fn(this._q[i]); } catch(err) {}
-    }
-  }
-};
-window.dataLayer = window.dataLayer || [];
-`;
-}
-
-export interface DecoRootLayoutProps {
-  /** Language attribute for the <html> tag. Default: "en" */
-  lang?: string;
-  /** DaisyUI data-theme attribute. Default: "light" */
-  dataTheme?: string;
-  /** Site name for LiveControls (admin iframe communication). Required. */
-  siteName: string;
-  /** Commerce platform account name for analytics bootstrap (e.g. VTEX account). */
-  account?: string;
-  /** CSS class for <body>. Default: "bg-base-200 text-base-content" */
-  bodyClassName?: string;
-  children?: ReactNode;
-}
-
-/**
- * Root layout for app/layout.tsx — the Next.js analogue of
- * `@decocms/tanstack`'s `DecoRootLayout`.
- *
- * The bootstrap/analytics <script> tags run once per navigation session
- * because Next.js App Router doesn't remount a shared layout.tsx across
- * same-layout navigations — the same property TanStack's <ScriptOnce>
- * provides explicitly, here implicit in the framework's own layout model.
- * That's why a plain inline <script> (rather than a ScriptOnce-like helper)
- * is sufficient here.
- *
- * No <head>/<HeadContent> equivalent: Next.js App Router injects
- * `generateMetadata`'s output automatically, and a root layout.tsx doesn't
- * render its own <head> element by convention.
- *
- * No NavigationProgress/StableOutlet port in v1 — those are
- * TanStack-Router-specific SPA-navigation UX polish (a loading bar during
- * client-side nav, height-preserved outlet), not part of the core
- * CMS-rendering feature set this plan scopes.
- */
-export function DecoRootLayout({
-  lang = "en",
-  dataTheme = "light",
-  siteName,
-  account,
-  bodyClassName = "bg-base-200 text-base-content",
-  children,
-}: DecoRootLayoutProps) {
-  return (
-    <html lang={lang} data-theme={dataTheme} suppressHydrationWarning>
-      <body className={bodyClassName} suppressHydrationWarning>
-        <script dangerouslySetInnerHTML={{ __html: buildDecoEventsBootstrap(account) }} />
-        {children}
-        <LiveControls site={siteName} />
-        <script dangerouslySetInnerHTML={{ __html: ANALYTICS_SCRIPT }} />
-      </body>
-    </html>
-  );
-}

package/src/DeferredSection.test.tsx

@@ -1,27 +0,0 @@
-import { registerSectionsSync } from "@decocms/blocks/cms";
-import { renderToString } from "react-dom/server";
-import { describe, expect, it } from "vitest";
-import { DeferredSectionBoundary } from "./DeferredSection";
-
-function Hero({ label }: { label?: string }) {
-  return <h1>{`hero-${label ?? "none"}`}</h1>;
-}
-
-describe("DeferredSectionBoundary (next)", () => {
-  it("renders the fallback while the promise is pending, per Suspense semantics", () => {
-    const KEY = "site/sections/NextDeferredA.tsx";
-    registerSectionsSync({ [KEY]: { default: Hero } });
-
-    const neverResolves = new Promise<any>(() => {});
-    const html = renderToString(
-      <DeferredSectionBoundary
-        deferred={{ key: KEY, component: KEY, index: 0 } as any}
-        promise={neverResolves}
-        pagePath="/"
-        fallback={<div>loading</div>}
-      />,
-    );
-    expect(html).toContain("loading");
-    expect(html).not.toContain("hero-");
-  });
-});

package/src/DeferredSection.tsx

@@ -1,59 +0,0 @@
-import type { DeferredSection, ResolvedSection } from "@decocms/blocks/cms";
-import { SectionErrorBoundary } from "@decocms/blocks/hooks";
-import { type ReactNode, Suspense } from "react";
-import { SectionRenderer } from "./SectionRenderer";
-
-interface DeferredSectionBoundaryProps {
-  deferred: DeferredSection;
-  promise: Promise<ResolvedSection | null>;
-  pagePath: string;
-  fallback?: ReactNode;
-  errorFallback?: ReactNode;
-}
-
-async function ResolvedDeferredSection({
-  promise,
-  errorFallback,
-}: {
-  promise: Promise<ResolvedSection | null>;
-  errorFallback?: ReactNode;
-}) {
-  const resolved = await promise;
-  if (!resolved) return null;
-  return <SectionRenderer resolved={resolved} errorFallback={errorFallback} />;
-}
-
-/**
- * Deferred/streamed section — the RSC-native analogue of DecoPageRenderer's
- * <Suspense><Await promise={promise}>{...}</Await></Suspense>. React 19
- * Server Components can await a promise directly inside an async component,
- * so there is no need for TanStack's <Await> wrapper — <Suspense> here is
- * the same React primitive TanStack also uses, just without the extra
- * unwrapping component.
- */
-export function DeferredSectionBoundary({
-  deferred,
-  promise,
-  pagePath: _pagePath,
-  fallback,
-  errorFallback,
-}: DeferredSectionBoundaryProps) {
-  const sectionId = deferred.key
-    .replace(/\//g, "-")
-    .replace(/\.tsx$/, "")
-    .replace(/^site-sections-/, "");
-
-  return (
-    <SectionErrorBoundary sectionKey={deferred.key} fallback={errorFallback}>
-      <Suspense
-        fallback={
-          <section id={sectionId} data-manifest-key={deferred.key} data-deferred="true">
-            {fallback}
-          </section>
-        }
-      >
-        <ResolvedDeferredSection promise={promise} errorFallback={errorFallback} />
-      </Suspense>
-    </SectionErrorBoundary>
-  );
-}

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;