@decocms/nextjs 8.1.0-next.0 → 8.4.0

package/src/draft.ts

@@ -1,231 +1,45 @@
 /**
- * Draft preview — the Next.js binding.
- *
- * `@decocms/blocks`'s `draftSource` owns the framework-agnostic half (pointer
- * parsing, origin construction, fetch, version cache). This file binds a
- * resolved draft to the current request.
- *
- * ## Why React `cache()` and not AsyncLocalStorage
- *
- * App Router never enters `RequestContext.run` (that is a TanStack/Workers
- * path), and ALS cannot help here anyway: you cannot wrap `ALS.run()` around a
- * component's children, because the children render later, outside the call.
- * `cache()` gives a per-request memoized value in RSC, which is exactly the
- * scope needed — verified concurrently, see `draft.test.ts`.
- *
- * ## Why this must be awaited by the PAGE, not a layout
- *
- * A layout's `await` does NOT gate its children: App Router renders a layout
- * and its children concurrently, so sections call `loadBlocks()` before a
- * layout-level resolve lands, and silently render published content. The
- * resolve has to happen somewhere that returns the subtree *after* awaiting —
- * i.e. the page component. `ensureDraft()` exists so each site makes one call
- * instead of re-deriving that ordering rule.
+ * The draft names and headers of a Deco Next.js site: the `?__draft=` link,
+ * the cookie that keeps a preview going, the request header the proxy hands
+ * the pages, and the response headers of a page rendered from a draft. The
+ * proxy reads and writes them (`./drafts.ts`, `./proxy`); the pages read the
+ * header (`./server`); `./config/index.cjs` repeats them (`config.test.ts`
+ * holds them equal). This package's own copy: it never imports
+ * `@decocms/tanstack`. No imports, no state: safe in every bundle.
  */
-import {
-  isDraftHostAllowed,
-  resolveDraftDecofile,
-  setDraftOverrideGetter,
-} from "@decocms/blocks/cms";
-import { cookies, headers } from "next/headers";
-import { cache } from "react";
-import { DRAFT_COOKIE, DRAFT_HEADER, DRAFT_PARAM } from "./draftConstants";
-
-// Re-exported for back-compat: these used to live here, but the client badge
-// needs DRAFT_PARAM and cannot import this module (it pulls in `next/headers`).
-export { DRAFT_COOKIE, DRAFT_HEADER, DRAFT_PARAM } from "./draftConstants";
 
 /**
- * Request-scoped slot.
- *
- * `cache()` memoizes per-request, so every call within one request gets the
- * same object and a different one per request. Mutable by design: the page
- * fills it before returning its subtree, and nested sections read it
- * synchronously through `loadBlocks()`.
- *
- * `pointer` is the raw `<host>@<version>` token this render is bound to, kept
- * so the UI can surface an explicit "you are in preview" indicator and build a
- * shareable link — see {@link getActiveDraftPointer}.
+ * The query parameter a draft link carries (`?__draft=<pointer>`, or `off` to
+ * end a preview). The proxy reads it after its host check; reading it
+ * directly would skip that check.
  */
-const draftSlot = cache((): {
-  blocks: Record<string, unknown> | null;
-  pointer: string | null;
-} => ({
-  blocks: null,
-  pointer: null,
-}));
+export const DRAFT_PARAM = "__draft";
 
 /**
- * Register the request-scoped getter with the runtime.
- *
- * Idempotent and safe to call at module scope: outside a request `cache()`
- * still returns an object, whose `blocks` is null, so `loadBlocks()` sees no
- * override and behaves exactly as before.
+ * The cookie that keeps a preview going after the first draft link. Like
+ * {@link DRAFT_PARAM}, the proxy reads it after its host check.
  */
