@avocadostudio-ai/site-sdk 0.7.0 → 0.8.0

package/dist/editor-rewrite-core.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Options shared by every host's editor rewrite.
+ *
+ * `EditorProxyOptions` in `./proxy.ts` extends this with `trailingSlash`, which
+ * exists only to re-issue a redirect Next was told to stop issuing.
+ */
+export type EditorRewriteOptions = {
+    /**
+     * 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 cookie that keeps in-preview navigation in draft mode, or
+     * `false` to key the rewrite on {@link EditorRewriteOptions.editorParam}
+     * alone.
+     *
+     * A link clicked inside the editor iframe carries no `__editor=1`, so without
+     * a cookie the second page a user visits renders published content.
+     *
+     * The default is Next's own `__prerender_bypass`, which is not Avocado's to
+     * claim: anything else calling `draftMode().enable()` — Sanity's Presentation
+     * tool, Contentful's live preview — sets the same cookie, and every one of
+     * *their* preview requests then lands on Avocado's preview route.
+     *
+     * A host with no draft-mode convention of its own has no `__prerender_bypass`
+     * to inherit and must name and set a cookie itself; whatever it names goes
+     * here, so the rewrite triggers on the same cookie the host sets.
+     *
+     * @default "__prerender_bypass"
+     */
+    draftCookie?: string | false;
+};
+/** What the host should do with this request. */
+export type EditorRewriteDecision = 
+/** Not an editor request. The caller's cue to run its own logic, not a decision to pass through. */
+{
+    kind: "pass";
+}
+/** Serve the preview route instead, with these request headers added. */
+ | {
+    kind: "preview";
+    pathname: string;
+    headers: Record<string, string>;
+};
+export type EditorRewriteRequest = {
+    /**
+     * The path the host routes on. Next supplies `nextUrl.pathname`, which has
+     * `basePath` already stripped; a host without the concept passes the URL's
+     * own pathname. It matters because the preview prefix is prepended to this
+     * value, and prepending it to a path that still carries a basePath produces a
+     * route that exists nowhere.
+     */
+    pathname: string;
+    searchParams: URLSearchParams;
+    hasCookie: (name: string) => boolean;
+};
+/**
+ * Whether a request is the editor previewing the site, and where it should be
+ * served from if so.
+ *
+ * Pure, and the whole of the rewrite: `editorPreviewRewrite` in `./proxy.ts` is
+ * this plus `NextResponse.rewrite`, and any other host's middleware is this
+ * plus its own equivalent.
+ */
+export declare function decideEditorRewrite(request: EditorRewriteRequest, options?: EditorRewriteOptions): EditorRewriteDecision;

package/dist/editor-rewrite-core.js

@@ -0,0 +1,37 @@
+import { DEFAULT_PREVIEW_ROUTE } from "./editor-matcher.js";
+import { EDITOR_RENDER_HEADER } from "./editor-render.js";
+/**
+ * Whether a request is the editor previewing the site, and where it should be
+ * served from if so.
+ *
+ * Pure, and the whole of the rewrite: `editorPreviewRewrite` in `./proxy.ts` is
+ * this plus `NextResponse.rewrite`, and any other host's middleware is this
+ * plus its own equivalent.
+ */
+export function decideEditorRewrite(request, options) {
+    const previewRoute = options?.previewRoute ?? DEFAULT_PREVIEW_ROUTE;
+    const editorParam = options?.editorParam ?? "__editor";
+    const draftCookie = options?.draftCookie === undefined ? "__prerender_bypass" : options.draftCookie;
+    const isEditor = request.searchParams.get(editorParam) === "1";
+    const hasDraftCookie = draftCookie !== false && request.hasCookie(draftCookie);
+    if (!isEditor && !hasDraftCookie)
+        return { kind: "pass" };
+    /*
+     * The one fact a layout can get at.
+     *
+     * A page learns it is being previewed from `resolveEditorContext(searchParams)`.
+     * A layout receives no search params, and the root layout is exactly where a
+     * site mounts its consent banner, analytics and tag manager — so every
+     * integration loads all three into the editor iframe until somebody notices
+     * the pageviews. Stamping the rewritten request lets `isEditorRenderFrom()`
+     * answer in a layout without the site threading anything down to it.
+     *
+     * Set on the request, replacing any client-supplied header of the same name,
+     * so what a layout reads is this function's answer and not the caller's.
+     */
+    return {
+        kind: "preview",
+        pathname: `${previewRoute}${request.pathname}`,
+        headers: { [EDITOR_RENDER_HEADER]: "1" },
+    };
+}

