@avocadostudio-ai/site-sdk 0.1.0

package/dist/editor.js

@@ -0,0 +1,22 @@
+// Editor UI components
+export { EditorOverlay } from "./editor-overlay.js";
+// Editor query param utilities
+export { buildEditorQuerySuffix } from "./editor-query.js";
+// Block wrapper props for preview mode
+export function getPreviewWrapperProps(editorMode, blockId, blockType) {
+    if (!editorMode)
+        return {};
+    return {
+        "data-block-id": blockId,
+        "data-block-type": blockType,
+        className: "editor-selectable",
+        style: { viewTransitionName: `block-${blockId}` }
+    };
+}
+// Block rendering helper
+export { renderBlocks } from "./render-blocks.js";
+// Live-preview store renderer (streams field drafts through React)
+export { RenderedBlocks, PreviewBlock } from "./live-preview-blocks.js";
+export { LivePreviewProvider } from "@avocadostudio-ai/preview-adapter";
+// Editor CORS utilities
+export { getEditorCorsOrigins, applyEditorCors, createEditorCorsOptionsHandler } from "./editor-cors.js";

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { PageDoc, PageMeta, BlockInstance, DraftContext, SearchParamsRecord } from "./types.ts";
+export type { SiteConfig } from "@avocadostudio-ai/shared";
+export { pageDocSchema } from "./types.ts";
+export { buildSlug } from "./editor-query.ts";
+export { renderBlocks } from "./render-blocks.tsx";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { pageDocSchema } from "./types.js";
+// URL utilities
+export { buildSlug } from "./editor-query.js";
+// Block rendering
+export { renderBlocks } from "./render-blocks.js";

package/dist/integration-check.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Run once on first editor API request to validate essential integration config.
+ * Logs warnings to console — does not throw or block requests.
+ */
+export declare function checkIntegrationOnce(): void;

package/dist/integration-check.js

@@ -0,0 +1,29 @@
+import { getConfiguredDraftSecret } from "@avocadostudio-ai/shared";
+let checked = false;
+/**
+ * Run once on first editor API request to validate essential integration config.
+ * Logs warnings to console — does not throw or block requests.
+ */
+export function checkIntegrationOnce() {
+    if (checked)
+        return;
+    checked = true;
+    const warnings = [];
+    // 1. Draft mode secret
+    const draftSecret = getConfiguredDraftSecret(process.env);
+    if (!draftSecret) {
+        warnings.push("DRAFT_MODE_SECRET is not set — editor draft mode will not work. " +
+            "Set DRAFT_MODE_SECRET (or VITE_SITE_DRAFT_SECRET) in your .env file.");
+    }
+    // 2. Orchestrator URL
+    const orchestratorUrl = process.env.ORCHESTRATOR_URL?.trim();
+    if (!orchestratorUrl) {
+        warnings.push("ORCHESTRATOR_URL is not set — defaults to http://localhost:4200. " +
+            "Set this in production to point to your deployed orchestrator.");
+    }
+    if (warnings.length > 0) {
+        console.warn("\n[ai-site-editor] Integration warnings:\n" +
+            warnings.map((w) => `  ⚠ ${w}`).join("\n") +
+            "\n");
+    }
+}

package/dist/live-preview-blocks.d.ts

@@ -0,0 +1,5 @@
+import type { BlockInstance } from "./types.ts";
+export declare const PreviewBlock: import("react").NamedExoticComponent<{
+    block: BlockInstance;
+}>;
+export declare function RenderedBlocks(): import("react/jsx-runtime").JSX.Element;

package/dist/live-preview-blocks.js

