canopycms 0.0.68-int.103 → 0.0.68-int.105

package/dist/build/asset-refs.d.ts

@@ -63,9 +63,10 @@ declare const assetRefsFileSchema: z.ZodObject<{
     }[];
 }>;
 export type AssetRefsFile = z.infer<typeof assetRefsFileSchema>;
-/** A URL in the output that no stored object can answer. */
+/** A URL in the output that no stored object can answer, or an inline flight script that cannot be read. */
 export interface AssetRefProblem {
     file: string;
+    /** The URL, or the script's position when the problem is a script. */
     url: string;
     error: string;
 }

package/dist/build/asset-refs.js

@@ -12,6 +12,7 @@ import { z } from 'zod';
 import { ASSET_PREFIXES } from '../assets/asset-prefixes.js';
 import { canonicalizeTransformPath } from '../assets/transform-directives.js';
 import { atomicWriteFile } from '../utils/atomic-write.js';
+import { extractInlineFlight } from './inline-flight.js';
 /** @internal Written into the scanned directory, so a manifest the adopter builds afterwards covers it. */
 export const ASSET_REFS_FILENAME = 'canopy-asset-refs.json';
 /**
@@ -84,11 +85,12 @@ async function listScannedFiles(root) {
         .filter((rel) => rel !== ASSET_REFS_FILENAME)
         .sort();
 }
+const HTML_FILE_RE = /\.html?$/;
 /** The route a static-export HTML file serves (`about/index.html` and `about.html` are `/about`). */
 function routeForFile(file) {
-    if (!/\.html?$/.test(file))
+    if (!HTML_FILE_RE.test(file))
         return undefined;
-    const withoutExt = file.replace(/\.html?$/, '');
+    const withoutExt = file.replace(HTML_FILE_RE, '');
     const route = withoutExt === 'index' ? '' : withoutExt.replace(/\/index$/, '');
     return `/${route}`;
 }