package/dist/lens/register.d.ts

@@ -1,14 +1,18 @@
 import type { FieldTable, Primitives } from "./types.ts";
 export type RegisterOptions = {
     /**
-     * The CMS pack, read only for its image prop naming.
+     * The CMS pack, read for its image prop naming and its row keys.
      *
      * Passing the same object `createLens` gets is what makes the panel and the
      * projection agree about what an image field's two props are called. Held
      * apart they are two declarations that must match with nothing checking that
      * they do — and the symptom is an asset picker that never appears.
+     *
+     * `rowIdKey` and `rowTypeKey` are the same argument one level down: the
+     * projection writes a row's identity and type under those keys, so the schema
+     * has to expect them there and the list has to discriminate on them.
      */
-    primitives?: Pick<Primitives, "imageNaming">;
+    primitives?: Pick<Primitives, "imageNaming"> & Partial<Pick<Primitives, "rowIdKey" | "rowTypeKey">>;
     /**
      * `false` to leave Avocado's own built-in block types in the picker.
      *
@@ -18,12 +22,6 @@ export type RegisterOptions = {
      */
     narrowCatalogue?: boolean;
 };
-/**
- * Register every type in the table as an Avocado block type.
- *
- * Adding a field to a block becomes one line in one file: the schema, the
- * panel, the projection and the merge all read the same declaration.
- */
 export declare function registerFieldTable(table: FieldTable, options?: RegisterOptions): void;
 /**
  * The types a page body may hold, which is not every type in the table.

package/dist/lens/register.js

@@ -12,7 +12,7 @@
  * `createLens` returns a value; folding a side effect into a constructor makes
  * an object you cannot build twice, and makes the order of two imports matter.
  */