@@ -0,0 +1,30 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Client renderer for the live-preview draft store.
+ *
+ * `RenderedBlocks` subscribes to the store's effective blocks (committed ⊕
+ * streamed drafts) and renders them through the REAL block renderers. Each block
+ * is memoized on its own object identity, so when one block's draft changes only
+ * that block re-renders — unchanged blocks keep their DOM nodes, which is what
+ * keeps the editor overlay's selection/handles/shimmer attached during a stream.
+ *
+ * Only used on built-in-block sites (EditorPageWrapper gates on the absence of
+ * custom renderers), so SharedBlockRenderer's standard-renderer path is enough —
+ * no client-side custom-renderer (globalThis) resolution needed.
+ */
+import { memo } from "react";
+import { SharedBlockRenderer, BlockErrorBoundary } from "@avocadostudio-ai/blocks";
+import { getChromeTypes } from "@avocadostudio-ai/shared";
+import { useLivePreviewBlocks } from "@avocadostudio-ai/preview-adapter";
+import { getPreviewWrapperProps } from "./editor.js";
+const CHROME_BLOCK_TYPES = new Set(getChromeTypes());
+export const PreviewBlock = memo(function PreviewBlock({ block }) {
+    return (_jsx("div", { id: block.id, ...getPreviewWrapperProps(true, block.id, block.type), children: _jsx(BlockErrorBoundary, { blockId: block.id, blockType: block.type, resetKey: block, children: _jsx(SharedBlockRenderer, { block: block }) }) }));
+});
+export function RenderedBlocks() {
+    const blocks = useLivePreviewBlocks() ?? [];
+    return (_jsx(_Fragment, { children: blocks
+            .filter((b) => !CHROME_BLOCK_TYPES.has(b.type))
+            .map((block) => (_jsx(PreviewBlock, { block: block }, block.id))) }));
+}

package/dist/manifest-utils.d.ts

@@ -0,0 +1,17 @@
+import { type BlockManifest } from "@avocadostudio-ai/shared";
+export type ManifestFieldInfo = {
+    /** Top-level image fields per block type (e.g. Hero → {"imageUrl"}) */
+    imageFields: Map<string, Set<string>>;
+    /** Image fields within list items per block type + list key (e.g. CardGrid → cards → {"imageUrl"}) */
+    listImageFields: Map<string, Map<string, Set<string>>>;
+    /** All list field names per block type (e.g. CardGrid → {"cards"}, FeatureGrid → {"features"}) */
+    listFieldNames: Map<string, Set<string>>;
+};
+/**
+ * Derive field metadata per block type from the manifest's propsSchema.
+ * Cached by manifest reference — safe to call from multiple modules.
+ *
+ * Works for both default blocks (via buildBlockManifest()) and custom blocks
+ * (via developer-provided getManifest()). No shared block registry needed.
+ */
+export declare function getManifestImageFields(manifest: BlockManifest): ManifestFieldInfo;

package/dist/manifest-utils.js

@@ -0,0 +1,44 @@
+import { deriveFieldMetaFromSchema } from "@avocadostudio-ai/shared";
+const _cache = new WeakMap();
+/**
+ * Derive field metadata per block type from the manifest's propsSchema.
+ * Cached by manifest reference — safe to call from multiple modules.
+ *
+ * Works for both default blocks (via buildBlockManifest()) and custom blocks
+ * (via developer-provided getManifest()). No shared block registry needed.
+ */
+export function getManifestImageFields(manifest) {
+    const cached = _cache.get(manifest);
+    if (cached)
+        return cached;
+    const imageFields = new Map();
+    const listImageFields = new Map();
+    const listFieldNames = new Map();
+    for (const block of manifest.blocks) {
+        const { fields, listFields } = deriveFieldMetaFromSchema(block.propsSchema);
+        const imgs = new Set();
+        for (const [key, meta] of Object.entries(fields)) {
+            if (meta.kind === "image")
+                imgs.add(key);
+        }
+        imageFields.set(block.type, imgs);
+        const listNames = new Set(Object.keys(listFields));
+        if (listNames.size > 0)
+            listFieldNames.set(block.type, listNames);
+        const listImgs = new Map();
+        for (const [listKey, listMeta] of Object.entries(listFields)) {
+            const itemImgs = new Set();
+            for (const [itemKey, itemMeta] of Object.entries(listMeta.itemFields)) {
+                if (itemMeta.kind === "image")
+                    itemImgs.add(itemKey);
+            }
+            if (itemImgs.size > 0)
+                listImgs.set(listKey, itemImgs);
+        }
+        if (listImgs.size > 0)
+            listImageFields.set(block.type, listImgs);
+    }
+    const result = { imageFields, listImageFields, listFieldNames };
+    _cache.set(manifest, result);
+    return result;
+}

