@byline/richtext-lexical 5.2.0 → 6.0.1

package/dist/scan/types.d.ts

@@ -0,0 +1,63 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/** What one richtext field accepts, as its resolved editor reports it. */
+export interface FieldCapabilities {
+    collectionPath: string;
+    /**
+     * Declaration path of the field, so one nested in a block or array is
+     * addressable — `content.photoBlock.caption`, not just `caption`.
+     * Stored values carry instance paths (`content.1.photoBlock.caption`);
+     * eliding the selectors yields this.
+     */
+    fieldPath: string;
+    /**
+     * Node types the field accepts, or `null` when they could not be
+     * measured.
+     *
+     * A field whose capabilities are unknown is NOT the same as a field
+     * with none. The scanner reports it as unmapped rather than treating
+     * its documents as clean, because reporting a document safe when it
+     * was never examined is the one failure an upgrade check must not
+     * have.
+     */
+    supportedTypes: string[] | null;
+    /** Why the capabilities could not be measured, when they could not. */
+    unresolvedReason?: string;
+}
+/**
+ * Field capabilities for a whole installation, produced where the client
+ * config can be loaded and consumed where the database can.
+ */
+export interface CapabilityManifest {
+    generatedAt: string;
+    fields: FieldCapabilities[];
+}
+/** One stored value that this field's current configuration cannot take as-is. */
+export interface ScanFinding {
+    collectionPath: string;
+    /** Declaration path — the manifest key this value was matched against. */
+    fieldPath: string;
+    /**
+     * Instance path as stored, when the caller knows it —
+     * `content.1.photoBlock.caption`. Two affected captions in one version
+     * share a declaration path and are told apart only by this.
+     */
+    instancePath?: string;
+    documentId: string;
+    versionId: string;
+    locale?: string;
+    /** Structures that will be converted when the field opens this value. */
+    adaptedTypes: string[];
+    /** Structures with no conversion — the field will open read-only. */
+    refusedTypes: string[];
+    /**
+     * Set when the field's capabilities were never measured, so this value
+     * was not examined. Neither adapted nor refused: unknown.
+     */
+    unmapped?: true;
+}

package/dist/scan/types.js

@@ -0,0 +1 @@
+export { };

package/dist/scan.d.ts

@@ -0,0 +1,25 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * Pre-upgrade scanning, without the editor.
+ *
+ * This entry is deliberately **runtime-free**: it carries the pure
+ * scanning logic and its types, and imports no React, no Lexical
+ * extension and no CSS. A Node script can therefore read it, which the
+ * root barrel makes impossible — importing that pulls the editor graph
+ * and fails on the first `.css` import.
+ *
+ * The other half, measuring what a field accepts, needs a DOM and lives
+ * on the root entry as `capabilitiesFor` / `capabilitiesFromEditor`.
+ * That split is the same boundary the manifest crosses: capabilities are
+ * measured in a browser, written to a file, and consumed here.
+ *
+ * See docs/09-admin-ui/04-richtext-capabilities.md.
+ */
+export { scanDocument, summarise } from './scan/scan-documents.js';
+export type { CapabilityManifest, FieldCapabilities, ScanFinding } from './scan/types.js';

package/dist/scan.js

@@ -0,0 +1 @@
+export { scanDocument, summarise } from "./scan/scan-documents.js";

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "type": "module",
   "license": "MPL-2.0",
-  "version": "5.2.0",
+  "version": "6.0.1",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -53,6 +53,12 @@
       "import": "./dist/server.js",
       "main": "./dist/server.js",
       "default": "./dist/server.js"