-import { registerBlock, declareBlockCatalogue, z } from "@avocadostudio-ai/shared";
+import { registerBlock, declareBlockCatalogue, z, FIELD_KINDS } from "@avocadostudio-ai/shared";
 import { suffixNaming } from "./types.js";
 /**
  * A ProseMirror document, declared so the panel recognises it as one.
@@ -32,10 +32,70 @@ function humanise(key) {
         .replace(/([a-z\d])([A-Z])/g, "$1 $2")
         .replace(/^./, (c) => c.toUpperCase());
 }
-function schemaForField(spec) {
+/**
+ * The row types a `list: { of }` can actually be given a shape for.
+ *
+ * A named type the table does not describe is skipped rather than emitted as an
+ * empty branch: Avocado cannot project or merge a row of it — `createLens`
+ * filters those rows out — so offering it in the panel would be an Add control
+ * for something no publish could store.
+ */
+function rowTypesFor(of, ctx) {
+    if (!ctx.rowTypeKey)
+        return [];
+    return [...new Set(of)].filter((type) => ctx.table[type] !== undefined && !ctx.visiting.has(type));
+}
+/**
+ * One list row as an object schema, and `loose` is the load-bearing word.
+ *
+ * A row is a CMS document: it carries `component`, `_uid`, and every field the
+ * table chose not to declare. `z.object` strips what it does not know, and the
+ * ops engine's passthrough only covers a block's *top-level* props — so a
+ * strict row schema would silently delete the undeclared half of every row an
+ * edit touched.
+ */
+function rowSchema(fields, ctx, pinned) {
+    const shape = { ...pinned };
+    // Declared, not merely tolerated: an undeclared prop present in the content is
+    // an `orphan_prop` to the coverage checkers, and a row id is one per row.
+    if (ctx.rowIdKey)
+        shape[ctx.rowIdKey] = z.string().optional();
+    Object.assign(shape, shapeForFields(fields, ctx));
+    return z.object(shape).loose();
+}
+/**
+ * A list's schema, in the one shape the manifest can resolve.
+ *
+ * It used to be `z.array(z.record(z.string(), z.any()))` for both forms, which
+ * reaches the manifest as an array of objects with no properties — so the
+ * derivation produced no item fields at all, `resolveManifestFieldMeta` dropped
+ * the list, and the panel drew neither rows nor an Add control. The metadata
+ * registered beside it was correct the whole time; the schema is what the panel
+ * sees, and it said nothing.
+ */
+function listSchemaFor(spec, ctx) {
+    if ("itemFields" in spec)
+        return z.array(rowSchema(spec.itemFields, ctx, {})).optional();
+    const typeKey = ctx.rowTypeKey;
+    const types = rowTypesFor(spec.of, ctx);
+    // Nothing describable: back to the opaque array, which at least stores the
+    // rows untouched rather than rejecting them.
+    if (types.length === 0)
+        return z.array(z.record(z.string(), z.any())).optional();
+    const branches = types.map((type) => rowSchema(ctx.table[type].fields, { ...ctx, visiting: new Set([...ctx.visiting, type]) }, {
+        [typeKey]: z.literal(type)
+    }));
+    return z.array(z.discriminatedUnion(typeKey, branches)).optional();
+}
+function schemaForField(spec, ctx) {
     switch (spec.kind) {
         case "richtext":
             return richTextSchema().optional();
+        // Stored as the string the template renders. The document only exists
+        // while the panel has it open; `richTextSchema` would also admit a doc,
+        // and a doc written back is markup the site cannot render.
+        case "html":
+            return z.string().optional();
         case "boolean":
             return z.boolean().optional();
         case "number":
@@ -51,70 +111,184 @@ function schemaForField(spec) {
         case "imageList":
             return z.array(z.record(z.string(), z.any())).optional();
         case "list":
-            return z.array(z.record(z.string(), z.any())).optional();
+            return listSchemaFor(spec, ctx);
         default:
             return z.string().optional();
     }
 }
+/**
+ * A declared field set as an object shape — a block's props, or a row's.
+ *
+ * An image is two props and `key` may be neither of them: a pack that names
+ * them `heroUrl`/`heroAlt` must not also leave a bare `hero` in the schema, or
+ * the panel draws a third control that writes nowhere.
+ */
+function shapeForFields(fields, ctx) {
+    const shape = {};
+    for (const [key, spec] of Object.entries(fields)) {
+        if (spec.kind === "image") {
+            shape[ctx.naming.url(key)] = z.string().optional();
+            shape[ctx.naming.alt(key)] = z.string().optional();
+            continue;
+        }
+        shape[key] = schemaForField(spec, ctx);
+    }
+    return shape;
+}
 function metaForField(key, spec) {
     const meta = {
-        kind: spec.kind === "stringList" || spec.kind === "imageList" || spec.kind === "list" ? "text" : spec.kind,
+        /*
+         * `list` alone is still `text` here, and it is not a loss: a list travels
+         * the separate `listFields` channel, which carries its row shape, and the
+         * kind on this side is never read. `stringList` and `imageList` have no
+         * such channel — flattening them to `text` was the whole of AW-01, because
+         * the panel then discarded the metadata as contradicting an array schema
+         * and drew nothing.
+         */
+        kind: spec.kind === "list" ? "text" : spec.kind,
         label: spec.label ?? humanise(key)
     };
     if (spec.internal)
         meta.internal = true;
+    if (spec.panelOnly)
+        meta.panelOnly = true;
     if (spec.kind === "text" && spec.multiline)
         meta.multiline = true;
     if (spec.kind === "text" && spec.inlineEditable !== undefined)
         meta.inlineEditable = spec.inlineEditable;
     if (spec.kind === "richtext" && spec.inline)
         meta.inline = true;
+    if (spec.kind === "html" && spec.inline)
+        meta.inline = true;
+    /*
+     * Not editable on the page unless the site says so.
+     *
+     * Every other kind defaults to inline-editable, and for this one that
+     * default corrupts: the overlay edits an element's text, and the value here
+     * is markup wrapped around that text. A person fixing a typo in the hero
+     * headline would write the typo back without the spans. The panel converts
+     * properly, so it is the whole of the UI until a site opts in.
+     */
+    if (spec.kind === "html")
+        meta.inlineEditable = spec.inlineEditable ?? false;
     if (spec.kind === "enum")
         meta.options = [...spec.options];
     if (spec.kind === "image" && spec.imageSpec)
         meta.imageSpec = spec.imageSpec;
     return meta;
 }
+/** The same expansion as `shapeForFields`, as panel metadata rather than schema. */
+function metaForFields(fields, ctx) {
+    const out = {};
+    if (ctx.rowIdKey)
+        out[ctx.rowIdKey] = { kind: "text", label: humanise(ctx.rowIdKey), internal: true };
+    for (const [key, spec] of Object.entries(fields)) {
+        if (spec.kind === "image") {
+            out[ctx.naming.url(key)] = metaForField(key, spec);
+            out[ctx.naming.alt(key)] = { kind: "imageAlt", label: `${spec.label ?? humanise(key)} alt` };
+            continue;
+        }
+        out[key] = metaForField(key, spec);
+    }
+    return out;
+}
+/**
+ * A list's panel metadata.
+ *
+ * Declared rather than left to the derivation because the derivation cannot
+ * know all of it: an enum's options never reach the JSON schema (the schema is
+ * a plain string on purpose, see above), and neither does a label the table
+ * chose. For the `of` form this carries the per-type field sets and the
+ * discriminator the panel narrows a row by — and that the ops engine reads to
+ * refuse a new row that names no type.
+ */
+function listMetaFor(key, spec, ctx) {
+    const label = spec.label ?? humanise(key);
+    if ("itemFields" in spec)
+        return { label, itemFields: metaForFields(spec.itemFields, ctx) };
+    const types = rowTypesFor(spec.of, ctx);
+    if (types.length === 0)
+        return { label, itemFields: {} };
+    const itemFieldsByType = {};
+    const merged = {};
+    for (const type of types) {
+        const fields = metaForFields(ctx.table[type].fields, {
+            ...ctx,
+            visiting: new Set([...ctx.visiting, type])
+        });
+        itemFieldsByType[type] = fields;
+        for (const [fieldKey, meta] of Object.entries(fields))
+            if (!(fieldKey in merged))
+                merged[fieldKey] = meta;
+    }
+    return { label, itemFields: merged, discriminator: ctx.rowTypeKey, itemFieldsByType };
+}
 /**
  * Register every type in the table as an Avocado block type.
  *
  * Adding a field to a block becomes one line in one file: the schema, the
  * panel, the projection and the merge all read the same declaration.
  */
+/**
+ * Refuse a field this table cannot draw, rather than emitting the nearest kind.
+ *
+ * Every gap this file has produced was found by a person looking at a property
+ * panel: a control drawn for something it cannot edit, or — worse — no control
+ * at all, with the field valid in the schema and present in the codec. Nothing
+ * failed, so nothing was reported, and the integration looked finished.
+ *
+ * TypeScript already rejects an unknown `kind` for a table written in
+ * TypeScript. This is for the tables that are not: `registerFieldTable` is a
+ * published entry point, adopters call it from plain JavaScript and from JSON
+ * they generated, and a misspelled kind there is currently a field that quietly
+ * becomes a text input over a value a text input destroys.
+ *
+ * It checks the kind only. It cannot tell whether the panel's control for a
+ * kind is the *right* control — that is what `FIELD_KINDS` and the editor's own
+ * exhaustiveness check are for.
+ */
+function assertDrawable(type, key, spec) {
+    const kind = spec.kind;
+    if (typeof kind === "string" && KNOWN_KINDS.includes(kind))
+        return;
+    throw new Error(`registerFieldTable: ${type}.${key} declares kind ${JSON.stringify(kind)}, which is not a field kind. `
+        + `Known kinds: ${KNOWN_KINDS.join(", ")}.`);
+}
+/**
+ * The kinds a table may declare.
+ *
+ * `FIELD_KINDS` is the panel's vocabulary; `list` is this layer's own, because
+ * a list is not a field — it travels the `listFields` channel instead and has
+ * no `FieldKind` spelling.
+ */
+const KNOWN_KINDS = [...FIELD_KINDS, "list"];
 export function registerFieldTable(table, options) {
     const naming = options?.primitives?.imageNaming ?? suffixNaming("", "_alt");
+    const ctx = {
+        naming,
+        table,
+        rowIdKey: options?.primitives?.rowIdKey,
+        rowTypeKey: options?.primitives?.rowTypeKey,
+        visiting: new Set()
+    };
     for (const [type, blockSpec] of Object.entries(table)) {
-        const shape = {};
+        const shape = shapeForFields(blockSpec.fields, { ...ctx, visiting: new Set([type]) });
         const fields = {};
         const listFields = {};
         for (const [key, spec] of Object.entries(blockSpec.fields)) {
-            shape[key] = schemaForField(spec);
-            if (spec.kind === "list" || spec.kind === "imageList") {
-                const itemFields = {};
-                if (spec.kind === "imageList") {
-                    itemFields.image = { kind: "image", label: "Image" };
-                    itemFields.alt = { kind: "imageAlt", label: "Alt text" };
-                }
-                else if ("itemFields" in spec) {
-                    for (const [itemKey, itemSpec] of Object.entries(spec.itemFields)) {
-                        if (itemSpec.kind === "image") {
-                            itemFields[naming.url(itemKey)] = metaForField(itemKey, itemSpec);
-                            itemFields[naming.alt(itemKey)] = { kind: "imageAlt", label: `${itemSpec.label ?? humanise(itemKey)} alt` };
-                            continue;
-                        }
-                        itemFields[itemKey] = metaForField(itemKey, itemSpec);
-                    }
-                }
-                listFields[key] = { label: spec.label ?? humanise(key), itemFields };
+            assertDrawable(type, key, spec);
+            if (spec.kind === "imageList") {
+                listFields[key] = {
+                    label: spec.label ?? humanise(key),
+                    itemFields: { image: { kind: "image", label: "Image" }, alt: { kind: "imageAlt", label: "Alt text" } }
+                };
+                continue;
+            }
+            if (spec.kind === "list") {
+                listFields[key] = listMetaFor(key, spec, { ...ctx, visiting: new Set([type]) });
                 continue;
             }
             if (spec.kind === "image") {
-                // An image is two props, and `key` may not be either of them: a pack
-                // that names them `heroUrl`/`heroAlt` must not also leave a bare `hero`
-                // in the schema, or the panel draws a third control that writes nowhere.
-                delete shape[key];
-                shape[naming.url(key)] = z.string().optional();
-                shape[naming.alt(key)] = z.string().optional();
                 fields[naming.url(key)] = metaForField(key, spec);
                 fields[naming.alt(key)] = { kind: "imageAlt", label: `${spec.label ?? humanise(key)} alt` };
                 continue;

package/dist/lens/types.d.ts

@@ -11,6 +11,20 @@ type FieldCommon = {
      * keeping it out of the panel and out of the planner's view.
      */
     internal?: boolean;
+    /**
+     * A person edits it, but never on the page.
+     *
+     * A section anchor, a video poster, a layout switch: real content with no
+     * element that could carry an editable marker, so the property panel is the
+     * whole of its UI. `editableCoverage` reads this as "no marker expected",
+     * which is what makes the number reachable — without it a correct
+     * integration reports 88% and the integrator gating on coverage has to guess
+     * a threshold, at which point a real regression hides behind the guess.
+     *
+     * The weaker neighbour of `internal`: that one says the field has no
+     * audience, this one says it has no element.
+     */
+    panelOnly?: boolean;
     /**
      * `false` for a field with one value for every language.
      *
@@ -52,6 +66,22 @@ export type FieldSpec =
     kind: "richtext";
     inline?: boolean;
 })
+/**
+ * A string of HTML — a prop the template renders with `set:html`,
+ * `dangerouslySetInnerHTML` or `v-html`.
+ *
+ * Stored as the string it is, edited as a document. Declaring one of these
+ * `richtext` is the mistake it exists to stop: `richtext` means a document,
+ * so the panel renders the markup literally and a person editing it writes
+ * broken markup back into the site's own source file. Tags outside the
+ * converter's vocabulary are preserved rather than dropped — see
+ * `@avocadostudio-ai/richtext`'s `fromHtml`.
+ */
+ | (FieldCommon & {
+    kind: "html";
+    inline?: boolean;
+    inlineEditable?: boolean;
+})
 /** An image. Projects to a URL string plus a companion alt prop. */
  | (FieldCommon & {
     kind: "image";
@@ -99,6 +129,12 @@ export type FieldSpec =
  * `of` names the child types admitted, for a CMS where each row is its own
  * document and carries its own type; `itemFields` describes the row inline,
  * for a CMS where the rows are plain objects. Exactly one of the two.
+ *
+ * Every type named in `of` must itself be in the table, and the pack must
+ * supply a `rowTypeKey`: the list's schema is a discriminated union over that
+ * key, with one branch per named type. A type the table does not describe is
+ * left out of the union rather than admitted as an empty shape, because
+ * `createLens` cannot project or merge a row of it either.
  */
  | (FieldCommon & {
     kind: "list";

package/dist/page-metadata.d.ts

@@ -64,3 +64,24 @@ export type BuildPageMetadataOptions = {
  * image to put in it.
  */
 export declare function buildPageMetadata(page: Pick<PageDoc, "title" | "meta" | "blocks">, options?: BuildPageMetadataOptions): PageMetadata;
+/**
+ * Render {@link PageMetadata} as the head tags it describes.
+ *
+ * Next consumes the object directly — a route exports `metadata` and the
+ * framework emits the tags — so nothing in this repo needed this until now.
+ * Every other host writes its own `<head>`, and an integrator left to do that
+ * by hand reproduces a subset: the title and description usually, Open Graph
+ * sometimes, `twitter:card` almost never, and the canonical link not at all.
+ * That is how `test:build` came to exist — three of those omissions had already
+ * shipped from the one route that built its head by hand.
+ *
+ * Returns a string because the alternative is a shape per templating language.
+ * The values are attribute-escaped; the caller inserts it as raw HTML
+ * (`set:html` in Astro, `v-html` in Vue, `{@html}` in Svelte).
+ *
+ * `og:image` and `twitter:image` are emitted exactly as given. A relative path
+ * is legal in the document but most crawlers will not resolve it, so pass
+ * absolute URLs — the same rule that applies to `buildPageMetadata`'s
+ * `canonical`.
+ */
+export declare function renderPageMetadata(metadata: PageMetadata): string;

package/dist/page-metadata.js

@@ -108,3 +108,67 @@ export function buildPageMetadata(page, options = {}) {
         ...(options.canonical ? { alternates: { canonical: options.canonical } } : {}),
     };
 }
+/** `&`, `<`, `>` and `"` inside an attribute value, which a title routinely contains. */
+function escapeAttribute(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+/**
+ * Render {@link PageMetadata} as the head tags it describes.
+ *
+ * Next consumes the object directly — a route exports `metadata` and the
+ * framework emits the tags — so nothing in this repo needed this until now.
+ * Every other host writes its own `<head>`, and an integrator left to do that
+ * by hand reproduces a subset: the title and description usually, Open Graph
+ * sometimes, `twitter:card` almost never, and the canonical link not at all.
+ * That is how `test:build` came to exist — three of those omissions had already
+ * shipped from the one route that built its head by hand.
+ *
+ * Returns a string because the alternative is a shape per templating language.
+ * The values are attribute-escaped; the caller inserts it as raw HTML
+ * (`set:html` in Astro, `v-html` in Vue, `{@html}` in Svelte).
+ *
+ * `og:image` and `twitter:image` are emitted exactly as given. A relative path
+ * is legal in the document but most crawlers will not resolve it, so pass
+ * absolute URLs — the same rule that applies to `buildPageMetadata`'s
+ * `canonical`.
+ */
+export function renderPageMetadata(metadata) {
+    const tags = [];
+    const meta = (attr, key, value) => {
+        if (value)
+            tags.push(`<meta ${attr}="${escapeAttribute(key)}" content="${escapeAttribute(value)}" />`);
+    };
+    if (metadata.title)
+        tags.push(`<title>${escapeAttribute(metadata.title)}</title>`);
+    meta("name", "description", metadata.description);
+    if (metadata.alternates?.canonical) {
+        tags.push(`<link rel="canonical" href="${escapeAttribute(metadata.alternates.canonical)}" />`);
+    }
+    const og = metadata.openGraph;
+    if (og) {
+        meta("property", "og:title", og.title);
+        meta("property", "og:description", og.description);
+        meta("property", "og:type", og.type);
+        meta("property", "og:site_name", og.siteName);
+        meta("property", "og:url", og.url);
+        for (const image of og.images ?? [])
+            meta("property", "og:image", image);
+    }
+    const twitter = metadata.twitter;
+    if (twitter) {
+        meta("name", "twitter:card", twitter.card);
+        meta("name", "twitter:title", twitter.title);
+        meta("name", "twitter:description", twitter.description);
+        for (const image of twitter.images ?? [])
+            meta("name", "twitter:image", image);
+    }
+    if (metadata.robots) {
+        const directives = [metadata.robots.index ? "index" : "noindex", metadata.robots.follow ? "follow" : "nofollow"];
+        meta("name", "robots", directives.join(", "));
+    }
+    return tags.join("\n");
+}

package/dist/proxy.d.ts

@@ -1,37 +1,16 @@
 import { NextResponse, type NextRequest } from "next/server";
+import { type EditorRewriteOptions } from "./editor-rewrite-core.ts";
 export { DEFAULT_PREVIEW_ROUTE, buildEditorMatcher } from "./editor-matcher.ts";
+export { decideEditorRewrite } from "./editor-rewrite-core.ts";
+export type { EditorRewriteDecision, EditorRewriteOptions } from "./editor-rewrite-core.ts";
 /**
  * Options for the editor proxy factory.
+ *
+ * `previewRoute`, `editorParam` and `draftCookie` are documented on
+ * {@link EditorRewriteOptions}, which every host shares; `trailingSlash` below
+ * is Next's alone.
  */
-export type EditorProxyOptions = {
-    /**
-     * 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, or `false` to ignore cookies
-     * entirely and key the rewrite on {@link EditorProxyOptions.editorParam} alone.
-     *
-     * The cookie is how navigation *inside* the editor iframe stays in draft mode:
-     * a link click carries no `__editor=1`, so without it the second page a user
-     * visits renders published content.
-     *
-     * But the cookie is Next's own, and it is not Avocado's to claim. Any other
-     * feature that calls `draftMode().enable()` sets the same
-     * `__prerender_bypass` — Sanity's Presentation tool and Contentful's live
-     * preview both do — and every one of *their* preview requests then lands on
-     * Avocado's preview route. On a site that already had Draft Mode before it had
-     * Avocado, pass `draftCookie: false` and the two stop fighting over it.
-     *
-     * @default "__prerender_bypass"
-     */
-    draftCookie?: string | false;
+export type EditorProxyOptions = EditorRewriteOptions & {
     /**
      * Set this to `true` on a site whose `next.config` sets `trailingSlash: true`.
      *
@@ -118,4 +97,4 @@ export declare function trailingSlashRedirect(request: NextRequest): NextRespons
  * The half of `createEditorProxy` a site with its own middleware needs; see
  * {@link trailingSlashRedirect} for the composition.
  */
-export declare function editorPreviewRewrite(request: NextRequest, options?: Pick<EditorProxyOptions, "previewRoute" | "editorParam" | "draftCookie">): NextResponse | null;
+export declare function editorPreviewRewrite(request: NextRequest, options?: EditorRewriteOptions): NextResponse | null;