@@ -191,13 +193,8 @@ export async function collectAssetRefs(outDir) {
     const transforms = new RefCollector();
     const statics = new RefCollector();
     const problems = [];
-    let scannedFiles = 0;
-    for (const file of files) {
-        const filePath = path.join(root, file);
-        if (path.extname(file) === '' && (await startsBinary(filePath)))
-            continue;
-        scannedFiles++;
-        const text = decodeUrlEscapes(await fs.readFile(filePath, 'utf-8'));
+    const scan = (file, raw) => {
+        const text = decodeUrlEscapes(raw);
         for (const match of text.matchAll(TRANSFORM_URL_RE)) {
             const [url, filename] = trimTrailingPunctuation(match[0], match[3]);
             const [, encodedDirectives, hash32] = match;
@@ -228,6 +225,25 @@ export async function collectAssetRefs(outDir) {
                 statics.add(`${ASSET_PREFIXES.public}/${hash32}/${filename}`, file);
             }
         }
+    };
+    let scannedFiles = 0;
+    for (const file of files) {
+        const filePath = path.join(root, file);
+        if (path.extname(file) === '' && (await startsBinary(filePath)))
+            continue;
+        scannedFiles++;
+        const text = await fs.readFile(filePath, 'utf-8');
+        if (!HTML_FILE_RE.test(file)) {
+            scan(file, text);
+            continue;
+        }
+        // A page's inline RSC payload is split across scripts at arbitrary bytes (inline-flight.ts).
+        const page = extractInlineFlight(text);
+        scan(file, page.markup);
+        for (const flight of page.texts)
+            scan(file, flight);
+        for (const { script, error } of page.problems)
+            problems.push({ file, url: script, error });
     }
     if (problems.length > 0)
         throw new AssetRefsError(problems);

package/dist/build/inline-flight.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Reassemble the RSC (flight) stream Next's App Router inlines into a page, so a URL the stream
+ * splits across two scripts is scanned whole.
+ *
+ * Next writes each chunk of the stream as its own `<script>`, and React Flight cuts chunks at
+ * arbitrary bytes (it fills fixed-size views and enqueues the partial one at every flush), so a URL
+ * can straddle two scripts and the page text holds only its fragments. The format is the same in Next 15.5.21 and 16.1.7
+ * (`createInlinedDataReadableStream` in `dist/server/app-render/use-flight-response.js`, read back
+ * by `nextServerDataCallback` in `dist/client/app-index.js`):
+ *
+ * - `(self.__next_f=self.__next_f||[]).push([0])` starts the stream, followed in the same script by
+ *   `;self.__next_f.push([2,formState])` when there is form state;
+ * - each chunk is then `self.__next_f.push([1,text])`, or `[3,base64]` for a chunk that is not
+ *   valid UTF-8, whose bytes join the same stream;
+ * - every argument is `JSON.stringify` output passed through `htmlEscapeJsonString`, which only
+ *   rewrites `& < > U+2028 U+2029` as `\uXXXX` escapes, so it parses as JSON and never holds
+ *   `</script`.
+ *
+ * Every push on a page joins one stream: Next inlines one flight stream per page.
+ */
+export interface InlineFlight {
+    /** The page with each parsed flight script replaced by a space, so no fragment is scanned. */
+    markup: string;
+    /** The stream's text, joined in document order, then each form state as JSON. */
+    texts: string[];
+    /** Scripts that name `__next_f` but are not flight pushes; their data cannot be scanned. */
+    problems: {
+        script: string;
+        error: string;
+    }[];
+}
+/**
+ * Split `html` into its markup and its inline flight stream. Only a script whose body names
+ * `__next_f` is flight; one that does but does not parse stays in the markup and is reported,
+ * because skipping it could drop a reference.
+ */
+export declare function extractInlineFlight(html: string): InlineFlight;

package/dist/build/inline-flight.js

@@ -0,0 +1,142 @@
+/**
+ * Reassemble the RSC (flight) stream Next's App Router inlines into a page, so a URL the stream
+ * splits across two scripts is scanned whole.
+ *
+ * Next writes each chunk of the stream as its own `<script>`, and React Flight cuts chunks at
+ * arbitrary bytes (it fills fixed-size views and enqueues the partial one at every flush), so a URL
+ * can straddle two scripts and the page text holds only its fragments. The format is the same in Next 15.5.21 and 16.1.7
+ * (`createInlinedDataReadableStream` in `dist/server/app-render/use-flight-response.js`, read back
+ * by `nextServerDataCallback` in `dist/client/app-index.js`):
+ *
+ * - `(self.__next_f=self.__next_f||[]).push([0])` starts the stream, followed in the same script by
+ *   `;self.__next_f.push([2,formState])` when there is form state;
+ * - each chunk is then `self.__next_f.push([1,text])`, or `[3,base64]` for a chunk that is not
+ *   valid UTF-8, whose bytes join the same stream;
+ * - every argument is `JSON.stringify` output passed through `htmlEscapeJsonString`, which only
+ *   rewrites `& < > U+2028 U+2029` as `\uXXXX` escapes, so it parses as JSON and never holds
+ *   `</script`.
+ *
+ * Every push on a page joins one stream: Next inlines one flight stream per page.
+ */
+import { getErrorMessage } from '../utils/error.js';
+const PUSH_CALL_RE = /(?:\(self\.__next_f=self\.__next_f\|\|\[\]\)|self\.__next_f)\.push\(/y;
+const BASE64_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+/** The index just past the JSON array that opens at `start`; `JSON.parse` checks the rest. */
+function jsonArrayEnd(body, start) {
+    if (body[start] !== '[')
+        throw new Error(`expected a JSON array at ${start}`);
+    let depth = 0;
+    let inString = false;
+    for (let i = start; i < body.length; i++) {
+        const c = body[i];
+        if (inString) {
+            if (c === '\\')
+                i++;
+            else if (c === '"')
+                inString = false;
+        }
+        else if (c === '"') {
+            inString = true;
+        }
+        else if (c === '[' || c === '{') {
+            depth++;
+        }
+        else if (c === ']' || c === '}') {
+            depth--;
+            if (depth === 0)
+                return i + 1;
+        }
+    }
+    throw new Error('unterminated JSON array');
+}
+/** The arguments of a script body that is nothing but `;`-joined `self.__next_f.push(...)` calls. */
+function parsePushArguments(body) {
+    const args = [];
+    let pos = 0;
+    for (;;) {
+        PUSH_CALL_RE.lastIndex = pos;
+        if (!PUSH_CALL_RE.test(body))
+            throw new Error(`expected self.__next_f.push( at ${pos}`);
+        const end = jsonArrayEnd(body, PUSH_CALL_RE.lastIndex);
+        args.push(JSON.parse(body.slice(PUSH_CALL_RE.lastIndex, end)));
+        if (body[end] !== ')')
+            throw new Error(`expected ) at ${end}`);
+        pos = end + 1;
+        if (pos === body.length)
+            return args;
+        if (body[pos] !== ';')
+            throw new Error(`expected ; or the end of the script at ${pos}`);
+        pos++;
+    }
+}
+/** A push's contribution: bytes of the stream, form state as JSON, or nothing (the bootstrap). */
+function readSegment(arg) {
+    if (!Array.isArray(arg))
+        throw new Error('argument is not an array');
+    const [kind, payload] = arg;
+    if (kind === 0 && arg.length === 1)
+        return {};
+    if (kind === 1 && arg.length === 2 && typeof payload === 'string') {
+        return { bytes: Buffer.from(payload, 'utf8') };
+    }
+    if (kind === 2 && arg.length === 2)
+        return { formState: JSON.stringify(payload) };
+    if (kind === 3 && arg.length === 2 && typeof payload === 'string' && BASE64_RE.test(payload)) {
+        return { bytes: Buffer.from(payload, 'base64') };
+    }
+    throw new Error(`unknown segment ${JSON.stringify(arg).slice(0, 40)}`);
+}
+/** Each script element's span and body, in document order; one pass, however the page ends. */
+function* scriptElements(html) {
+    const openRe = /<script\b[^<>]*>/gi;
+    const closeRe = /<\/script\s*>/gi;
+    for (let open = openRe.exec(html); open; open = openRe.exec(html)) {
+        closeRe.lastIndex = openRe.lastIndex;
+        const close = closeRe.exec(html);
+        if (!close)
+            return;
+        yield {
+            start: open.index,
+            end: closeRe.lastIndex,
+            body: html.slice(openRe.lastIndex, close.index),
+        };
+        openRe.lastIndex = closeRe.lastIndex;
+    }
+}
+/**
+ * Split `html` into its markup and its inline flight stream. Only a script whose body names
+ * `__next_f` is flight; one that does but does not parse stays in the markup and is reported,
+ * because skipping it could drop a reference.
+ */
+export function extractInlineFlight(html) {
+    const stream = [];
+    const formStates = [];
+    const problems = [];
+    let markup = '';
+    let last = 0;
+    for (const { start, end, body } of scriptElements(html)) {
+        if (!body.includes('__next_f'))
+            continue;
+        let segments;
+        try {
+            segments = parsePushArguments(body).map(readSegment);
+        }
+        catch (err) {
+            problems.push({
+                script: `<script> at offset ${start}`,
+                error: `Not a Next inline flight script (${getErrorMessage(err)}); its RSC payload cannot be scanned`,
+            });
+            continue;
+        }
+        for (const { bytes, formState } of segments) {
+            if (bytes)
+                stream.push(bytes);
+            if (formState !== undefined)
+                formStates.push(formState);
+        }
+        markup += `${html.slice(last, start)} `;
+        last = end;
+    }
+    const texts = stream.length > 0 ? [Buffer.concat(stream).toString('utf8'), ...formStates] : formStates;
+    return { markup: markup + html.slice(last), texts, problems };
+}

package/dist/cli/cli.js

@@ -12653,6 +12653,123 @@ var init_atomic_write2 = __esm({
   }
 });
 
+// dist/build/inline-flight.js
+function jsonArrayEnd(body, start) {
+  if (body[start] !== "[")
+    throw new Error(`expected a JSON array at ${start}`);
+  let depth = 0;
+  let inString = false;
+  for (let i = start; i < body.length; i++) {
+    const c = body[i];
+    if (inString) {
+      if (c === "\\")
+        i++;
+      else if (c === '"')
+        inString = false;
+    } else if (c === '"') {
+      inString = true;
+    } else if (c === "[" || c === "{") {
+      depth++;
+    } else if (c === "]" || c === "}") {
+      depth--;
+      if (depth === 0)
+        return i + 1;
+    }
+  }
+  throw new Error("unterminated JSON array");
+}
+function parsePushArguments(body) {
+  const args = [];
+  let pos = 0;
+  for (; ; ) {
+    PUSH_CALL_RE.lastIndex = pos;
+    if (!PUSH_CALL_RE.test(body))
+      throw new Error(`expected self.__next_f.push( at ${pos}`);
+    const end = jsonArrayEnd(body, PUSH_CALL_RE.lastIndex);
+    args.push(JSON.parse(body.slice(PUSH_CALL_RE.lastIndex, end)));
+    if (body[end] !== ")")
+      throw new Error(`expected ) at ${end}`);
+    pos = end + 1;
+    if (pos === body.length)
+      return args;
+    if (body[pos] !== ";")
+      throw new Error(`expected ; or the end of the script at ${pos}`);
+    pos++;
+  }
+}
+function readSegment(arg) {
+  if (!Array.isArray(arg))
+    throw new Error("argument is not an array");
+  const [kind, payload] = arg;
+  if (kind === 0 && arg.length === 1)
+    return {};
+  if (kind === 1 && arg.length === 2 && typeof payload === "string") {
+    return { bytes: Buffer.from(payload, "utf8") };
+  }
+  if (kind === 2 && arg.length === 2)
+    return { formState: JSON.stringify(payload) };
+  if (kind === 3 && arg.length === 2 && typeof payload === "string" && BASE64_RE.test(payload)) {
+    return { bytes: Buffer.from(payload, "base64") };
+  }
+  throw new Error(`unknown segment ${JSON.stringify(arg).slice(0, 40)}`);
+}
+function* scriptElements(html) {
+  const openRe = /<script\b[^<>]*>/gi;
+  const closeRe = /<\/script\s*>/gi;
+  for (let open = openRe.exec(html); open; open = openRe.exec(html)) {
+    closeRe.lastIndex = openRe.lastIndex;
+    const close = closeRe.exec(html);
+    if (!close)
+      return;
+    yield {
+      start: open.index,
+      end: closeRe.lastIndex,
+      body: html.slice(openRe.lastIndex, close.index)
+    };
+    openRe.lastIndex = closeRe.lastIndex;
+  }
+}
+function extractInlineFlight(html) {
+  const stream = [];
+  const formStates = [];
+  const problems = [];
+  let markup = "";
+  let last = 0;
+  for (const { start, end, body } of scriptElements(html)) {
+    if (!body.includes("__next_f"))
+      continue;
+    let segments;
+    try {
+      segments = parsePushArguments(body).map(readSegment);
+    } catch (err2) {
+      problems.push({
+        script: `<script> at offset ${start}`,
+        error: `Not a Next inline flight script (${getErrorMessage(err2)}); its RSC payload cannot be scanned`
+      });
+      continue;
+    }
+    for (const { bytes, formState } of segments) {
+      if (bytes)
+        stream.push(bytes);
+      if (formState !== void 0)
+        formStates.push(formState);
+    }
+    markup += `${html.slice(last, start)} `;
+    last = end;
+  }
+  const texts = stream.length > 0 ? [Buffer.concat(stream).toString("utf8"), ...formStates] : formStates;
+  return { markup: markup + html.slice(last), texts, problems };
+}
+var PUSH_CALL_RE, BASE64_RE;
+var init_inline_flight = __esm({
+  "dist/build/inline-flight.js"() {
+    "use strict";
+    init_error();
+    PUSH_CALL_RE = /(?:\(self\.__next_f=self\.__next_f\|\|\[\]\)|self\.__next_f)\.push\(/y;
+    BASE64_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+  }
+});
+
 // dist/build/asset-refs.js
 import fs24 from "node:fs/promises";
 import path26 from "node:path";
@@ -12662,9 +12779,9 @@ async function listScannedFiles(root) {
   return entries.filter((entry) => entry.isFile() && SCANNED_EXTENSIONS.has(path26.extname(entry.name))).map((entry) => path26.relative(root, path26.join(entry.parentPath, entry.name))).map((rel) => rel.split(path26.sep).join("/")).filter((rel) => rel !== ASSET_REFS_FILENAME).sort();
 }
 function routeForFile(file) {
-  if (!/\.html?$/.test(file))
+  if (!HTML_FILE_RE.test(file))
     return void 0;
-  const withoutExt = file.replace(/\.html?$/, "");
+  const withoutExt = file.replace(HTML_FILE_RE, "");
   const route = withoutExt === "index" ? "" : withoutExt.replace(/\/index$/, "");
   return `/${route}`;
 }
@@ -12718,13 +12835,8 @@ async function collectAssetRefs(outDir) {
   const transforms = new RefCollector();
   const statics = new RefCollector();
   const problems = [];
-  let scannedFiles = 0;
-  for (const file of files) {
-    const filePath2 = path26.join(root, file);
-    if (path26.extname(file) === "" && await startsBinary(filePath2))
-      continue;
-    scannedFiles++;
-    const text3 = decodeUrlEscapes(await fs24.readFile(filePath2, "utf-8"));
+  const scan = (file, raw) => {
+    const text3 = decodeUrlEscapes(raw);
     for (const match of text3.matchAll(TRANSFORM_URL_RE)) {
       const [url, filename] = trimTrailingPunctuation(match[0], match[3]);
       const [, encodedDirectives, hash32] = match;
@@ -12751,6 +12863,24 @@ async function collectAssetRefs(outDir) {
         statics.add(`${ASSET_PREFIXES.public}/${hash32}/${filename}`, file);
       }
     }
+  };
+  let scannedFiles = 0;
+  for (const file of files) {
+    const filePath2 = path26.join(root, file);
+    if (path26.extname(file) === "" && await startsBinary(filePath2))
+      continue;
+    scannedFiles++;
+    const text3 = await fs24.readFile(filePath2, "utf-8");
+    if (!HTML_FILE_RE.test(file)) {
+      scan(file, text3);
+      continue;
+    }
+    const page = extractInlineFlight(text3);
+    scan(file, page.markup);
+    for (const flight of page.texts)
+      scan(file, flight);
+    for (const { script, error } of page.problems)
+      problems.push({ file, url: script, error });
   }
   if (problems.length > 0)
     throw new AssetRefsError(problems);
@@ -12772,13 +12902,14 @@ async function readAssetRefsFile(filePath) {
   }
   return parsed.data;
 }
-var ASSET_REFS_FILENAME, SCANNED_EXTENSIONS, URL_STOP, TRANSFORM_URL_RE, STATIC_URL_RE, STATIC_FILENAME_RE, HASH32_RE2, assetRefEntrySchema, assetRefsFileSchema, AssetRefsError, ENCODED_ASSETS, RUN_STOP, RefCollector;
+var ASSET_REFS_FILENAME, SCANNED_EXTENSIONS, URL_STOP, TRANSFORM_URL_RE, STATIC_URL_RE, STATIC_FILENAME_RE, HASH32_RE2, assetRefEntrySchema, assetRefsFileSchema, AssetRefsError, HTML_FILE_RE, ENCODED_ASSETS, RUN_STOP, RefCollector;
 var init_asset_refs = __esm({
   "dist/build/asset-refs.js"() {
     "use strict";
     init_asset_prefixes();
     init_transform_directives();
     init_atomic_write2();
+    init_inline_flight();
     ASSET_REFS_FILENAME = "canopy-asset-refs.json";
     SCANNED_EXTENSIONS = /* @__PURE__ */ new Set([
       "",
@@ -12820,6 +12951,7 @@ var init_asset_refs = __esm({
         this.name = "AssetRefsError";
       }
     };
+    HTML_FILE_RE = /\.html?$/;
     ENCODED_ASSETS = /%2[fF]assets%2[fF]/g;
     RUN_STOP = /[\s"'`<>&]/;
     RefCollector = class {

package/dist/editor/fields/mdx-jsx-support.js

@@ -62,13 +62,83 @@ function unsupportedJsx(mdx, node) {
     }
     return null;
 }
+// Blocks that run into the block before them in a list item, by that block's type.
+const RUNS_INTO = {
+    paragraph: ['thematicBreak'],
+    blockquote: ['paragraph', 'blockquote', 'table'],
+    table: ['paragraph', 'table'],
+};
+const BLOCK_NAMES = {
+    paragraph: 'paragraph',
+    blockquote: 'quote',
+    table: 'table',
+    thematicBreak: 'horizontal rule',
+};
+/**
+ * Why MDXEditor would change what this list item says, or null. Its import moves a nested list into
+ * a new item after its own, so what follows the list comes out before it; its export writes an item
+ * tight, so `---` underlines a paragraph and a line continues a quote or table (`RUNS_INTO`).
+ */
+function rearrangedBlocks(node) {
+    if (node.type !== 'listItem')
+        return null;
+    for (let i = 1; i < node.children.length; i++) {
+        const before = node.children[i - 1].type;
+        const after = node.children[i].type;
+        if (before === 'list')
+            return 'a list item with content after its nested list';
+        if (RUNS_INTO[before]?.includes(after)) {
+            return `a list item with a ${BLOCK_NAMES[before] ?? before} followed by a ${BLOCK_NAMES[after] ?? after}`;
+        }
+    }
+    return null;
+}
+const isLexicalParent = (node) => 'getChildren' in node && typeof node.getChildren === 'function';
+const hasBlockChild = (node) => isLexicalParent(node) && node.getChildren().some((child) => !child.isInline());
+// Writes `node`'s children into `target`: a run of inline children as one paragraph, a block as itself.
+function writeBlocks(node, target, actions) {
+    let paragraph = null;
+    for (const child of isLexicalParent(node) ? node.getChildren() : []) {
+        if (!child.isInline()) {
+            paragraph = null;
+            actions.visit(child, target);
+            continue;
+        }
+        if (paragraph === null) {
+            const created = { type: 'paragraph', children: [] };
+            actions.appendToParent(target, created);
+            paragraph = created;
+        }
+        actions.visit(child, paragraph);
+    }
+}
+// MDXEditor 4 exports each child of a quote as a block, so inline children the toolbar's Quote,
+// the `> ` shortcut or a merge put in a quote would come out one paragraph each.
+const quoteExportVisitor = {
+    priority: 100,
+    testLexicalNode: (node) => node.getType() === 'quote',
+    visitLexicalNode({ lexicalNode, mdastParent, actions }) {
+        const quote = { type: 'blockquote', children: [] };
+        actions.appendToParent(mdastParent, quote);
+        writeBlocks(lexicalNode, quote, actions);
+    },
+};
+// Backspace at the start of a quote moves its paragraphs and lists into one paragraph, which
+// MDXEditor would export as one run of text; they are written as the blocks they show.
+const paragraphOfBlocksExportVisitor = {
+    priority: 100,
+    testLexicalNode: (node) => node.getType() === 'paragraph' && hasBlockChild(node),
+    visitLexicalNode({ lexicalNode, mdastParent, actions }) {
+        writeBlocks(lexicalNode, mdastParent, actions);
+    },
+};
 /** Typed `string` because the mdast node union this package resolves omits the ESM node. */
 const ESM_NODE_TYPE = 'mdxjsEsm';
 /** Node types inside a table, imported by its cell editors rather than by visitors. */
 const CONSUMED_BY_PARENT_VISITOR = new Set(['tableRow', 'tableCell']);
 /** Creates the JSX plugins from MDXEditor's exports; call once per load of MDXEditor. */
 export function createMdxJsxPlugins(mdx) {
-    const { NestedLexicalEditor, UnrecognizedMarkdownConstructError, addImportVisitor$, importVisitors$, isMdastJsxNode, jsxPlugin, realmPlugin, } = mdx;
+    const { NestedLexicalEditor, UnrecognizedMarkdownConstructError, addExportVisitor$, addImportVisitor$, importVisitors$, isMdastJsxNode, jsxPlugin, realmPlugin, } = mdx;
     /**
      * Shows an element's tag and attributes read-only (they are edited as source)
      * and edits its children, inline or block per the parsed node: one `*`
@@ -92,27 +162,35 @@ export function createMdxJsxPlugins(mdx) {
     /**
      * Reports through `onError`, at import, what MDXEditor would otherwise lose or
      * break on without reporting it: `import`/`export` lines (its visitor for them
-     * is a no-op), elements `unsupportedJsx` rejects, and content with no visitor
-     * inside a JSX element or table, whose children nested editors import later,
-     * only logging a failure and writing partial children back on edit. It throws
-     * an error class MDXEditor's import reports; any other error crashes the editor.
+     * is a no-op), what `unsupportedJsx` and `rearrangedBlocks` reject, and content
+     * with no visitor inside a JSX element or table, whose children nested editors
+     * import later, only logging a failure and writing partial children back on
+     * edit. It throws an error class MDXEditor's import reports; any other error
+     * crashes the editor.
      */
     const roundTripGuardPlugin = realmPlugin({
         init(realm) {
             const guard = {
                 priority: 100,
-                testNode: (node) => node.type === ESM_NODE_TYPE || node.type === 'table' || isMdastJsxNode(node),
+                testNode: (node) => node.type === ESM_NODE_TYPE ||
+                    node.type === 'table' ||
+                    node.type === 'listItem' ||
+                    isMdastJsxNode(node),
                 visitNode({ mdastNode, descriptors, actions }) {
                     if (mdastNode.type === ESM_NODE_TYPE) {
                         throw new UnrecognizedMarkdownConstructError('import/export statements cannot be edited in the rich-text editor');
                     }
                     const reject = (node) => {
-                        const reason = unsupportedJsx(mdx, node);
+                        const reason = unsupportedJsx(mdx, node) ?? rearrangedBlocks(node);
                         if (reason !== null) {
                             throw new UnrecognizedMarkdownConstructError(`${reason} cannot be edited in the rich-text editor`);
                         }
                     };
                     reject(mdastNode);
+                    if (mdastNode.type === 'listItem') {
+                        actions.nextVisitor();
+                        return;
+                    }
                     const visitors = realm.getValue(importVisitors$).filter((visitor) => visitor !== guard);
                     const hasVisitor = (node) => visitors.some((visitor) => typeof visitor.testNode === 'string'
                         ? visitor.testNode === node.type
@@ -134,8 +212,14 @@ export function createMdxJsxPlugins(mdx) {
             realm.pub(addImportVisitor$, guard);
         },
     });
+    const blockExportPlugin = realmPlugin({
+        init(realm) {
+            realm.pub(addExportVisitor$, [quoteExportVisitor, paragraphOfBlocksExportVisitor]);
+        },
+    });
     return () => [
         jsxPlugin({ jsxComponentDescriptors: [catchAllJsxDescriptor] }),
         roundTripGuardPlugin(),
+        blockExportPlugin(),
     ];
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CANOPYCMS_VERSION = "0.0.68-int.103";
+export declare const CANOPYCMS_VERSION = "0.0.68-int.105";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by scripts/bump-version.mjs, its only writer. The package builds with plain
 // tsc (rootDir: src), so src/ cannot import ../package.json; version.test.ts keeps the two equal.
-export const CANOPYCMS_VERSION = '0.0.68-int.103';
+export const CANOPYCMS_VERSION = '0.0.68-int.105';

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "@codemirror/language, @lezer/highlight: workaround — @mdxeditor/editor uses cm6-theme-basic-light which peer-requires these but mdxeditor doesn't declare them as dependencies",
   "name": "canopycms",
-  "version": "0.0.68-int.103",
+  "version": "0.0.68-int.105",
   "description": "CanopyCMS core package: schema-driven content, branch-aware editing, and editor UI for Next.js.",
   "license": "MIT",
   "repository": {
@@ -114,7 +114,7 @@
     "@mantine/hooks": "^7.14.2",
     "@mantine/modals": "^7.14.2",
     "@mantine/notifications": "^7.14.2",
-    "@mdxeditor/editor": "^3.52.4",
+    "@mdxeditor/editor": "^4.3.2",
     "@octokit/auth-token": "^4.0.0",
     "@octokit/plugin-throttling": "^8.2.0",
     "@octokit/rest": "^20.0.2",