@avocadostudio-ai/site-sdk 0.1.0

package/dist/draft-fetch.js

@@ -0,0 +1,115 @@
+import { pageDocSchemaLenient, siteConfigSchema } from "@avocadostudio-ai/shared";
+export function getOrchestratorUrl() {
+    const value = process.env.ORCHESTRATOR_URL?.trim();
+    if (value)
+        return value.replace(/\/$/, "");
+    if (process.env.NODE_ENV !== "production")
+        return "http://127.0.0.1:4200";
+    return null;
+}
+function buildCandidateBaseUrls(configuredBaseUrl) {
+    const candidates = [configuredBaseUrl];
+    try {
+        const parsed = new URL(configuredBaseUrl);
+        if (parsed.hostname === "localhost") {
+            parsed.hostname = "127.0.0.1";
+            candidates.push(parsed.toString().replace(/\/$/, ""));
+        }
+        else if (parsed.hostname === "127.0.0.1") {
+            parsed.hostname = "localhost";
+            candidates.push(parsed.toString().replace(/\/$/, ""));
+        }
+    }
+    catch {
+        // Keep the configured URL as-is.
+    }
+    return candidates;
+}
+async function fetchWithTimeout(url, timeoutMs) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, { cache: "no-store", signal: controller.signal });
+        return response;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export async function fetchEditorPage(slug, session, siteId, options) {
+    const configuredBaseUrl = options?.orchestratorUrl ?? getOrchestratorUrl();
+    if (!configuredBaseUrl)
+        return null;
+    const timeout = options?.timeoutMs ?? 5000;
+    const baseUrls = buildCandidateBaseUrls(configuredBaseUrl);
+    for (const baseUrl of baseUrls) {
+        try {
+            const url = `${baseUrl}/draft/pages?session=${encodeURIComponent(session)}&siteId=${encodeURIComponent(siteId)}&slug=${encodeURIComponent(slug)}`;
+            const res = await fetchWithTimeout(url, timeout);
+            if (!res.ok)
+                continue;
+            const payload = (await res.json());
+            const parsed = pageDocSchemaLenient.safeParse(payload);
+            if (parsed.success)
+                return parsed.data;
+            // Schema parse failed — surface the issues so this doesn't show up as a
+            // mysterious "Draft unavailable" in the UI. A common cause is the
+            // orchestrator returning a page doc that's missing required fields
+            // (e.g. id/updatedAt on pages created via the agent create_page tool).
+            const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+            console.warn(`[site-sdk/draft] fetchEditorPage: schema parse failed for slug=${slug} session=${session} siteId=${siteId} — ${issues}`);
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return null;
+}
+export async function fetchEditorSlugs(session, siteId, options) {
+    const configuredBaseUrl = options?.orchestratorUrl ?? getOrchestratorUrl();
+    if (!configuredBaseUrl)
+        return [];
+    const timeout = options?.timeoutMs ?? 5000;
+    const baseUrls = buildCandidateBaseUrls(configuredBaseUrl);
+    for (const baseUrl of baseUrls) {
+        try {
+            const url = `${baseUrl}/draft/slugs?session=${encodeURIComponent(session)}&siteId=${encodeURIComponent(siteId)}`;
+            const res = await fetchWithTimeout(url, timeout);
+            if (!res.ok)
+                continue;
+            const payload = (await res.json());
+            if (!Array.isArray(payload.slugs))
+                continue;
+            const slugs = payload.slugs.filter((item) => typeof item === "string" && item.length > 0);
+            if (slugs.length > 0)
+                return slugs;
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return [];
+}
+export async function fetchEditorSiteConfig(session, siteId, options) {
+    const configuredBaseUrl = options?.orchestratorUrl ?? getOrchestratorUrl();
+    if (!configuredBaseUrl)
+        return {};
+    const timeout = options?.timeoutMs ?? 5000;
+    const baseUrls = buildCandidateBaseUrls(configuredBaseUrl);
+    for (const baseUrl of baseUrls) {
+        try {
+            const url = `${baseUrl}/draft/site-config?session=${encodeURIComponent(session)}&siteId=${encodeURIComponent(siteId)}`;
+            const res = await fetchWithTimeout(url, timeout);
+            if (!res.ok)
+                continue;
+            const payload = (await res.json());
+            const parsed = siteConfigSchema.safeParse(payload);
+            if (parsed.success)
+                return parsed.data;
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return {};
+}

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

@@ -0,0 +1,11 @@
+export type DraftRouteAdapter = {
+    enableDraftMode: () => Promise<void>;
+    disableDraftMode: () => Promise<void>;
+    createRedirect: (url: URL, cookies?: Array<{
+        name: string;
+        value: string;
+        delete?: boolean;
+    }>) => Response;
+};
+export declare function createDraftEnableHandlerCore(adapter: DraftRouteAdapter): (request: Request) => Promise<Response>;
+export declare function createDraftDisableHandlerCore(adapter: DraftRouteAdapter): (request: Request) => Promise<Response>;

package/dist/draft-routes-core.js

@@ -0,0 +1,41 @@
+import { validateDraftSecret, getSafeInternalRedirectPath } from "@avocadostudio-ai/shared";
+import { DRAFT_SESSION_COOKIE, DRAFT_SITE_COOKIE, EDITOR_ORIGIN_COOKIE, normalizeOrigin } from "./draft-common.js";
+export function createDraftEnableHandlerCore(adapter) {
+    return async (request) => {
+        const url = new URL(request.url);
+        const validation = validateDraftSecret(url.searchParams.get("secret"), process.env);
+        if (!validation.ok && validation.reason === "missing_config") {
+            return new Response(JSON.stringify({ ok: false, error: "Draft mode secret is not configured. Set DRAFT_MODE_SECRET or NEXT_DRAFT_MODE_SECRET." }), { status: 500, headers: { "Content-Type": "application/json" } });
+        }
+        if (!validation.ok && validation.reason === "invalid_secret") {
+            return new Response(JSON.stringify({ ok: false, error: "Invalid draft mode secret." }), { status: 401, headers: { "Content-Type": "application/json" } });
+        }
+        const redirectPath = getSafeInternalRedirectPath(url.searchParams.get("redirect") ?? url.searchParams.get("slug"));
+        await adapter.enableDraftMode();
+        const redirectUrl = new URL(redirectPath, url);
+        const cookies = [];
+        const session = redirectUrl.searchParams.get("session")?.trim();
+        const siteId = redirectUrl.searchParams.get("siteId")?.trim();
+        const editorOrigin = normalizeOrigin(redirectUrl.searchParams.get("editorOrigin"));
+        if (session)
+            cookies.push({ name: DRAFT_SESSION_COOKIE, value: session });
+        if (siteId)
+            cookies.push({ name: DRAFT_SITE_COOKIE, value: siteId });
+        if (editorOrigin)
+            cookies.push({ name: EDITOR_ORIGIN_COOKIE, value: encodeURIComponent(editorOrigin) });
+        return adapter.createRedirect(redirectUrl, cookies);
+    };
+}
+export function createDraftDisableHandlerCore(adapter) {
+    return async (request) => {
+        const url = new URL(request.url);
+        await adapter.disableDraftMode();
+        const redirectPath = getSafeInternalRedirectPath(url.searchParams.get("redirect") ?? url.searchParams.get("slug"));
+        const redirectUrl = new URL(redirectPath, url);
+        return adapter.createRedirect(redirectUrl, [
+            { name: DRAFT_SESSION_COOKIE, value: "", delete: true },
+            { name: DRAFT_SITE_COOKIE, value: "", delete: true },
+            { name: EDITOR_ORIGIN_COOKIE, value: "", delete: true }
+        ]);
+    };
+}

package/dist/draft-routes.d.ts

@@ -0,0 +1,2 @@
+export declare function createDraftEnableHandler(): (request: Request) => Promise<Response>;
+export declare function createDraftDisableHandler(): (request: Request) => Promise<Response>;

package/dist/draft-routes.js

@@ -0,0 +1,27 @@
+import { draftMode } from "next/headers";
+import { NextResponse } from "next/server";
+import { createDraftEnableHandlerCore, createDraftDisableHandlerCore } from "./draft-routes-core.js";
+function createNextAdapter() {
+    return {
+        enableDraftMode: async () => { (await draftMode()).enable(); },
+        disableDraftMode: async () => { (await draftMode()).disable(); },
+        createRedirect: (url, cookies) => {
+            const response = NextResponse.redirect(url);
+            for (const c of cookies ?? []) {
+                if (c.delete) {
+                    response.cookies.delete(c.name);
+                }
+                else {
+                    response.cookies.set(c.name, c.value, { path: "/", sameSite: "lax" });
+                }
+            }
+            return response;
+        },
+    };
+}
+export function createDraftEnableHandler() {
+    return createDraftEnableHandlerCore(createNextAdapter());
+}
+export function createDraftDisableHandler() {
+    return createDraftDisableHandlerCore(createNextAdapter());
+}

package/dist/draft.d.ts

@@ -0,0 +1,3 @@
+export { resolveEditorContext, single } from "./draft-context.ts";
+export { getOrchestratorUrl, fetchEditorPage, fetchEditorSlugs, fetchEditorSiteConfig } from "./draft-fetch.ts";
+export { DRAFT_SESSION_COOKIE, DRAFT_SITE_COOKIE, EDITOR_ORIGIN_COOKIE } from "./draft-common.ts";

package/dist/draft.js

@@ -0,0 +1,6 @@
+// Editor context resolution
+export { resolveEditorContext, single } from "./draft-context.js";
+// Editor content fetching
+export { getOrchestratorUrl, fetchEditorPage, fetchEditorSlugs, fetchEditorSiteConfig } from "./draft-fetch.js";
+// Draft cookie constants
+export { DRAFT_SESSION_COOKIE, DRAFT_SITE_COOKIE, EDITOR_ORIGIN_COOKIE } from "./draft-common.js";

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

@@ -0,0 +1,59 @@
+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;
+    onPublish?: OnPublishFn;
+    /** Secret token required for publish requests. Checked against x-publish-token header. */
+    publishSecret?: string;
+}
+type NextRouteContext = {
+    params: Promise<{
+        path: string[];
+    }>;
+};
+/**
+ * Creates a single catch-all route handler that serves all editor API endpoints.
+ *
+ * Mount at `app/api/editor/[...path]/route.ts`:
+ * ```ts
+ * export const { GET, POST, OPTIONS } = createEditorApiHandler({
+ *   getPages: () => [...],
+ *   onPublish: async (pages, config) => { ... return { ok: true } }
+ * })
+ * ```
+ *
+ * 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 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

@@ -0,0 +1,89 @@
+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";
+/**
+ * Creates a single catch-all route handler that serves all editor API endpoints.
+ *
+ * Mount at `app/api/editor/[...path]/route.ts`:
+ * ```ts
+ * export const { GET, POST, OPTIONS } = createEditorApiHandler({
+ *   getPages: () => [...],
+ *   onPublish: async (pages, config) => { ... return { ok: true } }
+ * })
+ * ```
+ *
+ * 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 createEditorApiHandler(config) {
+    const draftEnable = createDraftEnableHandler();
+    const draftDisable = createDraftDisableHandler();
+    const manifestBuilder = config.registerBlocks
+        ? () => {
+            config.registerBlocks();
+            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"));
+    }
+    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);
+            }
+        },
+        async POST(request, context) {
+            const { path } = await context.params;
+            const route = matchRoute(path);
+            if (route === "publish" && publishHandler) {
+                return publishHandler.POST(request);
+            }
+            return notFound(request);
+        },
+        OPTIONS(request, context) {
+            // OPTIONS doesn't need async params resolution for CORS preflight
+            return blocksHandler.OPTIONS(request);
+        },
+    };
+}

package/dist/editor-cors.d.ts

@@ -0,0 +1,3 @@
+export declare function getEditorCorsOrigins(): Set<string>;
+export declare function applyEditorCors(response: Response, requestOrigin: string | null): Response;
+export declare function createEditorCorsOptionsHandler(): (request: Request) => Response;

package/dist/editor-cors.js

@@ -0,0 +1,31 @@
+let cachedOrigins;
+export function getEditorCorsOrigins() {
+    if (cachedOrigins)
+        return cachedOrigins;
+    const defaults = ["http://localhost:4100"];
+    const extra = (process.env.EDITOR_CORS_ORIGINS ?? "")
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    cachedOrigins = new Set([...defaults, ...extra]);
+    return cachedOrigins;
+}
+export function applyEditorCors(response, requestOrigin) {
+    const vary = response.headers.get("Vary") ?? "";
+    const hasOrigin = vary.split(",").map((v) => v.trim().toLowerCase()).includes("origin");
+    if (!hasOrigin)
+        response.headers.append("Vary", "Origin");
+    if (!requestOrigin)
+        return response;
+    if (!getEditorCorsOrigins().has(requestOrigin))
+        return response;
+    response.headers.set("Access-Control-Allow-Origin", requestOrigin);
+    response.headers.set("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    return response;
+}
+export function createEditorCorsOptionsHandler() {
+    return (request) => {
+        return applyEditorCors(new Response(null, { status: 204 }), request.headers.get("origin"));
+    };
+}

package/dist/editor-manifest.d.ts

@@ -0,0 +1,3 @@
+import { blockDefinitionSchema, blockManifestSchema, validateByJsonSchemaLike, validateManifestDefaultProps, type BlockDefinition, type BlockManifest } from "@avocadostudio-ai/shared";
+export { blockDefinitionSchema, blockManifestSchema, validateByJsonSchemaLike, validateManifestDefaultProps, type BlockDefinition, type BlockManifest };
+export declare function buildBlockManifest(): BlockManifest;

package/dist/editor-manifest.js

@@ -0,0 +1,65 @@
+import { getBlockJsonSchema, getBlockMeta, allowedBlockTypes, defaultPropsForType } from "@avocadostudio-ai/shared";
+import { blockDefinitionSchema, blockManifestSchema, validateByJsonSchemaLike, validateManifestDefaultProps } from "@avocadostudio-ai/shared";
+export { blockDefinitionSchema, blockManifestSchema, validateByJsonSchemaLike, validateManifestDefaultProps };
+// --- Manifest builder ---
+// Built fresh each time to include custom blocks registered after initial load.
+// Custom site blocks call registerBlock() in their schema.ts (imported via blocks/register.ts),
+// which adds them to allowedBlockTypes. The manifest must reflect ALL registered blocks,
+// not just the standard library ones.
+export function buildBlockManifest() {
+    const blocks = allowedBlockTypes
+        .map((type) => {
+        const meta = getBlockMeta(type);
+        const propsSchema = getBlockJsonSchema(type);
+        if (!propsSchema)
+            return null; // skip blocks without schema (shouldn't happen but be safe)
+        const finalSchema = applyMetaEnumsToSchema(propsSchema, meta);
+        // Only attach defaultProps that actually satisfy the block's schema.
+        // defaultPropsForType() hands custom (non-core) blocks a generic CTA-shaped
+        // fallback; if that violates a custom schema (e.g. a richtext field expecting
+        // a doc object, not a string) it would fail validateManifestDefaultProps and
+        // poison the WHOLE manifest, making every block read as "unknown" in the editor.
+        const candidateDefaults = defaultPropsForType(type);
+        const defaultProps = validateByJsonSchemaLike(finalSchema, candidateDefaults)
+            ? candidateDefaults
+            : undefined;
+        return {
+            type,
+            displayName: meta?.displayName ?? type,
+            propsSchema: finalSchema,
+            defaultProps
+        };
+    })
+        .filter((b) => b !== null);
+    return { version: 1, blocks };
+}
+/**
+ * Fold enum options declared in the block's registry `meta.fields` into the
+ * derived JSON schema. A site can declare `f.enum("Gap", ["sm","md","lg"])` in
+ * its block meta while the Zod prop stays a plain `z.string()` (so any value
+ * still validates). Without this, manifest-driven custom blocks lose the enum
+ * and the editor renders a free-text input instead of a dropdown. We only add
+ * `enum` (the editor reads it to pick a select control); validation is type-only
+ * (see validateByJsonSchemaLike), so widening here never rejects stored content.
+ */
+function applyMetaEnumsToSchema(schema, meta) {
+    if (!meta?.fields)
+        return schema;
+    const properties = schema.properties;
+    if (!properties || typeof properties !== "object")
+        return schema;
+    let next;
+    for (const [key, fieldMeta] of Object.entries(meta.fields)) {
+        if (fieldMeta.kind !== "enum" || !fieldMeta.options?.length)
+            continue;
+        const prop = properties[key];
+        if (!prop || typeof prop !== "object" || Array.isArray(prop))
+            continue;
+        const propObj = prop;
+        if (Array.isArray(propObj.enum))
+            continue; // schema already carries an enum
+        next ??= { ...schema, properties: { ...properties } };
+        next.properties[key] = { ...propObj, type: "string", enum: [...fieldMeta.options] };
+    }
+    return next ?? schema;
+}

package/dist/editor-overlay-inner.d.ts

@@ -0,0 +1,5 @@
+import "@avocadostudio-ai/preview-adapter/styles.css";
+export declare function EditorOverlayInner({ slug, editorOrigin }: {
+    slug: string;
+    editorOrigin: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/editor-overlay-inner.js

@@ -0,0 +1,7 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import "@avocadostudio-ai/preview-adapter/styles.css";
+import { PreviewBridge } from "@avocadostudio-ai/preview-adapter";
+export function EditorOverlayInner({ slug, editorOrigin }) {
+    return _jsx(PreviewBridge, { slug: slug, editorOrigin: editorOrigin });
+}

package/dist/editor-overlay.d.ts

@@ -0,0 +1,4 @@
+export declare function EditorOverlay({ slug, editorOrigin }: {
+    slug: string;
+    editorOrigin: string;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/editor-overlay.js

@@ -0,0 +1,14 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import dynamic from "next/dynamic";
+import { useState, useEffect } from "react";
+const PreviewBridgeLoader = dynamic(() => import("./editor-overlay-inner.js").then((m) => ({ default: m.EditorOverlayInner })), { ssr: false });
+export function EditorOverlay({ slug, editorOrigin }) {
+    const [inIframe, setInIframe] = useState(false);
+    useEffect(() => {
+        setInIframe(window.parent !== window);
+    }, []);
+    if (!inIframe)
+        return null;
+    return _jsx(PreviewBridgeLoader, { slug: slug, editorOrigin: editorOrigin });
+}

package/dist/editor-query.d.ts

@@ -0,0 +1,2 @@
+export declare function buildEditorQuerySuffix(searchParams: URLSearchParams): string;
+export declare function buildSlug(parts?: string[]): string;

package/dist/editor-query.js

@@ -0,0 +1,16 @@
+const EDITOR_KEYS = ["session", "siteId", "editorOrigin", "__editor"];
+export function buildEditorQuerySuffix(searchParams) {
+    const params = new URLSearchParams();
+    for (const key of EDITOR_KEYS) {
+        const val = searchParams.get(key);
+        if (val)
+            params.set(key, val);
+    }
+    const str = params.toString();
+    return str ? `?${str}` : "";
+}
+export function buildSlug(parts) {
+    if (!parts || parts.length === 0)
+        return "/";
+    return `/${parts.join("/")}`;
+}

package/dist/editor-routes.d.ts

@@ -0,0 +1,35 @@
+import { type BlockManifest } from "./editor-manifest.ts";
+import type { PageDoc } from "./types.ts";
+import type { SiteConfig } from "@avocadostudio-ai/shared";
+export type InlineAsset = {
+    /** base64-encoded image bytes */
+    data: string;
+    /** MIME type, e.g. "image/png" */
+    mimeType: string;
+    /** Original filename */
+    fileName: string;
+};
+export type PublishContext = {
+    /** Base64-encoded images for localhost/generated URLs that can't be fetched remotely */
+    assets?: Record<string, InlineAsset>;
+};
+export type OnPublishFn = (pages: PageDoc[], config: SiteConfig, context?: PublishContext) => Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+export declare function createBlocksHandler(options?: {
+    getManifest?: () => BlockManifest;
+}): {
+    GET: (request: Request) => Response;
+    OPTIONS: (request: Request) => Response;
+};
+export declare function createPagesHandler(getPages: () => PageDoc[] | Promise<PageDoc[]>, getSiteConfig?: () => SiteConfig | undefined | Promise<SiteConfig | undefined>): {
+    GET: (request: Request) => Promise<Response>;
+    OPTIONS: (request: Request) => Response;
+};
+export declare function createPublishHandler(onPublish: OnPublishFn, options?: {
+    publishSecret?: string;
+}): {
+    POST: (request: Request) => Promise<Response>;
+    OPTIONS: (request: Request) => Response;
+};

package/dist/editor-routes.js

@@ -0,0 +1,66 @@
+import { applyEditorCors, createEditorCorsOptionsHandler } from "./editor-cors.js";
+import { buildBlockManifest } from "./editor-manifest.js";
+export function createBlocksHandler(options) {
+    const getManifest = options?.getManifest ?? buildBlockManifest;
+    return {
+        OPTIONS: createEditorCorsOptionsHandler(),
+        GET(request) {
+            const manifest = getManifest();
+            const response = new Response(JSON.stringify(manifest), {
+                status: 200,
+                headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }
+            });
+            return applyEditorCors(response, request.headers.get("origin"));
+        }
+    };
+}
+export function createPagesHandler(getPages, getSiteConfig) {
+    return {
+        OPTIONS: createEditorCorsOptionsHandler(),
+        async GET(request) {
+            const pages = await getPages();
+            const siteConfig = getSiteConfig ? await getSiteConfig() : undefined;
+            const body = siteConfig ? { pages, siteConfig } : { pages };
+            const response = new Response(JSON.stringify(body), {
+                status: 200,
+                headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }
+            });
+            return applyEditorCors(response, request.headers.get("origin"));
+        }
+    };
+}
+export function createPublishHandler(onPublish, options) {
+    return {
+        OPTIONS: createEditorCorsOptionsHandler(),
+        async POST(request) {
+            // Verify publish token if configured
+            const secret = options?.publishSecret;
+            if (secret) {
+                const provided = request.headers.get("x-publish-token")?.trim();
+                if (!provided || provided !== secret) {
+                    const res = new Response(JSON.stringify({ ok: false, error: "Invalid or missing publish token" }), { status: 401, headers: { "Content-Type": "application/json" } });
+                    return applyEditorCors(res, request.headers.get("origin"));
+                }
+            }
+            try {
+                const body = (await request.json());
+                if (!Array.isArray(body.pages)) {
+                    const res = new Response(JSON.stringify({ ok: false, error: "pages must be an array" }), { status: 400, headers: { "Content-Type": "application/json" } });
+                    return applyEditorCors(res, request.headers.get("origin"));
+                }
+                const pages = body.pages;
+                const config = (body.siteConfig ?? {});
+                const context = { assets: body.assets };
+                const result = await onPublish(pages, config, context);
+                const status = result.ok ? 200 : 500;
+                const res = new Response(JSON.stringify({ ok: result.ok, slugs: pages.map((p) => p.slug), error: result.error }), { status, headers: { "Content-Type": "application/json" } });
+                return applyEditorCors(res, request.headers.get("origin"));
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : "publish failed";
+                const res = new Response(JSON.stringify({ ok: false, error: message }), { status: 500, headers: { "Content-Type": "application/json" } });
+                return applyEditorCors(res, request.headers.get("origin"));
+            }
+        }
+    };
+}

package/dist/editor.d.ts

@@ -0,0 +1,20 @@
+export { EditorOverlay } from "./editor-overlay.tsx";
+export { buildEditorQuerySuffix } from "./editor-query.ts";
+export declare function getPreviewWrapperProps(editorMode: boolean, blockId: string, blockType: string): {
+    readonly "data-block-id"?: undefined;
+    readonly "data-block-type"?: undefined;
+    readonly className?: undefined;
+    readonly style?: undefined;
+} | {
+    readonly "data-block-id": string;
+    readonly "data-block-type": string;
+    readonly className: "editor-selectable";
+    readonly style: {
+        readonly viewTransitionName: `block-${string}`;
+    };
+};
+export { renderBlocks } from "./render-blocks.tsx";
+export { RenderedBlocks, PreviewBlock } from "./live-preview-blocks.tsx";
+export { LivePreviewProvider } from "@avocadostudio-ai/preview-adapter";
+export type { LivePreviewPage, LivePreviewBridgeApi } from "@avocadostudio-ai/preview-adapter";
+export { getEditorCorsOrigins, applyEditorCors, createEditorCorsOptionsHandler } from "./editor-cors.ts";