@avocadostudio-ai/site-sdk 0.7.0 → 0.8.0

package/dist/create-site-page.js

@@ -1,12 +1,12 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { draftMode } from "next/headers";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { draftMode, cookies } from "next/headers";
 import { connection } from "next/server";
 import { notFound } from "next/navigation";
 import { SharedBlockRenderer, BlocksHydrator } from "@avocadostudio-ai/blocks";
 import { buildSlug } from "./index.js";
-import { resolveEditorContext, fetchEditorPage, fetchEditorSlugs } from "./draft.js";
+import { resolveEditorContext } from "./draft.js";
 import { renderBlocks, EditorOverlay } from "./editor.js";
-import { buildNavItems, buildSiteHeaderBlock } from "./navigation.js";
+import { resolvePageRender } from "./resolve-page-render.js";
 import { buildPageMetadata } from "./page-metadata.js";
 function resolve(config) {
     return {
@@ -30,33 +30,30 @@ function makeGenerateStaticParams(cmsGetSlugs) {
         }));
     };
 }
-async function renderStatic(slug, c) {
-    const [page, navSlugs, siteConfig] = await Promise.all([
-        c.cmsGetPage(slug),
-        c.cmsGetSlugs(),
-        c.cmsGetSiteConfig ? c.cmsGetSiteConfig() : Promise.resolve({}),
-    ]);
+function nextDraftAdapter(draft, getCookie) {
+    return { isDraftMode: draft.isEnabled, getCookie };
+}
+/** The site chrome around whatever the outcome turned out to be. */
+function withChrome(chrome, c, body, after) {
+    return (_jsxs(_Fragment, { children: [c.chrome && _jsx(SharedBlockRenderer, { block: chrome.header }), body, c.chrome && c.footer ? _jsx(SharedBlockRenderer, { block: c.footer }) : null, after] }));
+}
+function renderOutcome(outcome, c) {
     /*
      * `notFound()`, not a rendered 404 body. The previous version returned an
      * <h1>404</h1> with HTTP 200, which is a soft 404: crawlers index it as a
      * real page, and the host app's own `not-found.tsx` never runs. Consumers who
      * want the site chrome around their 404 get it by adding `app/not-found.tsx`,
      * which is where Next puts that and where a layout can wrap it.
-     *
-     * Before building the nav, since none of it survives the throw.
      */
-    if (!page)
+    if (outcome.kind === "not-found")
         notFound();
-    const { navItems, siteName, siteLogo } = buildNavItems({
-        navSlugs,
-        currentSlug: slug,
-        siteConfig,
-        siteId: c.siteId,
-        editorQuery: "",
-        defaultLogo: c.defaultLogo,
-    });
-    const chromeHeader = buildSiteHeaderBlock({ navItems, siteName, siteLogo, activePath: slug });
-    return (_jsxs(_Fragment, { children: [c.chrome && _jsx(SharedBlockRenderer, { block: chromeHeader }), _jsxs("main", { children: [renderBlocks(page.blocks), _jsx(BlocksHydrator, {})] }), c.chrome && c.footer ? _jsx(SharedBlockRenderer, { block: c.footer }) : null] }));
+    if (outcome.kind === "draft-unavailable") {
+        return withChrome(outcome.chrome, c, _jsxs("main", { style: { padding: "4rem", textAlign: "center" }, children: [_jsx("h1", { children: "Draft unavailable" }), _jsxs("p", { children: ["Could not load draft content for ", outcome.slug, "."] })] }));
+    }
+    if (!outcome.editor) {
+        return withChrome(outcome.chrome, c, _jsxs("main", { children: [renderBlocks(outcome.page.blocks), _jsx(BlocksHydrator, {})] }));
+    }
+    return withChrome(outcome.chrome, c, _jsx("main", { className: "editor-mode", children: renderBlocks(outcome.page.blocks, { editable: true }) }), _jsx(EditorOverlay, { slug: outcome.slug, editorOrigin: outcome.editor.editorOrigin }));
 }
 /**
  * Metadata for a page, mirroring the render's own choice of source.
@@ -90,57 +87,33 @@ function makeGenerateMetadata(c, mode) {
         return decorate(buildPageMetadata(page, { siteName: c.siteName }), page);
     };
 }
-async function renderPreview(slug, search, c) {
-    /*
-     * `connection()`, not `unstable_noStore()`. Same effect — this render depends
-     * on a live request and must never be prerendered or cached — but it is the
-     * stable primitive Next ships for saying so, and the SDK had exactly one
-     * `unstable_*` import left in it.
-     */
-    await connection();
-    const editorCtx = await resolveEditorContext(search, {
-        defaultSession: c.defaultSession,
-        defaultSiteId: c.siteId,
-    });
-    const session = editorCtx?.session ?? c.defaultSession;
-    const currentSiteId = editorCtx?.siteId ?? c.siteId;
-    const [page, navSlugs, siteConfig] = await Promise.all([
-        fetchEditorPage(slug, session, currentSiteId).then((p) => p ?? c.cmsGetPage(slug)),
-        fetchEditorSlugs(session, currentSiteId).then((s) => (s.length > 0 ? s : c.cmsGetSlugs())),
-        c.cmsGetSiteConfig ? c.cmsGetSiteConfig() : Promise.resolve({}),
-    ]);
-    const editorOrigin = editorCtx?.editorOrigin ?? "";
-    const editorQuery = (() => {
-        const p = new URLSearchParams({ session, siteId: currentSiteId });
-        if (editorOrigin)
-            p.set("editorOrigin", editorOrigin);
-        return `?${p.toString()}`;
-    })();
-    const { navItems, siteName, siteLogo } = buildNavItems({
-        navSlugs,
-        currentSlug: slug,
-        siteConfig,
-        siteId: c.siteId,
-        editorQuery,
-        defaultLogo: c.defaultLogo,
-    });
-    const chromeHeader = buildSiteHeaderBlock({ navItems, siteName, siteLogo, activePath: slug });
-    if (!page) {
-        return (_jsxs(_Fragment, { children: [c.chrome && _jsx(SharedBlockRenderer, { block: chromeHeader }), _jsxs("main", { style: { padding: "4rem", textAlign: "center" }, children: [_jsx("h1", { children: "Draft unavailable" }), _jsxs("p", { children: ["Could not load draft content for ", slug, "."] })] }), c.chrome && c.footer ? _jsx(SharedBlockRenderer, { block: c.footer }) : null] }));
+async function render(slug, search, c, mode) {
+    if (mode !== "static") {
+        /*
+         * `connection()`, not `unstable_noStore()`. Same effect — this render
+         * depends on a live request and must never be prerendered or cached — but
+         * it is the stable primitive Next ships for saying so, and the SDK had
+         * exactly one `unstable_*` import left in it.
+         */
+        await connection();
     }
-    return (_jsxs(_Fragment, { children: [c.chrome && _jsx(SharedBlockRenderer, { block: chromeHeader }), _jsx("main", { className: "editor-mode", children: renderBlocks(page.blocks, { editable: true }) }), c.chrome && c.footer ? _jsx(SharedBlockRenderer, { block: c.footer }) : null, _jsx(EditorOverlay, { slug: slug, editorOrigin: editorOrigin })] }));
-}
-async function renderAuto(slug, search, c) {
-    const editorCtx = await resolveEditorContext(search, {
-        defaultSession: c.defaultSession,
-        defaultSiteId: c.siteId,
+    const jar = mode === "static" ? null : await cookies();
+    const draft = mode === "static" ? null : await draftMode();
+    const outcome = await resolvePageRender({
+        slug,
+        mode,
+        search,
+        config: {
+            siteId: c.siteId,
+            session: c.defaultSession,
+            getPage: c.cmsGetPage,
+            getSlugs: c.cmsGetSlugs,
+            getSiteConfig: c.cmsGetSiteConfig,
+            defaultLogo: c.defaultLogo,
+        },
+        adapter: draft && jar ? nextDraftAdapter(draft, (name) => jar.get(name)?.value) : undefined,
     });
-    const draft = await draftMode();
-    const editorMode = draft.isEnabled || !!editorCtx;
-    if (editorMode) {
-        return renderPreview(slug, search, c);
-    }
-    return renderStatic(slug, c);
+    return renderOutcome(outcome, c);
 }
 /**
  * Create a Next.js page component with full editor integration.
@@ -156,23 +129,13 @@ export function createSitePage(config) {
     if (mode === "static") {
         async function Page({ params }) {
             const { slug: slugParts } = await params;
-            const slug = buildSlug(slugParts);
-            return renderStatic(slug, c);
-        }
-        return { Page, generateStaticParams, generateMetadata };
-    }
-    if (mode === "preview") {
-        async function Page({ params, searchParams }) {
-            const [{ slug: slugParts }, search] = await Promise.all([params, searchParams]);
-            const slug = buildSlug(slugParts);
-            return renderPreview(slug, search, c);
+            return render(buildSlug(slugParts), undefined, c, "static");
         }
         return { Page, generateStaticParams, generateMetadata };
     }
     async function Page({ params, searchParams }) {
         const [{ slug: slugParts }, search] = await Promise.all([params, searchParams]);
-        const slug = buildSlug(slugParts);
-        return renderAuto(slug, search, c);
+        return render(buildSlug(slugParts), search, c, mode);
     }
     return { Page, generateStaticParams, generateMetadata };
 }

package/dist/draft-common.d.ts

@@ -1,6 +1,7 @@
 export declare const DRAFT_SESSION_COOKIE = "editor_draft_session";
 export declare const DRAFT_SITE_COOKIE = "editor_draft_site_id";
 export declare const EDITOR_ORIGIN_COOKIE = "editor_origin";
+export declare function single(value: string | string[] | undefined): string | undefined;
 export declare function normalizeOrigin(value: string | null | undefined): string | undefined;
 /**
  * Editor origins this site will talk to.

package/dist/draft-common.js

@@ -1,6 +1,19 @@
 export const DRAFT_SESSION_COOKIE = "editor_draft_session";
 export const DRAFT_SITE_COOKIE = "editor_draft_site_id";
 export const EDITOR_ORIGIN_COOKIE = "editor_origin";
+/*
+ * A query value that arrived more than once is not a value. Next hands
+ * repeated params over as an array, and every caller here wants the single
+ * string or nothing — `?secret=a&secret=b` is not two secrets to try, it is a
+ * malformed request.
+ *
+ * It lives in this leaf module rather than beside `resolveEditorContext`
+ * because the framework-agnostic core needs it too, and importing it from the
+ * Next module pulled `next/headers` into every runtime that touched the core.
+ */
+export function single(value) {
+    return typeof value === "string" ? value : undefined;
+}
 export function normalizeOrigin(value) {
     const raw = value?.trim();
     if (!raw)

package/dist/draft-context-core.d.ts

@@ -1,5 +1,5 @@
 import type { DraftContext, SearchParamsRecord } from "./types.ts";
-export { single } from "./draft-context.ts";
+export { single } from "./draft-common.ts";
 export type DraftModeAdapter = {
     isDraftMode: boolean;
     getCookie: (name: string) => string | undefined;

package/dist/draft-context-core.js

@@ -1,7 +1,6 @@
 import { validateDraftSecret } from "@avocadostudio-ai/shared";
-import { DRAFT_SESSION_COOKIE, DRAFT_SITE_COOKIE, EDITOR_ORIGIN_COOKIE, normalizeOrigin, resolveTrustedEditorOrigin } from "./draft-common.js";
-import { single } from "./draft-context.js";
-export { single } from "./draft-context.js";
+import { DRAFT_SESSION_COOKIE, DRAFT_SITE_COOKIE, EDITOR_ORIGIN_COOKIE, normalizeOrigin, resolveTrustedEditorOrigin, single } from "./draft-common.js";
+export { single } from "./draft-common.js";
 export async function resolveDraftContextCore(searchParams, adapter, options) {
     const isDev = process.env.NODE_ENV !== "production";
     /*

package/dist/draft-context.d.ts

@@ -1,6 +1,6 @@
 import type { SearchParamsRecord } from "./types.ts";
 import type { DraftContext } from "./types.ts";
-export declare function single(value: string | string[] | undefined): string | undefined;
+export { single } from "./draft-common.ts";
 export declare function resolveEditorContext(searchParams: SearchParamsRecord, options?: {
     defaultSession?: string;
     defaultSiteId?: string;

package/dist/draft-context.js

@@ -1,8 +1,6 @@
 import { draftMode, cookies } from "next/headers";
 import { resolveDraftContextCore } from "./draft-context-core.js";
-export function single(value) {
-    return typeof value === "string" ? value : undefined;
-}
+export { single } from "./draft-common.js";
 export async function resolveEditorContext(searchParams, options) {
     const jar = await cookies();
     const draft = await draftMode();

package/dist/draft-routes.d.ts

@@ -1,2 +1,9 @@
+import type { DraftRouteAdapter } from "./draft-routes-core.ts";
+/**
+ * Next's answers to the three things the draft routes need from a framework.
+ * Exported because the editor API handler builds its own core and has to hand
+ * the same adapter down.
+ */
+export declare function createNextDraftAdapter(): DraftRouteAdapter;
 export declare function createDraftEnableHandler(): (request: Request) => Promise<Response>;
 export declare function createDraftDisableHandler(): (request: Request) => Promise<Response>;

package/dist/draft-routes.js

@@ -1,7 +1,12 @@
 import { draftMode } from "next/headers";
 import { NextResponse } from "next/server";
 import { createDraftEnableHandlerCore, createDraftDisableHandlerCore } from "./draft-routes-core.js";
-function createNextAdapter() {
+/**
+ * Next's answers to the three things the draft routes need from a framework.
+ * Exported because the editor API handler builds its own core and has to hand
+ * the same adapter down.
+ */
+export function createNextDraftAdapter() {
     return {
         enableDraftMode: async () => { (await draftMode()).enable(); },
         disableDraftMode: async () => { (await draftMode()).disable(); },
@@ -20,8 +25,8 @@ function createNextAdapter() {
     };
 }
 export function createDraftEnableHandler() {
-    return createDraftEnableHandlerCore(createNextAdapter());
+    return createDraftEnableHandlerCore(createNextDraftAdapter());
 }
 export function createDraftDisableHandler() {
-    return createDraftDisableHandlerCore(createNextAdapter());
+    return createDraftDisableHandlerCore(createNextDraftAdapter());
 }

package/dist/editor-api-handler-core.d.ts

@@ -0,0 +1,85 @@
+import type { DraftRouteAdapter } from "./draft-routes-core.ts";
+import type { OnPublishFn } from "./editor-routes.ts";
+import { type BlockManifest } from "./editor-manifest.ts";
+import type { PageDoc } from "./types.ts";
+import { type SiteConfig } from "@avocadostudio-ai/shared";
+export interface EditorApiHandlerConfig {
+    getPages: () => PageDoc[] | Promise<PageDoc[]>;
+    /**
+     * Optional site-config getter. When provided, `/api/editor/pages` returns
+     * `{ pages, siteConfig }` so the orchestrator's publish-diff can show
+     * header-chrome changes (name/logo/navLabels/navGroups) alongside page diffs.
+     */
+    getSiteConfig?: () => SiteConfig | undefined | Promise<SiteConfig | undefined>;
+    getManifest?: () => BlockManifest;
+    /**
+     * Register the site's block schemas before each manifest build. Use this
+     * instead of relying on side-effect import order — Next.js's dev bundler
+     * does not reliably honor source-order side effects across RSC / SSR / API
+     * route layers, so a canonical re-registration from `@avocadostudio-ai/shared`
+     * can silently clobber the site's overrides. Called inside `getManifest`,
+     * so registration is guaranteed to be last at request time. `registerBlock`
+     * is idempotent, so repeated calls are cheap.
+     *
+     * Composes with `getManifest`: when both are set, `registerBlocks` runs
+     * first, then `getManifest` is invoked.
+     */
+    registerBlocks?: () => void;
+    /**
+     * The block types this site renders, narrowing `/api/editor/blocks` to them.
+     *
+     * `createOrchestrator` takes the same option and declares the same catalogue,
+     * and for a while that was assumed to be enough for both routes: the
+     * declaration lives on `globalThis`, so one handler's call is visible to the
+     * other. What that reasoning missed is *when* it runs. A Next route module is
+     * evaluated on the first request to that route, so a site whose editor asks
+     * for `/api/editor/blocks` before anything has touched `/api/avocado/*` gets
+     * the manifest built before `createOrchestrator` has ever been called — and
+     * the answer is the site's own blocks plus all of Avocado's built-ins, which
+     * the site has no renderer for.
+     *
+     * Declaring it here closes that window, and passing it to both handlers is
+     * harmless: the declaration records names and the manifest is rebuilt per
+     * request.
+     */
+    blockTypes?: readonly string[];
+    onPublish?: OnPublishFn;
+    /** Secret token required for publish requests. Checked against x-publish-token header. */
+    publishSecret?: string;
+}
+export interface EditorApiCoreConfig extends EditorApiHandlerConfig {
+    /**
+     * How this runtime enables draft mode and builds a redirect. Next has
+     * `draftMode()` and `NextResponse.redirect`; every other host has to say so
+     * itself, which is the whole of what the draft routes need from a framework.
+     */
+    draftAdapter: DraftRouteAdapter;
+    /**
+     * Where the catch-all is mounted, used to derive the route from the URL when
+     * the host does not hand over path segments of its own. Next's catch-all
+     * supplies them; Astro's `[...path]` also does, but a plain `fetch` handler
+     * mounted by hand has only the URL.
+     */
+    basePath?: string;
+}
+/**
+ * The editor API, with nothing framework-shaped left in it.
+ *
+ * Each handler takes the request and, optionally, the path segments beneath the
+ * mount point. A host that has them (any catch-all route) passes them; one that
+ * does not gets them derived from the URL against `basePath`. Everything below
+ * this line — matching, CORS, the manifest, publish — was already portable; it
+ * was reachable only through a signature naming a Next route context.
+ *
+ * Routes:
+ * - `/api/editor/draft` → enable draft mode
+ * - `/api/editor/draft/disable` → disable draft mode
+ * - `/api/editor/blocks` → block manifest
+ * - `/api/editor/pages` → published pages
+ * - `/api/editor/publish` → publish content (POST)
+ */
+export declare function createEditorApiHandlerCore(config: EditorApiCoreConfig): {
+    GET: (request: Request, path?: string[]) => Promise<Response>;
+    POST: (request: Request, path?: string[]) => Promise<Response>;
+    OPTIONS: (request: Request) => Response;
+};

package/dist/editor-api-handler-core.js

@@ -0,0 +1,101 @@
+import { createDraftEnableHandlerCore, createDraftDisableHandlerCore } from "./draft-routes-core.js";
+import { createBlocksHandler, createPagesHandler, createPublishHandler } from "./editor-routes.js";
+import { applyEditorCors } from "./editor-cors.js";
+import { checkIntegrationOnce } from "./integration-check.js";
+import { buildBlockManifest } from "./editor-manifest.js";
+import { declareBlockCatalogue } from "@avocadostudio-ai/shared";
+/**
+ * The editor API, with nothing framework-shaped left in it.
+ *
+ * Each handler takes the request and, optionally, the path segments beneath the
+ * mount point. A host that has them (any catch-all route) passes them; one that
+ * does not gets them derived from the URL against `basePath`. Everything below
+ * this line — matching, CORS, the manifest, publish — was already portable; it
+ * was reachable only through a signature naming a Next route context.
+ *
+ * Routes:
+ * - `/api/editor/draft` → enable draft mode
+ * - `/api/editor/draft/disable` → disable draft mode
+ * - `/api/editor/blocks` → block manifest
+ * - `/api/editor/pages` → published pages
+ * - `/api/editor/publish` → publish content (POST)
+ */
+export function createEditorApiHandlerCore(config) {
+    const draftEnable = createDraftEnableHandlerCore(config.draftAdapter);
+    const draftDisable = createDraftDisableHandlerCore(config.draftAdapter);
+    const basePath = (config.basePath ?? "/api/editor").replace(/\/+$/, "");
+    const needsPreamble = Boolean(config.registerBlocks || config.blockTypes);
+    const manifestBuilder = needsPreamble
+        ? () => {
+            config.registerBlocks?.();
+            if (config.blockTypes)
+                declareBlockCatalogue(config.blockTypes);
+            return (config.getManifest ?? buildBlockManifest)();
+        }
+        : config.getManifest;
+    const blocksHandler = createBlocksHandler(manifestBuilder ? { getManifest: manifestBuilder } : undefined);
+    const pagesHandler = createPagesHandler(config.getPages, config.getSiteConfig);
+    const publishHandler = config.onPublish
+        ? createPublishHandler(config.onPublish, { publishSecret: config.publishSecret })
+        : null;
+    /*
+     * `/api/editor/draft/disable` is two segments, so the fallback cannot simply
+     * take the last one. Trailing slashes and an exactly-`basePath` request both
+     * have to come out as no segments rather than as one empty one.
+     */
+    function pathFromUrl(request) {
+        const { pathname } = new URL(request.url);
+        const rest = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+        return rest.split("/").filter(Boolean);
+    }
+    function matchRoute(path) {
+        const key = path.join("/");
+        if (key === "draft")
+            return "draft-enable";
+        if (key === "draft/disable")
+            return "draft-disable";
+        if (key === "blocks")
+            return "blocks";
+        if (key === "pages")
+            return "pages";
+        if (key === "publish")
+            return "publish";
+        return "not-found";
+    }
+    function notFound(request) {
+        return applyEditorCors(new Response(JSON.stringify({ error: "Not found" }), {
+            status: 404,
+            headers: { "Content-Type": "application/json" },
+        }), request.headers.get("origin"));
+    }
+    return {
+        async GET(request, path) {
+            checkIntegrationOnce();
+            const route = matchRoute(path ?? pathFromUrl(request));
+            switch (route) {
+                case "draft-enable":
+                    return draftEnable(request);
+                case "draft-disable":
+                    return draftDisable(request);
+                case "blocks":
+                    return blocksHandler.GET(request);
+                case "pages":
+                    return pagesHandler.GET(request);
+                default:
+                    return notFound(request);
+            }
+        },
+        async POST(request, path) {
+            const route = matchRoute(path ?? pathFromUrl(request));
+            if (route === "publish" && publishHandler) {
+                return publishHandler.POST(request);
+            }
+            return notFound(request);
+        },
+        OPTIONS(request) {
+            // A preflight is answered the same way whatever it is preflighting, so
+            // the route is never resolved here.
+            return blocksHandler.OPTIONS(request);
+        },
+    };
+}

package/dist/editor-api-handler.d.ts

@@ -1,51 +1,5 @@
-import type { OnPublishFn } from "./editor-routes.ts";
-import { type BlockManifest } from "./editor-manifest.ts";
-import type { PageDoc } from "./types.ts";
-import { type SiteConfig } from "@avocadostudio-ai/shared";
-export interface EditorApiHandlerConfig {
-    getPages: () => PageDoc[] | Promise<PageDoc[]>;
-    /**
-     * Optional site-config getter. When provided, `/api/editor/pages` returns
-     * `{ pages, siteConfig }` so the orchestrator's publish-diff can show
-     * header-chrome changes (name/logo/navLabels/navGroups) alongside page diffs.
-     */
-    getSiteConfig?: () => SiteConfig | undefined | Promise<SiteConfig | undefined>;
-    getManifest?: () => BlockManifest;
-    /**
-     * Register the site's block schemas before each manifest build. Use this
-     * instead of relying on side-effect import order — Next.js's dev bundler
-     * does not reliably honor source-order side effects across RSC / SSR / API
-     * route layers, so a canonical re-registration from `@avocadostudio-ai/shared`
-     * can silently clobber the site's overrides. Called inside `getManifest`,
-     * so registration is guaranteed to be last at request time. `registerBlock`
-     * is idempotent, so repeated calls are cheap.
-     *
-     * Composes with `getManifest`: when both are set, `registerBlocks` runs
-     * first, then `getManifest` is invoked.
-     */
-    registerBlocks?: () => void;
-    /**
-     * The block types this site renders, narrowing `/api/editor/blocks` to them.
-     *
-     * `createOrchestrator` takes the same option and declares the same catalogue,
-     * and for a while that was assumed to be enough for both routes: the
-     * declaration lives on `globalThis`, so one handler's call is visible to the
-     * other. What that reasoning missed is *when* it runs. A Next route module is
-     * evaluated on the first request to that route, so a site whose editor asks
-     * for `/api/editor/blocks` before anything has touched `/api/avocado/*` gets
-     * the manifest built before `createOrchestrator` has ever been called — and
-     * the answer is the site's own blocks plus all of Avocado's built-ins, which
-     * the site has no renderer for.
-     *
-     * Declaring it here closes that window, and passing it to both handlers is
-     * harmless: the declaration records names and the manifest is rebuilt per
-     * request.
-     */
-    blockTypes?: readonly string[];
-    onPublish?: OnPublishFn;
-    /** Secret token required for publish requests. Checked against x-publish-token header. */
-    publishSecret?: string;
-}
+import type { EditorApiHandlerConfig } from "./editor-api-handler-core.ts";
+export type { EditorApiHandlerConfig } from "./editor-api-handler-core.ts";
 type NextRouteContext = {
     params: Promise<{
         path: string[];
@@ -68,10 +22,14 @@ type NextRouteContext = {
  * - `/api/editor/blocks` → block manifest
  * - `/api/editor/pages` → published pages
  * - `/api/editor/publish` → publish content (POST)
+ *
+ * The routing, CORS, manifest and publish behaviour all live in
+ * `createEditorApiHandlerCore`, which knows nothing about Next. This wrapper
+ * adds the two things that are actually Next's: `draftMode()` and the route
+ * context holding the matched path segments.
  */
 export declare function createEditorApiHandler(config: EditorApiHandlerConfig): {
     GET: (request: Request, context: NextRouteContext) => Promise<Response>;
     POST: (request: Request, context: NextRouteContext) => Promise<Response>;
     OPTIONS: (request: Request, context: NextRouteContext) => Response;
 };
-export {};

package/dist/editor-api-handler.js

@@ -1,9 +1,5 @@
-import { createDraftEnableHandler, createDraftDisableHandler } from "./draft-routes.js";
-import { createBlocksHandler, createPagesHandler, createPublishHandler } from "./editor-routes.js";
-import { applyEditorCors } from "./editor-cors.js";
-import { checkIntegrationOnce } from "./integration-check.js";
-import { buildBlockManifest } from "./editor-manifest.js";
-import { declareBlockCatalogue } from "@avocadostudio-ai/shared";
+import { createNextDraftAdapter } from "./draft-routes.js";
+import { createEditorApiHandlerCore } from "./editor-api-handler-core.js";
 /**
  * Creates a single catch-all route handler that serves all editor API endpoints.
  *
@@ -21,73 +17,23 @@ import { declareBlockCatalogue } from "@avocadostudio-ai/shared";
  * - `/api/editor/blocks` → block manifest
  * - `/api/editor/pages` → published pages
  * - `/api/editor/publish` → publish content (POST)
+ *
+ * The routing, CORS, manifest and publish behaviour all live in
+ * `createEditorApiHandlerCore`, which knows nothing about Next. This wrapper
+ * adds the two things that are actually Next's: `draftMode()` and the route
+ * context holding the matched path segments.
  */
 export function createEditorApiHandler(config) {
-    const draftEnable = createDraftEnableHandler();
-    const draftDisable = createDraftDisableHandler();
-    const needsPreamble = Boolean(config.registerBlocks || config.blockTypes);
-    const manifestBuilder = needsPreamble
-        ? () => {
-            config.registerBlocks?.();
-            if (config.blockTypes)
-                declareBlockCatalogue(config.blockTypes);
-            return (config.getManifest ?? buildBlockManifest)();
-        }
-        : config.getManifest;
-    const blocksHandler = createBlocksHandler(manifestBuilder ? { getManifest: manifestBuilder } : undefined);
-    const pagesHandler = createPagesHandler(config.getPages, config.getSiteConfig);
-    const publishHandler = config.onPublish
-        ? createPublishHandler(config.onPublish, { publishSecret: config.publishSecret })
-        : null;
-    function matchRoute(path) {
-        const key = path.join("/");
-        if (key === "draft")
-            return "draft-enable";
-        if (key === "draft/disable")
-            return "draft-disable";
-        if (key === "blocks")
-            return "blocks";
-        if (key === "pages")
-            return "pages";
-        if (key === "publish")
-            return "publish";
-        return "not-found";
-    }
-    function notFound(request) {
-        return applyEditorCors(new Response(JSON.stringify({ error: "Not found" }), {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-        }), request.headers.get("origin"));
-    }
+    const core = createEditorApiHandlerCore({ ...config, draftAdapter: createNextDraftAdapter() });
     return {
         async GET(request, context) {
-            checkIntegrationOnce();
-            const { path } = await context.params;
-            const route = matchRoute(path);
-            switch (route) {
-                case "draft-enable":
-                    return draftEnable(request);
-                case "draft-disable":
-                    return draftDisable(request);
-                case "blocks":
-                    return blocksHandler.GET(request);
-                case "pages":
-                    return pagesHandler.GET(request);
-                default:
-                    return notFound(request);
-            }
+            return core.GET(request, (await context.params).path);
         },
         async POST(request, context) {
-            const { path } = await context.params;
-            const route = matchRoute(path);
-            if (route === "publish" && publishHandler) {
-                return publishHandler.POST(request);
-            }
-            return notFound(request);
+            return core.POST(request, (await context.params).path);
         },
-        OPTIONS(request, context) {
-            // OPTIONS doesn't need async params resolution for CORS preflight
-            return blocksHandler.OPTIONS(request);
+        OPTIONS(request) {
+            return core.OPTIONS(request);
         },
     };
 }