+    },
+    "./scan": {
+      "types": "./dist/scan.d.ts",
+      "import": "./dist/scan.js",
+      "main": "./dist/scan.js",
+      "default": "./dist/scan.js"
     }
   },
   "dependencies": {
@@ -72,10 +78,11 @@
     "clsx": "^2.1.1",
     "lexical": "0.50.0",
     "react-error-boundary": "^6.1.5",
-    "@byline/admin": "5.2.0",
-    "@byline/ui": "5.2.0",
-    "@byline/client": "5.2.0",
-    "@byline/core": "5.2.0"
+    "@byline/client": "6.0.1",
+    "@byline/i18n": "6.0.1",
+    "@byline/admin": "6.0.1",
+    "@byline/ui": "6.0.1",
+    "@byline/core": "6.0.1"
   },
   "peerDependencies": {
     "react": "^19.0.0",
@@ -83,6 +90,8 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.13",
+    "@lexical/clipboard": "0.50.0",
+    "@lexical/html": "0.50.0",
     "@rsbuild/plugin-react": "^2.1.0",
     "@rslib/core": "^1.0.0",
     "@types/node": "^26.5.1",

package/src/config.ts

@@ -13,7 +13,7 @@
  * registration factory (which dynamic-imports the editor runtime on first
  * mount), the config types, the built-in extension **names**, and the
  * light toolbar-authoring primitives — but NOT `RichTextField` /
- * `EditorField` / `Nodes` or the heavy *content* extension classes
+ * `EditorField` / `READABLE_NODES` or the heavy *content* extension classes
  * (Table, InlineImage, Admonition, …), all of which statically pull React
  * plugins, nodes, and the Lexical core. Import from here at registration
  * sites (e.g. an admin/admin config that you want to evaluate eagerly)

package/src/field/apply-value-plugin.tsx

@@ -1,12 +1,15 @@
 'use client'
 
 import type * as React from 'react'
-import { useEffect, useRef } from 'react'
+import { useLayoutEffect, useRef } from 'react'
 
 import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'
 import type { SerializedEditorState } from 'lexical'
 
+import { registeredNodeTypes } from './capabilities/registered-node-types'
 import { APPLY_VALUE_TAG } from './constants'
+import { useNormalizationStatus } from './normalize/normalization-status'
+import { normalizeValue } from './normalize/normalize-value'
 import { hashSerializedState } from './utils/hashSerializedState'
 
 export function ApplyValuePlugin({
@@ -23,16 +26,31 @@ export function ApplyValuePlugin({
   hasNormalizedBaselineRef: React.RefObject<boolean>
 }): React.JSX.Element | null {
   const [editor] = useLexicalComposerContext()
+  const { setStatus } = useNormalizationStatus()
   const lastAppliedHashRef = useRef<string | undefined>(undefined)
+  // True while the surface is showing the read-only refusal notice.
+  const isRefusedRef = useRef(false)
 
   const cancelWaiterRef = useRef<() => void>(undefined)
 
-  useEffect(() => {
+  // A layout effect, not a passive one: this is the ONLY path by which a
+  // stored value reaches the editor — the root extension deliberately
+  // carries no `$initialEditorState` — so applying before paint avoids
+  // showing an empty field first.
+  useLayoutEffect(() => {
     if (value == null) return
 
     const nextRawHash = incomingHash
 
-    if (nextRawHash === lastEmittedHashRef.current) {
+    // Both shortcuts below assume the editor already holds this value and
+    // that there is therefore nothing to do. Neither holds while refused:
+    // a refusal applies nothing, so the editor holds whatever preceded it
+    // and the notice is still up. Taking either shortcut would leave the
+    // field stranded — including via the echo path, where the value being
+    // returned to is one the editor itself last emitted.
+    const refused = isRefusedRef.current
+
+    if (!refused && nextRawHash === lastEmittedHashRef.current) {
       if (hasNormalizedBaselineRef.current !== true) {
         hasNormalizedBaselineRef.current = true
         if (cancelWaiterRef.current) {
@@ -43,7 +61,7 @@ export function ApplyValuePlugin({
       return
     }
 
-    if (nextRawHash === lastAppliedHashRef.current) {
+    if (!refused && nextRawHash === lastAppliedHashRef.current) {
       // If the incoming value matches what we last applied, we assume the previous
       // waiter (if any) is still running or has completed.
       // We do NOT want to cancel it just because of a re-render.
@@ -59,7 +77,52 @@ export function ApplyValuePlugin({
 
     hasNormalizedBaselineRef.current = false
 
-    const nextState = editor.parseEditorState(value)
+    // Adapt the stored value to what this editor actually accepts.
+    // Lexical throws on an unregistered type and loses the text, so a
+    // field whose configuration narrowed since the document was written
+    // would otherwise open blank and erroring.
+    const normalized = normalizeValue(value, registeredNodeTypes(editor))
+
+    if (normalized.status === 'refused') {
+      // No safe conversion exists — an image's media relation and its
+      // nested-editor caption survive no structural rewrite. Leave the
+      // editor as it stands and let the surface render read-only rather
+      // than silently discarding what the document holds.
+      setStatus({ kind: 'refused', unsupportedTypes: normalized.unsupportedTypes })
+
+      // Forget the last applied value and remember that we are refused,
+      // so neither shortcut above can swallow the return to it. Toggling
+      // between a refused value and a valid one is the first thing a
+      // reader does, and the value returned to may be one the editor
+      // itself emitted.
+      lastAppliedHashRef.current = undefined
+      isRefusedRef.current = true
+
+      // Leave the baseline UNESTABLISHED. It is the only thing
+      // suppressing emission in `editor-component.tsx` — the gate there
+      // is `value != null && baseline !== true` — and while refused the
+      // editor does NOT hold the stored value. Setting it true would
+      // open that gate on a field whose content is not the document's:
+      // an emission deferred through `requestIdleCallback` before the
+      // refusal would then land after it and write the PREVIOUS
+      // document's text over the refused one, which is exactly the loss
+      // refusal exists to prevent. Recovery does not need it — a later
+      // valid value re-enters the apply path and its waiter sets the
+      // baseline itself.
+      hasNormalizedBaselineRef.current = false
+      return
+    }
+
+    isRefusedRef.current = false
+    setStatus(
+      normalized.status === 'adapted'
+        ? { kind: 'adapted', convertedTypes: normalized.convertedTypes }
+        : { kind: 'ok' }
+    )
+
+    const nextState = editor.parseEditorState(
+      normalized.status === 'adapted' ? JSON.stringify(normalized.value) : value
+    )
 
     // Must NOT be wrapped in editor.update — setEditorState defers its commit
     // when called inside an active update, leaving selection/node references
@@ -67,6 +130,8 @@ export function ApplyValuePlugin({
     // errors ("Expected node with key N to exist") on the very next selection
     // change. setEditorState applies the tag itself.
     editor.setEditorState(nextState, { tag: APPLY_VALUE_TAG })
+    // Keyed to the ORIGINAL value's hash, never the adapted one, so an
+    // adapted document does not read as a change on every mount.
     lastAppliedHashRef.current = nextRawHash
 
     let cancelled = false
@@ -98,6 +163,7 @@ export function ApplyValuePlugin({
     lastEmittedHashRef,
     normalizedIncomingHashRef,
     hasNormalizedBaselineRef,
+    setStatus,
   ])
 
   return null

package/src/field/capabilities/filter-transformers.test.tsx

@@ -0,0 +1,71 @@
+import { $convertFromMarkdownString, registerMarkdownShortcuts } from '@lexical/markdown'
+import { $getRoot } from 'lexical'
+import { describe, expect, it } from 'vitest'
+
+import { ADMONITION_BODY_TRANSFORMERS, BYLINE_TRANSFORMERS } from '../markdown/transformers'
+import { buildFullEditor, buildRestrictedEditor } from '../test-support/build-test-editor'
+import { transformersFor } from './filter-transformers'
+
+describe('transformersFor', () => {
+  it('lets Markdown shortcuts register in a restricted editor', () => {
+    const editor = buildRestrictedEditor()
+    expect(() => {
+      registerMarkdownShortcuts(editor, transformersFor(editor, BYLINE_TRANSFORMERS))
+    }).not.toThrow()
+    editor.dispose()
+  })
+
+  it('throws without the filter, which is why it exists', () => {
+    const editor = buildRestrictedEditor()
+    expect(() => {
+      registerMarkdownShortcuts(editor, [...BYLINE_TRANSFORMERS])
+    }).toThrow(/missing dependency/)
+    editor.dispose()
+  })
+
+  it('keeps every transformer when nothing is removed', () => {
+    const editor = buildFullEditor()
+    expect(transformersFor(editor, BYLINE_TRANSFORMERS)).toHaveLength(BYLINE_TRANSFORMERS.length)
+    editor.dispose()
+  })
+
+  it('drops a transformer whose node is unregistered', () => {
+    const editor = buildRestrictedEditor()
+    expect(transformersFor(editor, BYLINE_TRANSFORMERS).length).toBeLessThan(
+      BYLINE_TRANSFORMERS.length
+    )
+    editor.dispose()
+  })
+
+  it('survives a Markdown import in a restricted editor', () => {
+    const editor = buildRestrictedEditor()
+    const active = transformersFor(editor, BYLINE_TRANSFORMERS)
+    expect(() => {
+      editor.update(
+        () => {
+          $convertFromMarkdownString(
+            '# heading\n\n| a | b |\n| - | - |\n\nplain text',
+            active,
+            undefined,
+            true
+          )
+        },
+        { discrete: true }
+      )
+    }).not.toThrow()
+    let text = ''
+    editor.read(() => {
+      text = $getRoot().getTextContent()
+    })
+    expect(text).toContain('plain text')
+    editor.dispose()
+  })
+
+  it('filters the admonition body list, which carries LINK', () => {
+    const editor = buildRestrictedEditor()
+    expect(transformersFor(editor, ADMONITION_BODY_TRANSFORMERS).length).toBeLessThan(
+      ADMONITION_BODY_TRANSFORMERS.length
+    )
+    editor.dispose()
+  })
+})

package/src/field/capabilities/filter-transformers.ts

@@ -0,0 +1,42 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import type { Transformer } from '@lexical/markdown'
+import type { LexicalEditor } from 'lexical'
+
+/**
+ * The transformers that can safely be used with this editor.
+ *
+ * Markdown is a second route into node creation, and it fails harder
+ * than paste does. `registerMarkdownShortcuts` throws when a transformer
+ * names a node class the editor has not registered, and it throws for
+ * the whole pipeline rather than skipping that one transformer — so a
+ * field with the table extension removed would lose Markdown entirely,
+ * not just tables. The same applies to every `$convertFromMarkdownString`
+ * call, which creates nodes directly.
+ *
+ * The membership test is `editor.hasNode`, which is exactly what
+ * `registerMarkdownShortcuts` uses for its own guard, so this filter
+ * cannot disagree with the check it exists to satisfy.
+ *
+ * Takes the list as a parameter rather than importing it: the Markdown
+ * module imports this one, so reaching back for `BYLINE_TRANSFORMERS`
+ * here would be a cycle.
+ */
+export function transformersFor(
+  editor: LexicalEditor,
+  transformers: ReadonlyArray<Transformer>
+): Array<Transformer> {
+  return transformers.filter((transformer) => {
+    // `text-format` transformers act on TextNode formats and declare no
+    // dependencies; they are always safe.
+    const dependencies = 'dependencies' in transformer ? transformer.dependencies : undefined
+    if (dependencies == null) return true
+    return dependencies.every((klass) => editor.hasNode(klass))
+  })
+}

package/src/field/capabilities/markdown-behaviour.test.tsx

@@ -0,0 +1,188 @@
+import { $convertFromMarkdownString, registerMarkdownShortcuts } from '@lexical/markdown'
+import {
+  $createParagraphNode,
+  $getRoot,
+  $getSelection,
+  $isRangeSelection,
+  type LexicalEditor,
+} from 'lexical'
+import { describe, expect, it } from 'vitest'
+
+import { builtInExtensions } from '../config/built-in-extension-names'
+import { ADMONITION_BODY_TRANSFORMERS, BYLINE_TRANSFORMERS } from '../markdown/transformers'
+import { buildFullEditor, buildRestrictedEditor } from '../test-support/build-test-editor'
+import { transformersFor } from './filter-transformers'
+
+/** Block types and full text of the editor's current state. */
+function snapshot(editor: LexicalEditor): { types: string[]; text: string } {
+  let types: string[] = []
+  let text = ''
+  editor.read(() => {
+    types = $getRoot()
+      .getChildren()
+      .map((node) => node.getType())
+    text = $getRoot().getTextContent()
+  })
+  return { types, text }
+}
+
+function importMarkdown(editor: LexicalEditor, markdown: string): void {
+  editor.update(
+    () => {
+      $convertFromMarkdownString(
+        markdown,
+        transformersFor(editor, BYLINE_TRANSFORMERS),
+        undefined,
+        true
+      )
+    },
+    { discrete: true }
+  )
+}
+
+describe('Markdown import produces no disabled structures', () => {
+  it('keeps heading text as a paragraph when headings are removed', () => {
+    const editor = buildRestrictedEditor([builtInExtensions.Heading])
+    importMarkdown(editor, '# Heading text\n\nBody text')
+    const result = snapshot(editor)
+    expect(result.types).not.toContain('heading')
+    expect(result.text).toContain('Heading text')
+    expect(result.text).toContain('Body text')
+    editor.dispose()
+  })
+
+  it('still produces headings with the default configuration', () => {
+    const editor = buildFullEditor()
+    importMarkdown(editor, '# Heading text')
+    expect(snapshot(editor).types).toContain('heading')
+    editor.dispose()
+  })
+
+  it('keeps table cell text as paragraphs when tables are removed', () => {
+    const editor = buildRestrictedEditor([builtInExtensions.Table])
+    importMarkdown(editor, '| a | b |\n| - | - |\n| one | two |')
+    const result = snapshot(editor)
+    expect(result.types).not.toContain('table')
+    expect(result.text).toContain('one')
+    expect(result.text).toContain('two')
+    editor.dispose()
+  })
+
+  it('keeps list item text when lists are removed', () => {
+    const editor = buildRestrictedEditor([builtInExtensions.List, builtInExtensions.CheckList])
+    importMarkdown(editor, '- item one\n- item two')
+    const result = snapshot(editor)
+    expect(result.types).not.toContain('list')
+    expect(result.text).toContain('item one')
+    expect(result.text).toContain('item two')
+    editor.dispose()
+  })
+
+  it('keeps link text when links are removed', () => {
+    const editor = buildRestrictedEditor([builtInExtensions.Link])
+    importMarkdown(editor, 'see [link text](https://example.com) here')
+    const result = snapshot(editor)
+    expect(JSON.stringify(editor.getEditorState().toJSON())).not.toContain('"type":"link"')
+    expect(result.text).toContain('link text')
+    editor.dispose()
+  })
+})
+
+describe('nested Markdown imports follow the same rule', () => {
+  it('imports a table cell with headings and links removed', () => {
+    // Tables are KEPT here: the point is that the cell's own nested
+    // $convertFromMarkdownString must be filtered too, so the table
+    // survives while the unsupported link inside it degrades.
+    const editor = buildRestrictedEditor([builtInExtensions.Heading, builtInExtensions.Link])
+    expect(() => {
+      importMarkdown(editor, '| a | b |\n| - | - |\n| [link text](https://e.com) | plain |')
+    }).not.toThrow()
+    const result = snapshot(editor)
+    const json = JSON.stringify(editor.getEditorState().toJSON())
+
+    expect(result.types).toContain('table')
+    expect(json).not.toContain('"type":"link"')
+    // The degraded cell keeps its text, not just its untouched neighbour.
+    expect(result.text).toContain('link text')
+    expect(result.text).toContain('plain')
+    editor.dispose()
+  })
+
+  it('imports an admonition body with links removed', () => {
+    // ADMONITION_BODY_TRANSFORMERS carries LINK, so this is the case that
+    // breaks without filtering.
+    //
+    // The directive syntax is `:::type[Title]` — the start regex is
+    // /^:::(note|tip|warning|danger)(?:\[([^\]]*)\])?\s*$/, so
+    // `:::note Title` silently fails to match and no admonition is ever
+    // created. Assert the node exists so this fixture cannot rot back
+    // into testing nothing.
+    const editor = buildRestrictedEditor([builtInExtensions.Link])
+    const active = transformersFor(editor, ADMONITION_BODY_TRANSFORMERS)
+    expect(active.length).toBeLessThan(ADMONITION_BODY_TRANSFORMERS.length)
+
+    expect(() => {
+      importMarkdown(editor, ':::note[Note title]\nbody with [a link](https://e.com)\n:::')
+    }).not.toThrow()
+
+    const result = snapshot(editor)
+    const json = JSON.stringify(editor.getEditorState().toJSON())
+    expect(result.types).toContain('admonition')
+    expect(json).not.toContain('"type":"link"')
+    expect(result.text).toContain('body with')
+    expect(result.text).toContain('a link')
+    editor.dispose()
+  })
+})
+
+/** Type `input` at the caret, the way the shortcut listener sees it. */
+function typeText(editor: LexicalEditor, input: string): void {
+  editor.update(
+    () => {
+      $getRoot().clear().append($createParagraphNode())
+      $getRoot().selectEnd()
+    },
+    { discrete: true }
+  )
+  for (const char of input) {
+    editor.update(
+      () => {
+        const selection = $getSelection()
+        if ($isRangeSelection(selection)) selection.insertText(char)
+      },
+      { discrete: true }
+    )
+  }
+}
+
+describe('keyboard Markdown shortcuts', () => {
+  it('POSITIVE CONTROL: "# " creates a heading in the default editor', () => {
+    // Without this the negative case below could pass simply because the
+    // typing simulation never triggers a shortcut at all.
+    const editor = buildFullEditor()
+    registerMarkdownShortcuts(editor, transformersFor(editor, BYLINE_TRANSFORMERS))
+    typeText(editor, '# Title')
+    expect(snapshot(editor).types).toEqual(['heading'])
+    editor.dispose()
+  })
+
+  it('"# " creates no heading when headings are removed, and keeps the text', () => {
+    const editor = buildRestrictedEditor([builtInExtensions.Heading])
+    registerMarkdownShortcuts(editor, transformersFor(editor, BYLINE_TRANSFORMERS))
+    typeText(editor, '# Title')
+    const result = snapshot(editor)
+    expect(result.types).toEqual(['paragraph'])
+    expect(result.text).toContain('Title')
+    editor.dispose()
+  })
+
+  it('"- " creates no list when lists are removed', () => {
+    const editor = buildRestrictedEditor([builtInExtensions.List, builtInExtensions.CheckList])
+    registerMarkdownShortcuts(editor, transformersFor(editor, BYLINE_TRANSFORMERS))
+    typeText(editor, '- item')
+    const result = snapshot(editor)
+    expect(result.types).toEqual(['paragraph'])
+    expect(result.text).toContain('item')
+    editor.dispose()
+  })
+})

package/src/field/capabilities/no-blanket-registration.test.tsx

@@ -0,0 +1,86 @@
+import { $generateNodesFromDOM } from '@lexical/html'
+import { $isElementNode, type LexicalEditor, type LexicalNode } from 'lexical'
+import { describe, expect, it } from 'vitest'
+
+import { $isLinkNode } from '../extensions/link'
+import {
+  buildFullEditor,
+  buildRestrictedEditor,
+  parseHtmlToTypes,
+} from '../test-support/build-test-editor'
+import { supportsNodeType } from './registered-node-types'
+
+/**
+ * Import `html` and report what the tree contains. Node methods only
+ * work inside an editor context, so everything is extracted in here
+ * rather than returning live nodes to the caller.
+ */
+function importedTree(editor: LexicalEditor, html: string): { linkUrls: string[]; text: string } {
+  const dom = new DOMParser().parseFromString(html, 'text/html')
+  const linkUrls: string[] = []
+  let text = ''
+  editor.update(
+    () => {
+      const walk = (nodes: LexicalNode[]) => {
+        for (const node of nodes) {
+          if ($isLinkNode(node)) linkUrls.push(node.getAttributes().url ?? '')
+          if ($isElementNode(node)) walk(node.getChildren())
+        }
+      }
+      const roots = $generateNodesFromDOM(editor, dom)
+      walk(roots)
+      text = roots.map((node) => node.getTextContent()).join('')
+    },
+    { discrete: true }
+  )
+  return { linkUrls, text }
+}
+
+describe('node registration follows the extensions list', () => {
+  it('registers nothing structural in a fully stripped editor', () => {
+    const editor = buildRestrictedEditor()
+    for (const type of ['heading', 'quote', 'table', 'link', 'list', 'code']) {
+      expect(supportsNodeType(editor, type), `${type} must not be registered`).toBe(false)
+    }
+    editor.dispose()
+  })
+
+  it('degrades every structural paste and keeps the text', () => {
+    const editor = buildRestrictedEditor()
+    const cases: Array<[string, string, string]> = [
+      ['<h1>Pasted title</h1>', 'paragraph', 'Pasted title'],
+      ['<blockquote>Quoted words</blockquote>', 'paragraph', 'Quoted words'],
+      ['<ul><li>one</li></ul>', 'paragraph', 'one'],
+      ['<pre>const x = 1</pre>', 'paragraph', 'const x = 1'],
+    ]
+    for (const [html, type, text] of cases) {
+      const result = parseHtmlToTypes(editor, html)
+      expect(result.types, html).toEqual([type])
+      expect(result.text, html).toContain(text)
+    }
+    editor.dispose()
+  })
+
+  it('does not regress the full default set', () => {
+    const editor = buildFullEditor()
+    expect(parseHtmlToTypes(editor, '<h1>Title</h1>').types).toEqual(['heading'])
+    expect(parseHtmlToTypes(editor, '<ul><li>one</li></ul>').types).toEqual(['list'])
+    expect(parseHtmlToTypes(editor, '<table><tr><td>cell</td></tr></table>').types).toEqual([
+      'table',
+    ])
+    // Inspect the link node itself, not the surrounding text: text
+    // survives even when the link is dropped, so a text assertion would
+    // pass in exactly the case this is meant to catch.
+    const tree = importedTree(editor, '<p>see <a href="https://x.com/a">link</a></p>')
+    expect(tree.linkUrls).toEqual(['https://x.com/a'])
+    editor.dispose()
+  })
+
+  it('drops the link node, but keeps its text, when the link extension is removed', () => {
+    const editor = buildRestrictedEditor()
+    const tree = importedTree(editor, '<p>see <a href="https://x.com/a">link</a></p>')
+    expect(tree.linkUrls).toEqual([])
+    expect(tree.text).toContain('link')
+    editor.dispose()
+  })
+})