-let registered = false;
-export function registerDraftOverride(): void {
-  if (registered) return;
-  registered = true;
-  setDraftOverrideGetter(() => draftSlot().blocks);
-}
-
-/** A page's `searchParams` prop, before it is narrowed. */
-export type DraftSearchParams = Record<string, string | string[] | undefined>;
-
-/** First value of a search param that may legitimately repeat. */
-function firstParam(searchParams: DraftSearchParams | undefined, key: string): string | null {
-  const raw = searchParams?.[key];
-  if (Array.isArray(raw)) return raw[0] ?? null;
-  return raw ?? null;
-}
-
-/**
- * The pointer for this request: the query param wins, the cookie carries
- * navigation, `off` exits.
- *
- * Read directly from the page rather than trusted from a request header. The
- * param has to take precedence or a save would never surface — Studio
- * navigating to a new version would keep rendering whatever older pointer is
- * still sitting in the cookie.
- */
-export function selectDraftPointer(
-  searchParams: DraftSearchParams | undefined,
-  cookieValue: string | null | undefined,
-): string | null {
-  const param = firstParam(searchParams, DRAFT_PARAM);
-  if (param === "off") return null;
-  if (param) return param;
-  return cookieValue ?? null;
-}
-
-/**
- * Resolve the request's draft, if any, and bind it for the rest of the render.
- *
- * Call this from the PAGE, awaited, before returning the subtree:
- *
- * ```tsx
- * export default async function Page({ searchParams }) {
- *   await ensureDraft(await searchParams);
- *   return <DecoPageRenderer />;
- * }
- * ```
- *
- * Reads the param from the page's own `searchParams` and the cookie via
- * `cookies()`. There is deliberately no request header in the path: the page
- * owns the decision, so a draft keeps working on routes the middleware matcher
- * never sees, and there is one less forgeable input to reason about. (The
- * pointer was never a secret — the draft id (the token's authority) is the capability — so a
- * client supplying one directly is equivalent to typing the query param.)
- *
- * Returns whether a draft was bound, so callers can surface an explicit
- * "draft unavailable" state instead of silently showing published content —
- * the failure mode most likely to mislead someone reviewing their own edits.
- */
-export async function ensureDraft(searchParams?: DraftSearchParams): Promise<boolean> {
-  registerDraftOverride();
-
-  const [cookieStore, requestHeaders] = await Promise.all([cookies(), headers()]);
-
-  // Pointer precedence: the page's own `?__draft=` param wins; then the
-  // middleware-forwarded header (the only source a LAYOUT can see on the entry
-  // request — see DRAFT_HEADER); then the navigation cookie. This is what lets
-  // `ensureDraft()` bind from a layout so shell-resolved Header/Footer reflect
-  // the draft, not just page sections.
-  const carried = requestHeaders.get(DRAFT_HEADER) ?? cookieStore.get(DRAFT_COOKIE)?.value ?? null;
-  const pointer = selectDraftPointer(searchParams, carried);
-  if (!pointer) return false;
-
-  // Host gate, checked only once a pointer exists (headers() is a dynamic
-  // API): the same build may serve the preview domain and the production
-  // domain, and only hosts named in DECO_ALLOWED_PREVIEW_HOSTS may render
-  // drafts — production stays published no matter what the URL carries.
-  const host = requestHeaders.get("x-forwarded-host") ?? requestHeaders.get("host");
-  if (!isDraftHostAllowed(host)) return false;
-
-  const blocks = await resolveDraftDecofile({ pointer });
-  if (!blocks) return false;
-
-  const slot = draftSlot();
-  slot.blocks = blocks;
-  slot.pointer = pointer;
-  return true;
-}
+export const DRAFT_COOKIE = "__deco_draft";
 
 /**
- * The raw draft pointer bound to this request, or null if the request is not
- * rendering a draft.
- *
- * Synchronous — reads the same request-scoped slot `ensureDraft` fills, so it
- * must be called AFTER `ensureDraft` has been awaited in this request (i.e.
- * from inside the page subtree, not a concurrently-rendered layout). Powers
- * the preview-mode indicator: a bound pointer is the signal that the visitor
- * is looking at unpublished content, and it is exactly what a "share this
- * draft" link must carry.
+ * The request header the proxy sets on the request it hands the pages once it
+ * accepted the draft: the pointer, already checked. The proxy removes any
+ * copy that arrives from outside, and `bindDraft` repeats the host check, so a
+ * client can't send one itself.
  */