package/dist/middleware.d.ts

@@ -0,0 +1,37 @@
+import { NextResponse, type NextRequest } from "next/server";
+/**
+ * Options for the editor middleware factory.
+ */
+export type EditorMiddlewareOptions = {
+    /**
+     * The internal route prefix that the dynamic editor/draft page lives under.
+     * @default "/preview-draft"
+     */
+    previewRoute?: string;
+    /**
+     * Query parameter that signals an editor iframe request.
+     * @default "__editor"
+     */
+    editorParam?: string;
+    /**
+     * Name of the Next.js draft-mode bypass cookie.
+     * @default "__prerender_bypass"
+     */
+    draftCookie?: string;
+};
+/**
+ * Create a Next.js middleware function that rewrites editor/draft requests
+ * to a dynamic preview route, keeping the main page route fully static.
+ *
+ * Usage in `middleware.ts`:
+ * ```ts
+ * import { createEditorMiddleware } from "@avocadostudio-ai/site-sdk/middleware"
+ * export const { middleware, config } = createEditorMiddleware()
+ * ```
+ */
+export declare function createEditorMiddleware(options?: EditorMiddlewareOptions): {
+    middleware: (request: NextRequest) => NextResponse<unknown>;
+    config: {
+        matcher: string[];
+    };
+};

package/dist/middleware.js

@@ -0,0 +1,34 @@
+import { NextResponse } from "next/server";
+/**
+ * Create a Next.js middleware function that rewrites editor/draft requests
+ * to a dynamic preview route, keeping the main page route fully static.
+ *
+ * Usage in `middleware.ts`:
+ * ```ts
+ * import { createEditorMiddleware } from "@avocadostudio-ai/site-sdk/middleware"
+ * export const { middleware, config } = createEditorMiddleware()
+ * ```
+ */
+export function createEditorMiddleware(options) {
+    const previewRoute = options?.previewRoute ?? "/preview-draft";
+    const editorParam = options?.editorParam ?? "__editor";
+    const draftCookie = options?.draftCookie ?? "__prerender_bypass";
+    function middleware(request) {
+        const isEditor = request.nextUrl.searchParams.get(editorParam) === "1";
+        const hasDraftCookie = request.cookies.has(draftCookie);
+        if (isEditor || hasDraftCookie) {
+            const url = request.nextUrl.clone();
+            url.pathname = `${previewRoute}${url.pathname}`;
+            return NextResponse.rewrite(url);
+        }
+        return NextResponse.next();
+    }
+    // Escape special regex chars in the route prefix (strip leading slash for the pattern)
+    const escapedRoute = previewRoute.slice(1).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const config = {
+        matcher: [
+            `/((?!_next|${escapedRoute}|api|favicon\\.ico|icon\\.svg|logos/|generated-images/|.*\\.).*)`
+        ],
+    };
+    return { middleware, config };
+}

package/dist/navigation.d.ts

