@pilotiq/tiptap 3.10.5 → 3.10.6

package/boost/skills/pilotiq-tiptap-blocks/rules/toolbar-and-extensibility.md

@@ -0,0 +1,161 @@
+# Toolbar & Extensibility
+
+Three things in scope here: customizing the always-on toolbar, opting into non-default block primitives (`details`, `grid`, `lead`, `small`), and the pitfalls that bite when you extend the editor beyond the defaults.
+
+## Default toolbar layout
+
+```ts
+[
+  ['bold', 'italic', 'underline', 'strike', 'subscript', 'superscript', 'link'],
+  ['h2', 'h3'],
+  ['alignStart', 'alignCenter', 'alignEnd'],
+  ['blockquote', 'codeBlock', 'bulletList', 'orderedList'],
+  ['undo', 'redo'],
+]
+```
+
+Each inner array is a visually-separated group in the rendered toolbar. The selection-anchored floating toolbar (separate surface) shows a smaller subset on text selection — by default `bold / italic / link / clearFormatting`.
+
+## Three customization styles
+
+Use whichever matches your intent:
+
+### Replace the whole layout
+
+```ts
+RichTextField.make('body').toolbarButtons([
+  ['bold', 'italic', 'underline', 'strike', 'link'],
+  ['h2', 'h3'],
+  ['textColor', 'highlight'],
+  ['bulletList', 'orderedList'],
+  ['attachFiles', 'table', 'details', 'grid', 'gridDelete'],
+  ['undo', 'redo'],
+])
+```
+
+### Augment the defaults
+
+```ts
+RichTextField.make('body')
+  .enableToolbarButtons(['lead', 'small'])      // append to last group
+  .disableToolbarButtons(['table'])             // drop from every group
+```
+
+`enableToolbarButtons` always appends to the last group; reach for `toolbarButtons` if you need ids in a specific group.
+
+### Hide chrome entirely
+
+```ts
+RichTextField.make('body')
+  .toolbar(false)                                // hide the always-on top toolbar
+  .floatingToolbar(false)                        // disable the selection-anchored quick toolbar
+  .slashCommand(false)                           // disable the slash menu
+```
+
+All three are independent. A minimal-distraction config: `.toolbar(false).floatingToolbar(false)` but keep the slash menu so the user still has a way to insert blocks.
+
+## Recognized button ids
+
+```
+Inline marks   bold italic underline strike subscript superscript code lead small
+Headings       paragraph h1 h2 h3 h4 h5 h6
+Alignment      alignStart alignCenter alignEnd alignJustify
+Block prims    blockquote codeBlock bulletList orderedList horizontalRule
+Style          textColor highlight clearFormatting
+Files          attachFiles
+Tables         table tableAddColumnBefore tableAddColumnAfter tableDeleteColumn
+               tableAddRowBefore tableAddRowAfter tableDeleteRow
+               tableMergeCells tableSplitCell tableDelete
+               tableToggleHeaderRow tableToggleHeaderCell
+Disclosure     details
+Layout         grid gridDelete
+Editing        link undo redo
+```
+
+**Unknown ids are silently dropped.** The union is forward-compatible — adding a new id later won't break existing field configs that referenced a typo or pre-release id.
+
+## Opt-in primitives (not in default toolbar)
+
+These nodes ship but aren't surfaced unless you explicitly add their toolbar id (or they appear in the slash menu via the same mechanism). The renderer (`renderRichTextToHtml`) serializes them whether or not the toolbar exposes them — so a document with `details` content created elsewhere still round-trips correctly even if the local field config doesn't include the button.
+
+### `lead` / `small` size marks
+
+Two inline marks for paragraph-style size variants:
+
+- **`lead`** renders as `<span class="lead">…</span>`. Consumer owns the `.lead` CSS — there's no built-in stylesheet (`@pilotiq/pilotiq`'s typography preset typically has one; check yours).
+- **`small`** renders as semantic `<small>…</small>`.
+
+Surfaced as toolbar button ids `'lead'` / `'small'` and slash-menu entries under the **Style** group. Mirror the editor output in your own server-side render (`renderRichTextToHtml` does this correctly).
+
+### `details` (collapsible disclosure)
+
+A node trio (`details` / `detailsSummary` / `detailsContent`) wired from `@tiptap/extension-details@3.22.4` — v3 consolidated the three classes into a single peer dep (the `-summary` / `-content` child packages don't exist on the v3 line).
+
+- Toolbar id: `'details'` (opt-in)
+- Slash entry under the **Insert** group
+- Render emits standard `<details><summary>…</summary>…</details>` HTML
+- Open / closed state round-trips via the node's `open: boolean` attr; the renderer adds the platform `open` attribute when `attrs.open === true`
+
+### `grid` / `gridDelete` (2-column / 3-column layout)
+
+A node pair (`grid` + `gridColumn`) defined inline under `extensions/GridExtension.ts` — Tiptap doesn't ship a first-party grid extension. Schema constrains `grid` to `gridColumn{2,3}` so the user can't construct a 1-col or 4+-col grid through any path (toolbar / slash / paste).
+
+- Toolbar ids: `'grid'` (insert; defaults to 2 columns when clicked) + `'gridDelete'` (unwrap the enclosing grid)
+- Slash entries: `Two-column grid`, `Three-column grid` under the **Insert** group
+- Render emits `<div class="pilotiq-grid pilotiq-grid-cols-N">…<div>col</div>…</div>` — consumer owns the CSS (same posture as `lead` / `small`)
+- Out-of-range column counts (anything other than 2 or 3) clamp to 2 in both editor `parseHTML` and renderer. `clampGridColumns(value)` is exported from `GridExtension.ts` for tests; the render-side has its own micro-helper to keep `render.ts` Tiptap-runtime-free.
+
+## File attachments (`attachFiles` button)
+
+The `attachFiles` toolbar button uploads via the panel's registered `UploadAdapter`. Per-field setters:
+
+```ts
+RichTextField.make('body')
+  .fileAttachmentsAcceptedFileTypes(['image/*', 'application/pdf'])
+  .fileAttachmentsMaxSize(5 * 1024 * 1024)       // 5 MB cap
+  .fileAttachmentsDirectory('articles')          // sub-directory hint
+  .fileAttachmentsVisibility('public')           // adapter-dependent
+  .resizableImages()                              // drag-handle resize on images
+```
+
+The upload route enforces `maxSize` server-side — a tampered client can't bypass. **Without an `UploadAdapter` registered on the panel, the `attachFiles` button silently hides.** Wire one with `Pilotiq.uploads({ adapter: localUpload({...}) })` (or any adapter from `@pilotiq/media`, S3, R2, etc.).
+
+This auto-hide behavior is intentional — see [[feedback-pilotiq-panel-module-client-safe]]: the `attachFiles` button checks `RenderContext.hasUploadAdapter` at meta-resolve time. The field renders correctly with the button absent rather than showing a broken control.
+
+## Drag handle — three-step drop dance
+
+The framework ships per-block drag handles in `extensions/DragHandleExtension.ts`. If you write a **custom block with external drag UX** (not the default per-block handle), the drop handler must do three things or you get the dreaded snap-back-to-origin bug:
+
+1. **`setNodeSelection(pos)`** on the editor view to select the drop target
+2. **Set `view.dragging = { slice, move: true }`** before the drop dispatches
+3. **`serializeForClipboard(view, slice)`** so ProseMirror has the serialized content to insert
+
+Missing any one of the three causes the dragged node to disappear from its drop position and snap back to where it came from. The framework's built-in handle does all three correctly; custom drag implementations (e.g. an external palette dragging onto the canvas) must too. See [[feedback-tiptap-drag-handle-pm-dragging]] for the full repro.
+
+## Module identity — dedupe Tiptap peers
+
+`@tiptap/core` and `@tiptap/pm` keep state on module-level singletons. **Multiple copies break the editor** (silent: `instanceof` checks fail, schema lookups miss, NodeViews don't mount). Add them to `resolve.dedupe` in your Vite config:
+
+```ts
+// vite.config.ts
+export default defineConfig({
+  resolve: {
+    dedupe: ['@tiptap/core', '@tiptap/pm', '@tiptap/react'],
+  },
+  // …
+})
+```
+
+This is unrelated to pilotiq's general `optimizeDeps.exclude: ['@pilotiq/pilotiq']` rule (see [[feedback-vite-optimizedeps-exclude]]) — both can be needed simultaneously.
+
+## Toolbar-driven slash entries
+
+The slash menu's **Style** and **Format** groups derive from the *active* toolbar buttons. If you hide `textColor` from the toolbar via `.disableToolbarButtons(['textColor'])`, it also disappears from the slash menu. Same for alignment — if no `alignStart` / `alignCenter` / `alignEnd` button is active, the Format group is empty and collapses.
+
+The **Insert** group is the inverse: it always shows the core insertable nodes regardless of toolbar config (paragraph, headings, lists, code block, blockquote, horizontal rule). Opt-in primitives (`details`, `grid`) only appear in the Insert group when their toolbar id is in the active config.
+
+## See also
+
+- `custom-blocks.md` — `Block.make(...)` user blocks appear in the slash menu after the framework groups.
+- `slash-menu-and-mentions.md` — how merge tags and mentions interact with the slash menu surface.
+- [[feedback-tiptap-block-name-collision]] — the `'block'` name pitfall (also covered in `custom-blocks.md`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pilotiq/tiptap",
-  "version": "3.10.5",
+  "version": "3.10.6",
   "description": "Tiptap rich-text editor adapter for @pilotiq/pilotiq — slash menu, draggable blocks, custom-block API",
   "license": "MIT",
   "repository": {
@@ -12,7 +12,8 @@
   "type": "module",
   "files": [
     "dist",
-    "src"
+    "boost",
+    "CHANGELOG.md"
   ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -89,7 +90,7 @@
     "react-dom": "^19",
     "tiptap-markdown": "^0.9",
     "typescript": "^5",
-    "@pilotiq/pilotiq": "^0.24.1"
+    "@pilotiq/pilotiq": "^0.24.2"
   },
   "author": "Suleiman Shahbari",
   "scripts": {

package/src/Block.ts

@@ -1,75 +0,0 @@
-import type { Field } from '@pilotiq/pilotiq'
-import type { FieldMeta } from '@pilotiq/pilotiq'
-
-/**
- * JSON-serializable block descriptor sent to the editor renderer.
- */
-export interface BlockMeta {
-  name:   string
-  label:  string
-  icon:   string | undefined
-  schema: FieldMeta[]
-}
-
-/**
- * Builder for a custom block type that can be inserted into a `RichTextField`
- * via the slash menu and rendered inline as an editable form.
- *
- * @example
- * ```ts
- * Block.make('callout')
- *   .label('Callout')
- *   .icon('💡')
- *   .schema([
- *     TextField.make('title'),
- *     TextareaField.make('content').required(),
- *   ])
- * ```
- */
-export class Block {
-  private _name:   string
-  private _label?: string
-  private _icon?:  string
-  private _schema: Field[] = []
-
-  protected constructor(name: string) {
-    this._name = name
-  }
-
-  static make(name: string): Block {
-    return new Block(name)
-  }
-
-  /** Display label shown in the slash menu. Defaults to the block name. */
-  label(label: string): this {
-    this._label = label
-    return this
-  }
-
-  /** Emoji or icon string shown in the slash menu. */
-  icon(icon: string): this {
-    this._icon = icon
-    return this
-  }
-
-  /** Fields rendered inline when this block is inserted. */
-  schema(fields: Field[]): this {
-    this._schema = fields
-    return this
-  }
-
-  getName():   string  { return this._name }
-  getLabel():  string  { return this._label ?? this._name }
-  getIcon():   string | undefined { return this._icon }
-  getSchema(): readonly Field[] { return this._schema }
-
-  /** @internal */
-  toMeta(): BlockMeta {
-    return {
-      name:   this._name,
-      label:  this._label ?? this._name,
-      icon:   this._icon,
-      schema: this._schema.map((f) => f.toMeta() as FieldMeta),
-    }
-  }
-}

package/src/MentionProvider.ts

@@ -1,153 +0,0 @@
-/**
- * Static menu item surfaced by a {@link MentionProvider}. `id` is the wire
- * identifier that survives serialization; `label` is what the editor shows
- * after the trigger char (`@Sleman`). `group` is purely cosmetic — the menu
- * uses it to bucket items under headings.
- */
-export interface MentionItem {
-  id:     string
-  label:  string
-  group?: string
-}
-
-/** Wire-side shape of a {@link MentionProvider}. */
-export interface MentionProviderMeta {
-  trigger: string
-  items:   MentionItem[]
-  /** Set when the provider is backed by an `itemsUsing(fn)` resolver — the
-   *  client fetches items from the field's `mentionsUrl` instead of using
-   *  the (empty) inlined list. */
-  async?:  boolean
-}
-
-/**
- * Context handed to `MentionProvider.itemsUsing(fn)` resolvers. Mirrors the
- * subset of {@link RenderContext} the route handler can re-derive at request
- * time — `user` from `Pilotiq.user(req=>…)`, `record` for edit-mode forms,
- * and the raw `request` for adapters that need cookie / header access.
- */
-export interface MentionResolverContext {
-  user?:    unknown
-  record?:  unknown
-  request?: unknown
-}
-
-export type MentionItemsResolver = (
-  query: string,
-  ctx:   MentionResolverContext,
-) => MentionItem[] | Promise<MentionItem[]>
-
-/**
- * Builder for a single mention provider — the trigger character (`@` /
- * `#` / …) and the items the popover offers when the user types it.
- *
- * Two shapes:
- *   - `MentionProvider.make('@').items([...])` — static items declared at
- *     form-build time, inlined into the field meta.
- *   - `MentionProvider.make('@').itemsUsing(async (query, ctx) => […])` —
- *     async resolver. The client fetches every keystroke; the server runs
- *     the user fn and returns the matched items. `items` and `itemsUsing`
- *     are mutually exclusive — last call wins, with a warning when both
- *     have been set.
- *
- * Read-time label resolution still works through `renderRichTextToHtml(
- * content, { resolveMention })` for cases where the cached label has gone
- * stale.
- *
- * @example Static items
- * ```ts
- * MentionProvider.make('@').items([
- *   { id: 'sleman', label: 'Sleman' },
- *   { id: 'alex',   label: 'Alex'   },
- * ])
- * ```
- *
- * @example Async items
- * ```ts
- * MentionProvider.make('@').itemsUsing(async (query) => {
- *   const users = await db.users.search(query, { limit: 10 })
- *   return users.map(u => ({ id: u.id, label: u.name }))
- * })
- * ```
- */
-export class MentionProvider {
-  private _trigger: string
-  private _items:   MentionItem[] = []
-  private _itemsUsing?: MentionItemsResolver
-
-  protected constructor(trigger: string) {
-    if (typeof trigger !== 'string' || trigger.length !== 1) {
-      throw new Error(`MentionProvider trigger must be a single character (got ${JSON.stringify(trigger)})`)
-    }
-    this._trigger = trigger
-  }
-
-  static make(trigger: string): MentionProvider {
-    return new MentionProvider(trigger)
-  }
-
-  /** Replace the static item list. Mutually exclusive with `itemsUsing()`. */
-  items(items: MentionItem[]): this {
-    if (this._itemsUsing !== undefined) {
-      console.warn(
-        `[pilotiq/tiptap] MentionProvider('${this._trigger}'): items() called after ` +
-        `itemsUsing(). The static list now wins; clear itemsUsing first to avoid surprise.`,
-      )
-      delete this._itemsUsing
-    }
-    this._items = items
-    return this
-  }
-
-  /**
-   * Install an async resolver. Called every keystroke with the current
-   * query (the text after the trigger char) and a `MentionResolverContext`.
-   *
-   * Mutually exclusive with `items()` — the last call wins; a warning fires
-   * when the previously-set static items are dropped silently.
-   */
-  itemsUsing(fn: MentionItemsResolver): this {
-    if (this._items.length > 0) {
-      console.warn(
-        `[pilotiq/tiptap] MentionProvider('${this._trigger}'): itemsUsing() called after ` +
-        `items(). The async resolver now wins; the static items array will be ignored.`,
-      )
-      this._items = []
-    }
-    this._itemsUsing = fn
-    return this
-  }
-
-  getTrigger(): string { return this._trigger }
-  getItems():   readonly MentionItem[] { return this._items }
-  isAsync():    boolean { return this._itemsUsing !== undefined }
-
-  /**
-   * Run the resolver — `itemsUsing(fn)` when set, otherwise the cached
-   * static list. Wraps non-array returns in `[]` so a misbehaving
-   * resolver doesn't crash the route handler.
-   *
-   * Synchronous resolvers are awaited the same way as async ones; the
-   * single code path keeps the call-site cheap.
-   */
-  async runResolver(query: string, ctx: MentionResolverContext): Promise<MentionItem[]> {
-    if (this._itemsUsing === undefined) {
-      // Static path mirrors the client-side filter so the server endpoint
-      // would be useful for static providers too — but the client never
-      // calls it for them (no `async: true` flag → no fetch).
-      return [...this._items]
-    }
-    const result = await this._itemsUsing(query, ctx)
-    return Array.isArray(result) ? result : []
-  }
-
-  /** @internal */
-  toMeta(): MentionProviderMeta {
-    if (this._itemsUsing !== undefined) {
-      // Async providers ship empty `items`; the client checks `async: true`
-      // and fetches from the field's `mentionsUrl` per-keystroke instead.
-      return { trigger: this._trigger, items: [], async: true }
-    }
-    return { trigger: this._trigger, items: [...this._items] }
-  }
-}

package/src/PlainTextEditor.dom.test.ts

@@ -1,111 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { Editor } from '@tiptap/core'
-
-import { createPlainTextEditor, plainTextOf } from './PlainTextEditor.js'
-
-/**
- * Phase 6e proof-of-concept — mount a real Tiptap `Editor` against the
- * jsdom DOM that `src/test/setup.ts` boots, exercise typing through the
- * ProseMirror transaction API, and assert via the public surface.
- *
- * The pure-config tests in `PlainTextEditor.test.ts` cover schema-shape
- * fixtures (`plainTextToDoc`); this file proves the config actually
- * behaves correctly when mounted into the editor's lifecycle —
- * `setContent` → `getJSON` → `plainTextOf` round-trip, multi-line
- * separator handling, document constraint enforcement. Component-level
- * coverage that previously lived only in the playground now has a
- * fast in-process test.
- */
-describe('createPlainTextEditor (DOM)', () => {
-  function mountInDom(multiline: boolean): { editor: Editor; el: HTMLDivElement } {
-    const el = document.createElement('div')
-    document.body.appendChild(el)
-    const editor = new Editor({
-      ...createPlainTextEditor({ multiline, content: '' }),
-      element: el,
-    })
-    return { editor, el }
-  }
-
-  it('single-line: setContent + plainTextOf round-trips one paragraph', () => {
-    const { editor } = mountInDom(false)
-    try {
-      editor.commands.setContent('hello world')
-      assert.equal(plainTextOf(editor), 'hello world')
-    } finally {
-      editor.destroy()
-    }
-  })
-
-  it('single-line: schema rejects multi-paragraph content (collapses to one)', () => {
-    const { editor } = mountInDom(false)
-    try {
-      // ProseMirror enforces the doc schema; PlainTextDocument's content
-      // expression is `paragraph` (a SINGLE paragraph) in single-line
-      // mode. Passing a multi-paragraph JSON tree should be coerced to
-      // one paragraph by Tiptap's repair pass rather than throwing.
-      editor.commands.setContent({
-        type: 'doc',
-        content: [
-          { type: 'paragraph', content: [{ type: 'text', text: 'line one' }] },
-          { type: 'paragraph', content: [{ type: 'text', text: 'line two' }] },
-        ],
-      })
-      // The exact repair behavior is "keep what fits, drop the rest" —
-      // we don't assert the specific outcome (`line one` only vs the
-      // two joined), only that the result is single-paragraph and
-      // non-empty. Future Tiptap version bumps that change the repair
-      // strategy won't break this test.
-      const json = editor.getJSON()
-      assert.equal(json.content?.length, 1, 'single paragraph after repair')
-      assert.ok(plainTextOf(editor).length > 0, 'non-empty after repair')
-      assert.ok(!plainTextOf(editor).includes('\n'), 'no newline in single-line mode')
-    } finally {
-      editor.destroy()
-    }
-  })
-
-  it('multi-line: setContent across paragraphs serializes with \\n separators', () => {
-    const { editor } = mountInDom(true)
-    try {
-      editor.commands.setContent({
-        type: 'doc',
-        content: [
-          { type: 'paragraph', content: [{ type: 'text', text: 'first' }] },
-          { type: 'paragraph', content: [{ type: 'text', text: 'second' }] },
-          { type: 'paragraph', content: [{ type: 'text', text: 'third' }] },
-        ],
-      })
-      assert.equal(plainTextOf(editor), 'first\nsecond\nthird')
-    } finally {
-      editor.destroy()
-    }
-  })
-
-  it('multi-line: empty document returns empty string', () => {
-    const { editor } = mountInDom(true)
-    try {
-      assert.equal(plainTextOf(editor), '')
-    } finally {
-      editor.destroy()
-    }
-  })
-
-  it('typing via commands.insertContent updates the visible DOM', () => {
-    const { editor, el } = mountInDom(false)
-    try {
-      editor.commands.focus()
-      editor.commands.insertContent('typed via command')
-      assert.equal(plainTextOf(editor), 'typed via command')
-      // The ProseMirror view renders `.ProseMirror` inside the mount
-      // element; verify the text is in the visible DOM too (this is
-      // the assertion that pure-data fixtures can't make).
-      const pm = el.querySelector('.ProseMirror')
-      assert.ok(pm, 'ProseMirror view mounted')
-      assert.ok(pm!.textContent?.includes('typed via command'), 'text rendered in DOM')
-    } finally {
-      editor.destroy()
-    }
-  })
-})

package/src/PlainTextEditor.test.ts

@@ -1,158 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  createPlainTextEditor,
-  plainTextToDoc,
-  type PlainTextEditorOptions,
-} from './PlainTextEditor.js'
-
-describe('plainTextToDoc — single-line', () => {
-  it('empty string yields one empty paragraph', () => {
-    assert.deepEqual(plainTextToDoc('', false), {
-      type: 'doc',
-      content: [{ type: 'paragraph' }],
-    })
-  })
-
-  it('wraps a single run of text in one paragraph', () => {
-    assert.deepEqual(plainTextToDoc('hello', false), {
-      type: 'doc',
-      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'hello' }] }],
-    })
-  })
-
-  it('strips embedded newlines (LF and CRLF) — single-line schema permits one paragraph only', () => {
-    assert.deepEqual(plainTextToDoc('a\nb', false), {
-      type: 'doc',
-      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'ab' }] }],
-    })
-    assert.deepEqual(plainTextToDoc('a\r\nb', false), {
-      type: 'doc',
-      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'ab' }] }],
-    })
-  })
-})
-
-describe('plainTextToDoc — multi-line', () => {
-  it('empty string yields one empty paragraph', () => {
-    assert.deepEqual(plainTextToDoc('', true), {
-      type: 'doc',
-      content: [{ type: 'paragraph' }],
-    })
-  })
-
-  it('splits LF-separated lines into separate paragraphs', () => {
-    assert.deepEqual(plainTextToDoc('a\nb', true), {
-      type: 'doc',
-      content: [
-        { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
-        { type: 'paragraph', content: [{ type: 'text', text: 'b' }] },
-      ],
-    })
-  })
-
-  it('preserves empty lines as empty paragraphs', () => {
-    assert.deepEqual(plainTextToDoc('a\n\nb', true), {
-      type: 'doc',
-      content: [
-        { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
-        { type: 'paragraph' },
-        { type: 'paragraph', content: [{ type: 'text', text: 'b' }] },
-      ],
-    })
-  })
-
-  it('normalises CRLF to single paragraph splits', () => {
-    assert.deepEqual(plainTextToDoc('a\r\nb', true), {
-      type: 'doc',
-      content: [
-        { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
-        { type: 'paragraph', content: [{ type: 'text', text: 'b' }] },
-      ],
-    })
-  })
-})
-
-describe('createPlainTextEditor — config shape', () => {
-  function names(extensions: ReadonlyArray<{ name: string }>): string[] {
-    return extensions.map((e) => e.name)
-  }
-
-  it('default config: single-line, editable, schema + single-line keymap only', () => {
-    const cfg = createPlainTextEditor()
-    assert.equal(cfg.editable, true)
-    assert.equal(cfg.content, '')
-    const exts = (cfg.extensions ?? []) as Array<{ name: string }>
-    assert.deepEqual(names(exts), ['doc', 'paragraph', 'text', 'plainTextSingleLineKeymap'])
-    assert.equal(cfg.editorProps, undefined)
-    assert.equal(cfg.onUpdate, undefined)
-  })
-
-  it('multiline mode drops the single-line keymap', () => {
-    const cfg = createPlainTextEditor({ multiline: true })
-    const exts = (cfg.extensions ?? []) as Array<{ name: string }>
-    assert.deepEqual(names(exts), ['doc', 'paragraph', 'text'])
-  })
-
-  it('placeholder appends the Placeholder extension', () => {
-    const cfg = createPlainTextEditor({ placeholder: 'Type here…' })
-    const exts = (cfg.extensions ?? []) as Array<{ name: string }>
-    assert.ok(exts.some((e) => e.name === 'placeholder'),
-      `expected placeholder extension, got ${names(exts).join(',')}`)
-  })
-
-  it('caller-supplied extensions land after schema + behavior', () => {
-    const fakeExt = { name: 'fake-collab' } as unknown as Parameters<typeof createPlainTextEditor>[0] extends infer T
-      ? T extends { extensions?: Array<infer E> } ? E : never : never
-    const cfg = createPlainTextEditor({ extensions: [fakeExt] })
-    const exts = (cfg.extensions ?? []) as Array<{ name: string }>
-    assert.equal(exts[exts.length - 1]?.name, 'fake-collab')
-  })
-
-  it('editable can be turned off', () => {
-    const cfg = createPlainTextEditor({ editable: false })
-    assert.equal(cfg.editable, false)
-  })
-
-  it('seeds content as a doc JSON when text provided (single-line)', () => {
-    const cfg = createPlainTextEditor({ content: 'hello' })
-    assert.deepEqual(cfg.content, {
-      type: 'doc',
-      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'hello' }] }],
-    })
-  })
-
-  it('seeds content as multi-paragraph doc JSON when multiline + text provided', () => {
-    const cfg = createPlainTextEditor({ multiline: true, content: 'a\nb' })
-    assert.deepEqual(cfg.content, {
-      type: 'doc',
-      content: [
-        { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
-        { type: 'paragraph', content: [{ type: 'text', text: 'b' }] },
-      ],
-    })
-  })
-
-  it('empty content stays an empty string sentinel — Collaboration-friendly', () => {
-    // When collab is on, callers pass content omitted/'' so Collaboration's
-    // y-prosemirror binding takes ownership of the doc without a seed race.
-    const cfg = createPlainTextEditor({ content: '' })
-    assert.equal(cfg.content, '')
-  })
-
-  it('editorAttributes plumb into editorProps.attributes verbatim', () => {
-    const attrs = { class: 'foo bar', 'aria-label': 'Name' }
-    const cfg = createPlainTextEditor({ editorAttributes: attrs })
-    assert.deepEqual(cfg.editorProps, { attributes: attrs })
-  })
-
-  it('onUpdate is wired only when caller provides it', () => {
-    const withCb: PlainTextEditorOptions = { onUpdate: () => {} }
-    const cfgA = createPlainTextEditor(withCb)
-    assert.equal(typeof cfgA.onUpdate, 'function')
-
-    const cfgB = createPlainTextEditor()
-    assert.equal(cfgB.onUpdate, undefined)
-  })
-})