-export function getActiveDraftPointer(): string | null {
-  return draftSlot().pointer;
-}
-
-// ---------------------------------------------------------------------------
-// Middleware helper
-// ---------------------------------------------------------------------------
-
-/** What middleware should do with this request. */
-export interface DraftMiddlewareDecision {
-  /** The active pointer, or null. Drives the cache/indexing headers. */
-  pointer: string | null;
-  /** Set the cookie to this value (entering draft mode). */
-  setCookie: string | null;
-  /** Clear the cookie (leaving draft mode via `?__draft=off`). */
-  clearCookie: boolean;
-}
+export const DRAFT_HEADER = "x-deco-draft";
 
 /**
- * Decide the draft state for a request, from `?__draft=` and the cookie.
- *
- * The param is authoritative on entry and the cookie carries subsequent
- * in-preview navigation — a param alone dies on the first link click, and a
- * cookie alone cannot be relied on: the preview iframe is cross-site, so the
- * cookie is third-party and may be blocked outright (Safari ITP) or
- * partitioned (Chrome CHIPS). Entry therefore never depends on cookie support.
- *
- * `?__draft=off` leaves draft mode, so a session can be ended deliberately
- * rather than waiting for a cookie to expire.
- *
- * Pure and framework-free so it can be unit-tested without a Next request; the
- * caller applies the decision to its own `NextResponse`.
+ * The response headers of a page rendered from a draft: never stored by a
+ * browser or a CDN (`Cache-Control: no-store, private`, `Vary: Cookie`) and
+ * never indexed (`X-Robots-Tag: noindex, nofollow`). `{}` when `pointer` is
+ * `null`, so the result of the draft decision applies as is.
  */