@@ -0,0 +1,48 @@
+export declare function siteNameFallback(siteId: string): string;
+export declare function slugToLabel(route: string): string;
+export type NavItem = {
+    href?: string;
+    label: string;
+    isActive: boolean;
+    children?: NavItem[];
+};
+type NavLinkProp = {
+    label: string;
+    href?: string;
+    children?: NavLinkProp[];
+};
+export type SiteHeaderBlock = {
+    id: string;
+    type: "SiteHeader";
+    props: {
+        siteName: string;
+        logoUrl: string;
+        links: NavLinkProp[];
+        activePath?: string;
+    };
+};
+export declare function buildSiteHeaderBlock(opts: {
+    navItems: NavItem[];
+    siteName: string;
+    siteLogo: string;
+    activePath: string;
+}): SiteHeaderBlock;
+export declare function buildNavItems(opts: {
+    navSlugs: string[];
+    currentSlug: string;
+    siteConfig: {
+        name?: string;
+        logo?: string;
+        navLabels?: Record<string, string>;
+        navGroups?: Record<string, string[]>;
+    };
+    siteId: string;
+    editorQuery: string;
+    defaultLogo?: string;
+}): {
+    navItems: NavItem[];
+    siteName: string;
+    siteLogo: string;
+    homeHref: string;
+};
+export {};

package/dist/navigation.js

@@ -0,0 +1,95 @@
+export function siteNameFallback(siteId) {
+    return siteId
+        .split("-")
+        .filter(Boolean)
+        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+        .join(" ");
+}
+export function slugToLabel(route) {
+    if (route === "/")
+        return "Home";
+    return route
+        .slice(1)
+        .split("/")
+        .filter(Boolean)
+        .map((part) => part.replace(/[-_]/g, " "))
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" / ");
+}
+function mapNavItemToLink(item) {
+    const link = { label: item.label };
+    if (item.href)
+        link.href = item.href;
+    if (item.children?.length)
+        link.children = item.children.map(mapNavItemToLink);
+    return link;
+}
+export function buildSiteHeaderBlock(opts) {
+    return {
+        id: "chrome_site-header",
+        type: "SiteHeader",
+        props: {
+            siteName: opts.siteName,
+            logoUrl: opts.siteLogo,
+            links: opts.navItems.map(mapNavItemToLink),
+            activePath: opts.activePath,
+        },
+    };
+}
+export function buildNavItems(opts) {
+    const { navSlugs, currentSlug, siteConfig, siteId, editorQuery } = opts;
+    const siteName = siteConfig.name || siteNameFallback(siteId) || "Site";
+    const siteLogo = siteConfig.logo || opts.defaultLogo || "";
+    const allSlugs = Array.from(new Set([...(navSlugs.length > 0 ? navSlugs : ["/"]), currentSlug]));
+    const orderedSlugs = allSlugs.includes("/")
+        ? ["/", ...allSlugs.filter((r) => r !== "/")]
+        : allSlugs;
+    // Build flat items first
+    const flatItems = orderedSlugs.map((route) => ({
+        href: `${route}${editorQuery}`,
+        label: siteConfig.navLabels?.[route] ?? slugToLabel(route),
+        isActive: route === currentSlug,
+        _slug: route, // internal, stripped before return
+    }));
+    // Apply navGroups to collapse slugs into parent dropdown items
+    const navGroups = siteConfig.navGroups;
+    let navItems;
+    if (navGroups && Object.keys(navGroups).length > 0) {
+        // Build reverse lookup: slug → group label
+        const slugToGroup = new Map();
+        for (const [groupLabel, slugs] of Object.entries(navGroups)) {
+            for (const slug of slugs)
+                slugToGroup.set(slug, groupLabel);
+        }
+        const emittedGroups = new Set();
+        navItems = [];
+        for (const item of flatItems) {
+            const groupLabel = slugToGroup.get(item._slug);
+            if (groupLabel) {
+                if (emittedGroups.has(groupLabel))
+                    continue; // already emitted as part of parent
+                emittedGroups.add(groupLabel);
+                // Collect all children in this group (preserving order from navGroups definition)
+                const groupSlugs = navGroups[groupLabel];
+                const children = groupSlugs
+                    .map((slug) => flatItems.find((fi) => fi._slug === slug))
+                    .filter((fi) => !!fi)
+                    .map(({ _slug: _, ...rest }) => rest);
+                navItems.push({
+                    label: groupLabel,
+                    isActive: children.some((c) => c.isActive),
+                    children,
+                });
+            }
+            else {
+                const { _slug: _, ...rest } = item;
+                navItems.push(rest);
+            }
+        }
+    }
+    else {
+        navItems = flatItems.map(({ _slug: _, ...rest }) => rest);
+    }
+    const homeHref = `/${editorQuery}`;
+    return { navItems, siteName, siteLogo, homeHref };
+}