-export function decideDraft(
-  url: URL,
-  cookieValue: string | null | undefined,
-): DraftMiddlewareDecision {
-  const param = url.searchParams.get(DRAFT_PARAM);
-
-  if (param === "off") {
-    return { pointer: null, setCookie: null, clearCookie: true };
-  }
-  if (param) {
-    return { pointer: param, setCookie: param, clearCookie: false };
-  }
-  if (cookieValue) {
-    return { pointer: cookieValue, setCookie: null, clearCookie: false };
-  }
-  return { pointer: null, setCookie: null, clearCookie: false };
+export function draftResponseHeaders(pointer: string | null | undefined): Record<string, string> {
+  if (!pointer) return {};
+  return {
+    "Cache-Control": "no-store, private",
+    Vary: "Cookie",
+    "X-Robots-Tag": "noindex, nofollow",
+  };
 }
-
-/**
- * Cookie attributes for the draft pointer.
- *
- * `SameSite=None; Secure` is mandatory for a cross-site iframe, and
- * `Partitioned` (CHIPS) is what keeps it working as browsers wind down
- * unpartitioned third-party cookies. Short-lived: a draft session is minutes,
- * and a stale pointer would keep pinning an old version.
- */
-export const DRAFT_COOKIE_OPTIONS = {
-  httpOnly: true,
-  secure: true,
-  sameSite: "none",
-  partitioned: true,
-  path: "/",
-  maxAge: 60 * 30,
-} as const;

package/src/drafts.ts

@@ -0,0 +1,229 @@
+/**
+ * Which hosts may render drafts: v7's allowlist (`@decocms/blocks` 7.x
+ * `cms/draftSource.ts`: `readAllowedHosts`, `isDraftHostAllowed`,
+ * `isDraftPreviewEnabled`), ported as is. v7 read its override from the
+ * `DECO_ALLOWED_PREVIEW_HOSTS` variable; here it is the `previewHosts` option,
+ * and the site passes the same options to the proxy (`decideDraft`) and to
+ * its pages (`bindDraft`).
+ *
+ * - The site's own preview hosts: the ones it declares, in the `CMS` block or
+ *   as `createCMS({ preview: { hosts } })` (matched as `cms.draftPointer`
+ *   matches them). A site that declares none has none, as in v7: blocks'
+ *   own default (every host) doesn't count as a declaration.
+ * - The hosts Deco runs the site on, named after the site and always added:
+ *   `<site>.deco.site` and `<site>.deco-cx.workers.dev`, exact.
+ * - `previewHosts: [...]` replaces the site's own list (the inferred hosts are
+ *   still added); `previewHosts: "none"` turns previews off on every host.
+ *
+ * Hosts compare exactly, lowercased, port included (`localhost:3000`). The
+ * host is the one the visitor asked for: `x-forwarded-host` behind a proxy,
+ * else `host`.
+ *
+ * The draft itself is the capability: a host check only bounds where a draft
+ * link works. A request the check refuses gets the release, never an error.
+ *
+ * No React, no Next.js and no module state: the proxy and the pages share it.
+ */
+import { type CMS, parseDraftPointer, type RequestLike } from "@decocms/blocks";
+import { DRAFT_COOKIE, DRAFT_PARAM } from "./draft.ts";
+
+export interface PreviewPolicy {
+  /** The site's name: `<site>.deco.site` and `<site>.deco-cx.workers.dev` may preview. */
+  site?: string;
+  /** Replaces the `CMS` block's preview hosts; `"none"` turns previews off everywhere. */
+  previewHosts?: readonly string[] | "none";
+}
+
+/** The hosts Deco runs `site` on, which may always preview (unless previews are off). */
+export function inferredPreviewHosts(site: string | undefined): string[] {
+  const s = (site ?? "").trim().toLowerCase();
+  return s ? [`${s}.deco.site`, `${s}.deco-cx.workers.dev`] : [];
+}
+
+function overrideHosts(policy: PreviewPolicy): string[] {
+  if (policy.previewHosts === "none") return ["none"];
+  return (policy.previewHosts ?? []).map((h) => h.trim().toLowerCase()).filter(Boolean);
+}
+
+/**
+ * Whether `host` may preview without asking the CMS: `true` (an override or
+ * inferred host), `false` (previews off, or the override leaves it out), or
+ * `"cms"` when only the site's declared preview hosts can say (none declared:
+ * `false`, see {@link declaresPreviewHosts}).
+ */
+export function previewHostDecision(host: string, policy: PreviewPolicy): boolean | "cms" {
+  const override = overrideHosts(policy);
+  if (override.includes("none")) return false;
+  const h = host.trim().toLowerCase();
+  if (h === "") return false;
+  if (inferredPreviewHosts(policy.site).includes(h)) return true;
+  if (policy.previewHosts !== undefined) return override.includes(h);
+  return "cms";
+}
+
+/**
+ * Whether any host may preview (v7's `isDraftPreviewEnabled`): a page checks
+ * it before it reads the request's headers, so a site with previews off never
+ * turns a static page dynamic. `false` for `previewHosts: "none"`; `true` with
+ * a site name or an override list; otherwise whether the site declares
+ * preview hosts and they allow any.
+ */
+export async function isDraftPreviewEnabled(
+  cms: Pick<CMS, "settings" | "forRelease">,
+  policy: PreviewPolicy,
+): Promise<boolean> {
+  const override = overrideHosts(policy);
+  if (override.includes("none")) return false;
+  if (inferredPreviewHosts(policy.site).length > 0) return true;
+  if (policy.previewHosts !== undefined) return override.length > 0;
+  return (await declaresPreviewHosts(cms)) && (await cms.settings()).preview.hosts.length > 0;
+}
+
+/**
+ * Whether the site declares its own preview hosts: in the `CMS` block, or as
+ * `createCMS`'s `preview.hosts`. When it declares none, `cms.settings()`
+ * reports blocks' default, every host (`["*"]`), which v7 never had: there,
+ * a site without a list previewed only on its Deco hosts. The saved `CMS`
+ * block tells an explicit `["*"]` from that default.
+ */
+export async function declaresPreviewHosts(
+  cms: Pick<CMS, "settings" | "forRelease">,
+): Promise<boolean> {
+  const { hosts } = (await cms.settings()).preview;
+  if (hosts.length !== 1 || hosts[0] !== "*") return true;
+  try {
+    const [block] = await cms.forRelease().resolve<unknown>("CMS", { run: false });
+    const preview = isRecord(block) ? block.preview : undefined;
+    return isRecord(preview) && ("hosts" in preview || "__resolveType" in preview);
+  } catch {
+    return false;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+const DRAFT_OFF = "off";
+
+function draftParam(request: RequestLike): string | null {
+  try {
+    return new URL(request.url, "http://localhost").searchParams.get(DRAFT_PARAM);
+  } catch {
+    return null;
+  }
+}
+
+function readCookie(header: string | null, name: string): string | null {
+  if (!header) return null;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1 || part.slice(0, eq).trim() !== name) continue;
+    try {
+      return decodeURIComponent(part.slice(eq + 1).trim());
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+/**
+ * The pointer a request carries, as `@decocms/blocks` reads it: `?__draft=`
+ * first, then the draft cookie; `null` for `?__draft=off` and for a value
+ * that doesn't parse.
+ */
+export function readDraftPointer(request: RequestLike): string | null {
+  const param = draftParam(request);
+  if (param === DRAFT_OFF) return null;
+  if (param && parseDraftPointer(param) !== null) return param;
+  const cookie = readCookie(request.headers.get("cookie"), DRAFT_COOKIE);
+  return cookie && parseDraftPointer(cookie) !== null ? cookie : null;
+}
+
+/** Whether the request carries a draft signal at all: without one the CMS is never asked. */
+export function hasDraftSignal(request: RequestLike): boolean {
+  return (
+    draftParam(request) !== null || readCookie(request.headers.get("cookie"), DRAFT_COOKIE) !== null
+  );
+}
+
+/** The host the visitor asked for: the first `x-forwarded-host`, else `host`. */
+export function requestHost(headers: { get(name: string): string | null }): string | null {
+  const forwarded = headers.get("x-forwarded-host")?.split(",")[0]?.trim();
+  const host = forwarded || headers.get("host")?.trim();
+  return host || null;
+}
+
+/**
+ * The request as the draft check should see it: `pathAndQuery` on the host
+ * the visitor asked for (`x-forwarded-host` behind a proxy, else `host`), so
+ * the host check judges the public hostname rather than the origin's, or
+ * `fallbackHost` when the headers name none. `null` when no host is known.
+ */
+export function requestLike(
+  headers: Headers,
+  pathAndQuery: string,
+  fallbackHost?: string,
+): RequestLike | null {
+  const host = requestHost(headers) ?? (fallbackHost || null);
+  if (!host) return null;
+  try {
+    return { url: new URL(pathAndQuery, `https://${host}`).href, headers };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The draft `request` renders under `policy`, or `null` for the release: the
+ * pointer it carries, on a host the policy (or, when only it can say, the
+ * `CMS` block) allows.
+ */
+export async function allowedDraft(
+  cms: Pick<CMS, "draftPointer" | "settings" | "forRelease">,
+  request: RequestLike,
+  policy: PreviewPolicy,
+): Promise<string | null> {
+  const pointer = readDraftPointer(request);
+  if (pointer === null) return null;
+  let host: string;
+  try {
+    host = new URL(request.url).host;
+  } catch {
+    return null;
+  }
+  const decision = previewHostDecision(host, policy);
+  const allowed =
+    decision === "cms"
+      ? (await declaresPreviewHosts(cms)) && (await cms.draftPointer(request)) !== null
+      : decision;
+  return allowed ? pointer : null;
+}
+
+/**
+ * The draft cookie: the same `Set-Cookie` `cms.draftCookie` writes (a test
+ * holds the two together). Studio frames the site cross-site, hence
+ * `SameSite=None; Partitioned`.
+ */
+export function draftCookie(value: string, extra: string[] = []): string {
+  return [
+    `${DRAFT_COOKIE}=${value}`,
+    "Path=/",
+    ...extra,
+    "HttpOnly",
+    "Secure",
+    "SameSite=None",
+    "Partitioned",
+  ].join("; ");
+}
+
+/** Whether the request ends a preview (`?__draft=off`): the cookie goes on any host. */
+export function endsPreview(request: RequestLike): boolean {
+  return draftParam(request) === DRAFT_OFF;
+}
+
+/** Whether the request's own `?__draft=` carries `pointer` (a draft link, not the cookie). */
+export function fromDraftLink(request: RequestLike, pointer: string): boolean {
+  return draftParam(request) === pointer;
+}

package/src/image-loader/index.ts

@@ -0,0 +1,62 @@
+/**
+ * `@decocms/nextjs/image-loader`: a next/image loader over an `ImageUrl` from
+ * `@decocms/blocks/image`. The site's `loaderFile` is one line:
+ *
+ * ```ts
+ * // src/image-loader.ts (next.config: images: { loader: "custom", loaderFile: "./src/image-loader.ts" })
+ * import { createDecoImageLoader } from "@decocms/nextjs/image-loader";
+ * import { imageUrl } from "./imageUrl";
+ * export default createDecoImageLoader(imageUrl);
+ * ```
+ *
+ * A source the `ImageUrl` resizes gets its provider's URL; any other source
+ * goes to `fallback` (`nextImageOptimizer` sends it through Next's own
+ * `/_next/image`), or comes back unchanged. No React, no module state.
+ */
+import type { ImageUrl, Quality } from "@decocms/blocks/image";
+
+/** What next/image passes a loader (`ImageLoaderProps`), with Deco's named tiers allowed as quality. */
+export interface DecoImageLoaderProps {
+  src: string;
+  width: number;
+  quality?: Quality;
+}
+
+export type DecoImageLoader = (props: DecoImageLoaderProps) => string;
+
+export interface DecoImageLoaderOptions {
+  /** The URL of a source no provider resizes; `null` keeps `src`. Default: `src` unchanged. */
+  fallback?: (props: DecoImageLoaderProps) => string | null;
+}
+
+const TIER_VALUES = { low: 60, medium: 70, high: 80, original: 100 } as const;
+
+/**
+ * Next's built-in optimizer (`/_next/image?url=&w=&q=`), for sources no
+ * provider resizes: a local `/public` file, another host listed in
+ * `images.remotePatterns`.
+ */
+export function nextImageOptimizer({ src, width, quality }: DecoImageLoaderProps): string {
+  const params = new URLSearchParams();
+  params.set("url", src);
+  params.set("w", width.toString());
+  if (quality) {
+    params.set("q", String(typeof quality === "string" ? TIER_VALUES[quality] : quality));
+  }
+  return `/_next/image?${params.toString()}`;
+}
+
+/** The next/image loader for `url`. */
+export function createDecoImageLoader(
+  url: ImageUrl,
+  options: DecoImageLoaderOptions = {},
+): DecoImageLoader {
+  const { fallback } = options;
+  return (props) => {
+    const { src, width, quality } = props;
+    if (url.isOptimizable(src)) {
+      return url(src, quality === undefined ? { width } : { width, quality });
+    }
+    return fallback?.(props) ?? src;
+  };
+}

package/src/index.ts

@@ -1,46 +1,32 @@
-export { ClientOnlySection } from "./ClientOnlySection";
-export { createDecoPage } from "./createDecoPage";
+/**
+ * `@decocms/nextjs`: the components a Next.js App Router site adds, and the
+ * names and lists the proxy, the pages and `withDeco()` share.
+ *
+ * - `DraftPreviewIndicator`: the "Preview mode" badge on a page rendered from
+ *   a draft (`bindDraft` from `@decocms/nextjs/server`), outside Studio's frame.
+ * - `StudioBridge`: one line in the root layout, `<StudioBridge site="my-store" />`,
+ *   lets Studio's site editor drive the page when Studio frames it
+ *   (`@decocms/blocks/preview`'s, answering `STUDIO_ORIGINS`). It renders an
+ *   inline script with no React hooks, so a Server Component renders it as is.
+ *   Outside Studio's frame, "." opens the page in Studio's editor.
+ * - `StudioPage`: rendered inside each CMS page, `<StudioPage pathTemplate={page.path} />`,
+ *   tells the bridge which page "." opens (the root layout doesn't re-render per page).
+ * - `DRAFT_PARAM`, `DRAFT_COOKIE`, `DRAFT_HEADER`, `draftResponseHeaders`,
+ *   `STUDIO_ORIGINS`, `STUDIO_FRAME_ANCESTORS`, `isStudioOrigin`: for a site
+ *   that needs them in its own code (a route that sets its own headers, a CSP
+ *   it writes itself). The package's own copy: it never imports
+ *   `@decocms/tanstack`.
+ *
+ * The proxy (`/proxy`), the pages (`/server`), `next.config` (`/config`) and the
+ * image loader (`/image-loader`) are separate subpaths, so the proxy never
+ * loads React.
+ */
+
+export { DraftBadge, StudioPage, type StudioPageInfo } from "@decocms/blocks/preview";
 export {
-  type CreateDecoPreviewPageOptions,
-  createDecoPreviewPage,
-  type DecoPreviewPageProps,
-} from "./createDecoPreviewPage";
-export { DecoPageRenderer } from "./DecoPageRenderer";
-export { DecoRootLayout, type DecoRootLayoutProps } from "./DecoRootLayout";
-export { DeferredSectionBoundary } from "./DeferredSection";
-export {
-  buildExitUrl,
-  buildShareUrl,
-  DraftPreviewBadge,
-  type DraftPreviewBadgeProps,
-} from "./DraftPreviewBadge";
-export { DraftPreviewIndicator } from "./DraftPreviewIndicator";
-export {
-  DRAFT_COOKIE,
-  DRAFT_COOKIE_OPTIONS,
-  DRAFT_HEADER,
-  DRAFT_PARAM,
-  type DraftMiddlewareDecision,
-  type DraftSearchParams,
-  decideDraft,
-  ensureDraft,
-  getActiveDraftPointer,
-  registerDraftOverride,
-  selectDraftPointer,
-} from "./draft";
-export {
-  applyDraft,
-  DRAFT_ROUTE_PREFIX,
-  draftRequestHeaders,
-  prepareDraft,
-  rewriteToDraftRoute,
-} from "./draftMiddleware";
-export {
-  decofileGET,
-  decofilePOST,
-  invokePOST,
-  metaGET,
-  renderGET,
-  renderPOST,
-} from "./routeHandlers";
-export { SectionRenderer } from "./SectionRenderer";
+  DraftPreviewIndicator,
+  type DraftPreviewIndicatorProps,
+} from "./DraftPreviewIndicator.tsx";
+export { DRAFT_COOKIE, DRAFT_HEADER, DRAFT_PARAM, draftResponseHeaders } from "./draft.ts";
+export { StudioBridge, type StudioBridgeProps } from "./StudioBridge.ts";
+export { isStudioOrigin, STUDIO_FRAME_ANCESTORS, STUDIO_ORIGINS } from "./studio.ts";