package/dist/publish-handlers/json-file.d.ts

@@ -0,0 +1,24 @@
+import type { OnPublishFn } from "../editor-routes.ts";
+/**
+ * Publish handler that writes PageDoc[] to a local JSON file.
+ *
+ * When `publicDir` is provided, inline assets (base64 images from the
+ * orchestrator) are written to disk and their localhost URLs are rewritten
+ * to relative paths in the JSON output.
+ *
+ * Usage:
+ * ```ts
+ * import { createJsonFilePublishHandler } from "@avocadostudio-ai/site-sdk/publish-handlers/json-file"
+ *
+ * createEditorApiHandler({
+ *   getPages: () => [...],
+ *   onPublish: createJsonFilePublishHandler("/path/to/published-content.json", {
+ *     publicDir: "/path/to/public/generated-images",
+ *   }),
+ * })
+ * ```
+ */
+export declare function createJsonFilePublishHandler(filePath: string, options?: {
+    publicDir?: string;
+    imagePathPrefix?: string;
+}): OnPublishFn;

package/dist/publish-handlers/json-file.js

@@ -0,0 +1,40 @@
+import { writeFile, mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+/**
+ * Publish handler that writes PageDoc[] to a local JSON file.
+ *
+ * When `publicDir` is provided, inline assets (base64 images from the
+ * orchestrator) are written to disk and their localhost URLs are rewritten
+ * to relative paths in the JSON output.
+ *
+ * Usage:
+ * ```ts
+ * import { createJsonFilePublishHandler } from "@avocadostudio-ai/site-sdk/publish-handlers/json-file"
+ *
+ * createEditorApiHandler({
+ *   getPages: () => [...],
+ *   onPublish: createJsonFilePublishHandler("/path/to/published-content.json", {
+ *     publicDir: "/path/to/public/generated-images",
+ *   }),
+ * })
+ * ```
+ */
+export function createJsonFilePublishHandler(filePath, options) {
+    return async (pages, config, context) => {
+        let output = pages;
+        if (options?.publicDir && context?.assets && Object.keys(context.assets).length > 0) {
+            const prefix = options.imagePathPrefix ?? "/generated-images/";
+            await mkdir(options.publicDir, { recursive: true });
+            let json = JSON.stringify(pages, null, 2);
+            for (const [originalUrl, asset] of Object.entries(context.assets)) {
+                const dest = resolve(options.publicDir, asset.fileName);
+                await writeFile(dest, Buffer.from(asset.data, "base64"));
+                json = json.replaceAll(originalUrl, `${prefix}${asset.fileName}`);
+            }
+            output = JSON.parse(json);
+        }
+        const payload = JSON.stringify({ pages: output, siteConfig: config }, null, 2) + "\n";
+        await writeFile(filePath, payload, "utf8");
+        return { ok: true };
+    };
+}

package/dist/publish-utils.d.ts

@@ -0,0 +1,28 @@
+import type { InlineAsset } from "./editor-routes.ts";
+/**
+ * Reject URLs pointing at private/loopback addresses (SSRF protection).
+ * Used by CMS publish handlers to validate image URLs before fetching.
+ */
+export declare function isSafeImageUrl(raw: string): boolean;
+/**
+ * CMS-specific image upload function.
+ * Receives raw bytes + metadata, returns a CMS asset reference (or null on failure).
+ */
+export type ImageUploader<T> = (bytes: Buffer, fileName: string, mimeType: string) => Promise<T | null>;
+/**
+ * Creates a cached image resolver for use during publish.
+ *
+ * Handles the full resolution pipeline that every CMS integration needs:
+ * 1. Check inline assets (base64 from orchestrator for localhost/generated URLs)
+ * 2. SSRF validation
+ * 3. Fetch external URL
+ * 4. Call CMS-specific upload function
+ * 5. Cache results to avoid duplicate uploads within a single publish
+ *
+ * @param upload  CMS-specific upload function (Sanity asset upload, Contentful asset create, Strapi media upload, etc.)
+ * @param assets  Inline assets from the publish context (base64-encoded images)
+ * @returns       A `resolve(imageUrl)` function that returns the CMS asset reference or null
+ */
+export declare function createImageResolver<T>(upload: ImageUploader<T>, assets?: Record<string, InlineAsset>): {
+    resolve: (imageUrl: string) => Promise<T | null>;
+};

package/dist/publish-utils.js

@@ -0,0 +1,92 @@
+/**
+ * Reject URLs pointing at private/loopback addresses (SSRF protection).
+ * Used by CMS publish handlers to validate image URLs before fetching.
+ */
+export function isSafeImageUrl(raw) {
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+        return false;
+    const h = parsed.hostname;
+    if (h === "localhost" || h === "127.0.0.1" || h === "[::1]" || h === "0.0.0.0")
+        return false;
+    if (h.startsWith("10.") || h.startsWith("192.168.") || h.startsWith("169.254."))
+        return false;
+    if (/^172\.(1[6-9]|2\d|3[01])\./.test(h))
+        return false;
+    return true;
+}
+/**
+ * Creates a cached image resolver for use during publish.
+ *
+ * Handles the full resolution pipeline that every CMS integration needs:
+ * 1. Check inline assets (base64 from orchestrator for localhost/generated URLs)
+ * 2. SSRF validation
+ * 3. Fetch external URL
+ * 4. Call CMS-specific upload function
+ * 5. Cache results to avoid duplicate uploads within a single publish
+ *
+ * @param upload  CMS-specific upload function (Sanity asset upload, Contentful asset create, Strapi media upload, etc.)
+ * @param assets  Inline assets from the publish context (base64-encoded images)
+ * @returns       A `resolve(imageUrl)` function that returns the CMS asset reference or null
+ */
+export function createImageResolver(upload, assets) {
+    const cache = new Map();
+    function resolve(imageUrl) {
+        const cached = cache.get(imageUrl);
+        if (cached)
+            return cached;
+        const promise = (async () => {
+            if (!imageUrl.startsWith("http"))
+                return null;
+            const inlineAsset = assets?.[imageUrl];
+            if (inlineAsset) {
+                try {
+                    const buf = Buffer.from(inlineAsset.data, "base64");
+                    return await upload(buf, inlineAsset.fileName, inlineAsset.mimeType);
+                }
+                catch {
+                    return null;
+                }
+            }
+            if (!isSafeImageUrl(imageUrl))
+                return null;
+            try {
+                const res = await fetch(imageUrl);
+                if (!res.ok)
+                    return null;
+                const blob = await res.blob();
+                const buf = Buffer.from(await blob.arrayBuffer());
+                const fileName = imageUrl.split("/").pop()?.split("?")[0] || "image.jpg";
+                const mimeType = blob.type || guessContentType(imageUrl);
+                return await upload(buf, fileName, mimeType);
+            }
+            catch {
+                return null;
+            }
+        })();
+        cache.set(imageUrl, promise);
+        return promise;
+    }
+    return { resolve };
+}
+function guessContentType(url) {
+    try {
+        const ext = new URL(url).pathname.split(".").pop()?.toLowerCase();
+        if (ext === "png")
+            return "image/png";
+        if (ext === "webp")
+            return "image/webp";
+        if (ext === "gif")
+            return "image/gif";
+        if (ext === "svg")
+            return "image/svg+xml";
+    }
+    catch { /* invalid URL — fall through */ }
+    return "image/jpeg";
+}

package/dist/render-blocks.d.ts

@@ -0,0 +1,4 @@
+import type { BlockInstance } from "./types.ts";
+export declare function renderBlocks(blocks: BlockInstance[], options?: {
+    editable?: boolean;
+}): import("react/jsx-runtime").JSX.Element[];

package/dist/render-blocks.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { SharedBlockRenderer, BlockErrorBoundary, getCustomRenderer } from "@avocadostudio-ai/blocks";
+import { getChromeTypes } from "@avocadostudio-ai/shared";
+import { getPreviewWrapperProps } from "./editor.js";
+/**
+ * Renders a list of blocks with error boundaries.
+ * When `editable` is true, adds preview wrapper attributes for editor overlay selection.
+ *
+ * Custom renderers (registered via registerCustomRenderer) are resolved here on the
+ * server side, then passed directly to the client-side BlockErrorBoundary. This avoids
+ * the RSC boundary issue where the customRenderers Map is empty on the client.
+ */
+// Chrome blocks (SiteHeader, Footer) are rendered by createSitePage — skip if present in page blocks
+const CHROME_BLOCK_TYPES = new Set(getChromeTypes());
+export function renderBlocks(blocks, options) {
+    const editable = options?.editable ?? false;
+    return blocks.filter(b => !CHROME_BLOCK_TYPES.has(b.type)).map((block) => {
+        // Resolve custom renderer on the server side (where registerCustomRenderer ran).
+        // Custom renderers are "use client" components — passing them as JSX from a server
+        // component works correctly across the RSC boundary (React serializes the reference).
+        const CustomRenderer = getCustomRenderer(block.type);
+        return (_jsx("div", { id: block.id, ...(editable ? getPreviewWrapperProps(true, block.id, block.type) : {}), children: _jsx(BlockErrorBoundary, { blockId: block.id, blockType: block.type, children: CustomRenderer
+                    ? _jsx(CustomRenderer, { ...block.props })
+                    : _jsx(SharedBlockRenderer, { block: block }) }) }, block.id));
+    });
+}

package/dist/revalidate-handler.d.ts

@@ -0,0 +1,42 @@
+import type { PageDoc } from "./types.ts";
+export type RevalidateHandlerConfig = {
+    /** Environment variable name containing the webhook secret (e.g. "SANITY_WEBHOOK_SECRET") */
+    secretEnvVar: string;
+    /**
+     * Where to look for the webhook secret. Accepts:
+     * - A header name string (default: "x-revalidate-secret")
+     * - null to check only query param "secret"
+     * - An array to check multiple sources in order (e.g. query param then header)
+     */
+    secretHeader?: string | string[] | null;
+    /** Extract the page slug from the webhook body. Return null to revalidate "/". */
+    extractSlug: (body: unknown) => string | null;
+    /** Fetch all published pages (for orchestrator bootstrap after CMS changes). */
+    getPages: () => Promise<PageDoc[]>;
+    /** Site identifier passed to orchestrator bootstrap. */
+    siteId: string;
+    /** Session name passed to orchestrator bootstrap. Defaults to "dev". */
+    session?: string;
+};
+/**
+ * Factory for CMS webhook → ISR revalidation + orchestrator bootstrap routes.
+ *
+ * All three CMS integrations follow the same pattern:
+ * 1. Validate webhook secret
+ * 2. Extract slug from CMS-specific body shape
+ * 3. Call Next.js revalidatePath()
+ * 4. Re-bootstrap orchestrator with fresh content
+ *
+ * This factory extracts that into a single configurable handler.
+ *
+ * Usage:
+ * ```ts
+ * export const POST = createRevalidateHandler({
+ *   secretEnvVar: "SANITY_WEBHOOK_SECRET",
+ *   extractSlug: (body) => (body as any)?.slug?.current ?? null,
+ *   getPages: getSanityPages,
+ *   siteId: "sanity-site",
+ * })
+ * ```
+ */
+export declare function createRevalidateHandler(config: RevalidateHandlerConfig): (request: Request) => Promise<Response>;