@pilotiq/tiptap 3.10.4 → 3.10.6

package/src/react/BlockSidePanel.tsx

@@ -1,451 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from 'react'
-import type { Editor } from '@tiptap/react'
-import {
-  FormFields,
-  parseFormDataToNested,
-  clampPanelWidth as clampPanelWidthShared,
-  useResizableWidth,
-} from '@pilotiq/pilotiq/react'
-import type { BlockMeta } from '../Block.js'
-
-const PANEL_WIDTH_STORAGE_KEY = 'pilotiq.tiptap.sidePanel.width'
-const PANEL_WIDTH_DEFAULT     = 320
-const PANEL_WIDTH_MIN         = 240
-const PANEL_WIDTH_MAX         = 600
-
-// Keys that point at any tabbable / interactive element inside the panel.
-// Same intent as Filament's focus-trap helper but kept inline — small one-off.
-const FOCUSABLE_SELECTOR = [
-  'a[href]',
-  'button:not([disabled])',
-  'input:not([disabled]):not([type="hidden"])',
-  'select:not([disabled])',
-  'textarea:not([disabled])',
-  '[tabindex]:not([tabindex="-1"])',
-].join(',')
-
-/**
- * Floating right-docked side panel for editing a custom block's schema
- * fields. Mounted by `TiptapEditor` once the user clicks the Edit button
- * on a `pilotiqBlock` NodeView; reads/writes flow through ProseMirror
- * directly (no form submit, no roundtrip).
- *
- * Why a sibling of the NodeView and not the NodeView itself:
- *   - NodeViews mount in a separate React tree (Tiptap quirk), so they
- *     can't reach pilotiq's `FormFields` renderer or any provider on
- *     the host page (Theme, Toaster, etc.). Hosting the panel here in
- *     the host's tree gives us the full pilotiq field surface for free.
- *
- * Reads: each field's `defaultValue` is overridden from the block's
- * stored `blockData`. Inputs are uncontrolled (outside `FormStateProvider`,
- * pilotiq's renderers fall back to `defaultValue` automatically).
- *
- * Writes: container-level event delegation on the form element. Every
- * change snapshots the entire form via `new FormData(formEl)` →
- * `parseFormDataToNested` (rebuilds nested arrays/objects from
- * dotted-path inputs like `myrep.0.title`) → `coerceBlockValues`
- * (per-fieldType JSON parse / boolean / number coerce so nested-shape
- * fields round-trip in their canonical wire form). The result is
- * dispatched through `state.tr.setNodeMarkup` on the tracked position.
- * The position is kept fresh by mapping it through every editor
- * transaction so live edits elsewhere in the document don't desync.
- *
- * V2 (2026-05-04 cont'd): nested-shape fields now round-trip cleanly:
- * Repeater (array of subschema rows), Builder (heterogeneous block
- * rows), TagsInput / KeyValue / FileUpload (JSON-encoded hidden
- * inputs), Markdown (plain textarea), and the standard primitives
- * (text / textarea / select / toggle / checkbox / radio / date /
- * datetime / number / slider / color / toggleButtons / checkboxList).
- */
-export interface BlockSidePanelProps {
-  editor:    Editor
-  /** Position at open time. Tracked + remapped on every transaction. */
-  initialPos: number
-  /** Block type at open time — guards against the user clicking Edit on
-   *  one block, then someone else's edit replacing it with a different
-   *  block at the same position. */
-  blockType: string
-  blocks:    BlockMeta[]
-  onClose:   () => void
-}
-
-export function BlockSidePanel({
-  editor,
-  initialPos,
-  blockType,
-  blocks,
-  onClose,
-}: BlockSidePanelProps): React.ReactElement | null {
-  const meta = blocks.find((b) => b.name === blockType)
-
-  // Live-tracked position of the block we're editing. Starts at the
-  // open-time position; every editor transaction maps it forward so the
-  // panel keeps writing to the same node even as the user types text
-  // elsewhere in the document.
-  const [pos, setPos] = useState<number | null>(initialPos)
-  const posRef = useRef<number | null>(initialPos)
-
-  // Prefilled values seed the form's `defaultValue`s. We re-read once
-  // when the panel opens (and on hard re-mount via key prop); ongoing
-  // edits don't snapshot the doc — the form's uncontrolled inputs hold
-  // their own state until the user closes the panel.
-  const initialValuesRef = useRef<Record<string, unknown>>(
-    pos !== null ? readBlockData(editor, pos) : {},
-  )
-
-  const asideRef = useRef<HTMLElement | null>(null)
-  const formRef = useRef<HTMLFormElement | null>(null)
-
-  // Width memory — survives panel close/reopen and full reload via
-  // localStorage. The shared `useResizableWidth` hook from
-  // `@pilotiq/pilotiq/react` handles the localStorage round-trip + drag
-  // pipeline; we just bind it to this panel's per-key bounds.
-  const { width, onResizeStart } = useResizableWidth({
-    storageKey:   PANEL_WIDTH_STORAGE_KEY,
-    min:          PANEL_WIDTH_MIN,
-    max:          PANEL_WIDTH_MAX,
-    defaultWidth: PANEL_WIDTH_DEFAULT,
-    edge:         'left',
-  })
-
-  // Save focus on mount, focus the first focusable inside the panel,
-  // restore previous focus on unmount. Mount-only effect — re-mounting
-  // the panel for a different block (key={pos:blockType}) re-runs this.
-  useEffect(() => {
-    const previouslyFocused = (typeof document !== 'undefined'
-      ? document.activeElement
-      : null) as HTMLElement | null
-    const aside = asideRef.current
-    if (aside) {
-      const first = aside.querySelector<HTMLElement>(FOCUSABLE_SELECTOR)
-      first?.focus()
-    }
-    return () => {
-      // Try/catch — the previously focused element may have been removed
-      // (e.g. an editor selection refresh nuked the surrounding NodeView).
-      try { previouslyFocused?.focus?.() } catch { /* noop */ }
-    }
-  }, [])
-
-  // ESC closes; Tab / Shift+Tab cycles within the panel. Bubble-phase
-  // listener — slash and mention menus' capture-phase ESC handlers fire
-  // first and stopPropagation, so ESC inside an open slash menu only
-  // closes the menu. ESC anywhere else (panel inputs, editor) closes
-  // the panel.
-  useEffect(() => {
-    const onKey = (e: KeyboardEvent): void => {
-      if (e.key === 'Escape') {
-        onClose()
-        e.preventDefault()
-        e.stopPropagation()
-        return
-      }
-      if (e.key !== 'Tab') return
-      const aside = asideRef.current
-      if (!aside) return
-      const active = document.activeElement as Node | null
-      if (!active || !aside.contains(active)) return
-      const focusables = Array.from(
-        aside.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR),
-      ).filter((el) => !el.hasAttribute('disabled'))
-      if (focusables.length === 0) return
-      const first = focusables[0]!
-      const last  = focusables[focusables.length - 1]!
-      if (e.shiftKey && active === first) {
-        e.preventDefault()
-        last.focus()
-      } else if (!e.shiftKey && active === last) {
-        e.preventDefault()
-        first.focus()
-      }
-    }
-    document.addEventListener('keydown', onKey)
-    return () => document.removeEventListener('keydown', onKey)
-  }, [onClose])
-
-  useEffect(() => {
-    if (pos === null) return
-    const handler = ({ transaction }: { transaction: { mapping: { map: (p: number) => number } } }): void => {
-      const current = posRef.current
-      if (current === null) return
-      const mapped = transaction.mapping.map(current)
-      // The block was deleted — close the panel.
-      const nodeNow = nodeAt(editor, mapped)
-      if (!nodeNow || nodeNow.type.name !== 'pilotiqBlock' || String(nodeNow.attrs['blockType'] ?? '') !== blockType) {
-        posRef.current = null
-        setPos(null)
-        onClose()
-        return
-      }
-      posRef.current = mapped
-      setPos(mapped)
-    }
-    editor.on('transaction', handler)
-    return () => { editor.off('transaction', handler) }
-  }, [editor, blockType, pos, onClose])
-
-  const writeBack = useCallback((nextValues: Record<string, unknown>): void => {
-    const at = posRef.current
-    if (at === null) return
-    // ProseMirror's `setNodeMarkup` lives on the transaction, not the
-    // ChainedCommands surface — go through `tr` directly. Pass `null`
-    // for the node-type arg to keep the existing type, just swap attrs.
-    const view = (editor as unknown as { view: { dispatch: (tr: unknown) => void } }).view
-    const state = (editor as unknown as { state: { tr: { setNodeMarkup: (p: number, t: null, a: Record<string, unknown>) => unknown } } }).state
-    const tr = state.tr.setNodeMarkup(at, null, { blockType, blockData: nextValues })
-    view.dispatch(tr)
-  }, [editor, blockType])
-
-  const handleChange = useCallback((): void => {
-    const formEl = formRef.current
-    if (!formEl || !meta) return
-    // Snapshot the full form: nested arrays / objects materialize from
-    // dotted-path names (`items.0.title`), JSON-encoded hidden inputs
-    // (TagsInput / KeyValue / FileUpload-multi) sit as JSON strings,
-    // toggle / checkbox hidden inputs sit as `'true' | 'false'`. The
-    // coerce pass below normalizes those to canonical shapes.
-    const raw = parseFormDataToNested(new FormData(formEl))
-    const coerced = coerceBlockValues(raw, meta.schema)
-    writeBack(coerced)
-  }, [meta, writeBack])
-
-  if (!meta || pos === null) return null
-
-  return (
-    <aside
-      ref={asideRef}
-      role="dialog"
-      aria-label={`Edit ${meta.label}`}
-      style={{ width }}
-      className="absolute top-0 left-full ml-4 max-h-[calc(100vh-2rem)] overflow-y-auto rounded-lg border bg-background shadow-lg z-30"
-    >
-      {/* Left-edge resize handle. Thin strip, hover-highlighted, full
-          height of the panel; mousedown starts a drag tracked at
-          document level so leaving the strip doesn't end the drag. */}
-      <div
-        role="separator"
-        aria-orientation="vertical"
-        aria-label="Resize panel"
-        onPointerDown={onResizeStart}
-        className="absolute left-0 top-0 h-full w-1 cursor-ew-resize hover:bg-border/80"
-      />
-      <header className="sticky top-0 z-10 flex items-center justify-between gap-2 border-b bg-background px-3 py-2">
-        <div className="flex items-center gap-2 min-w-0">
-          {meta.icon && <span aria-hidden="true">{meta.icon}</span>}
-          <span className="text-sm font-medium truncate">{meta.label}</span>
-        </div>
-        <button
-          type="button"
-          onClick={onClose}
-          aria-label="Close panel"
-          className="text-muted-foreground hover:text-foreground text-sm"
-        >
-          ×
-        </button>
-      </header>
-      <form
-        ref={formRef}
-        onInput={handleChange}
-        onChange={handleChange}
-        onSubmit={(e) => { e.preventDefault() }}
-        className="flex flex-col gap-3 px-3 py-3"
-      >
-        <FormFields
-          elements={meta.schema}
-          values={initialValuesRef.current}
-        />
-      </form>
-    </aside>
-  )
-}
-
-/**
- * Clamp + sanitize a candidate panel width against this panel's bounds
- * (`[PANEL_WIDTH_MIN, PANEL_WIDTH_MAX]`, default `PANEL_WIDTH_DEFAULT`).
- * Thin wrapper around the shared `clampPanelWidth` helper from
- * `@pilotiq/pilotiq/react` — kept exported with the panel-specific
- * defaults baked in so existing tests + downstream callers don't have
- * to plumb the bounds themselves.
- */
-export function clampPanelWidth(value: unknown): number {
-  return clampPanelWidthShared(value, {
-    min:          PANEL_WIDTH_MIN,
-    max:          PANEL_WIDTH_MAX,
-    defaultWidth: PANEL_WIDTH_DEFAULT,
-  })
-}
-
-/**
- * Per-fieldType coerce of a nested values map (built by
- * `parseFormDataToNested`) against the block's schema. Mirrors the
- * server-side `coerceFormValues` at a small subset suitable for the
- * side panel — we only run on top-level block fields plus the immediate
- * children of any Repeater rows / Builder rows.data, which is all the
- * V2 surface needs.
- *
- * Non-coerce passthrough for: text, textarea, select, radio, date,
- * dateTime, email, color, toggleButtons, slug, hidden. (Their wire shape
- * is already a plain string / array of strings.)
- *
- * Coerce branches:
- * - `toggle` / `checkbox`: 'true' / 'false' string → boolean.
- * - `number` / `slider`: parse to Number, null on empty, raw string
- *   passthrough on NaN (so a half-typed value isn't lost).
- * - `tagsInput`: JSON-encoded string → string[].
- * - `checkboxList`: JSON-encoded string OR array → string[].
- * - `keyValue`: JSON-encoded string → Record<string, unknown>.
- * - `fileUpload`: single → URL string passthrough; multiple →
- *   JSON-encoded string → string[].
- * - `repeater`: each row in the array gets recursive coerce against
- *   the field's `template` (the inner field schema definition).
- * - `builder`: each row's `data` gets recursive coerce against the
- *   block matching `row.type` from `field.blocks[]`. Unknown block
- *   types pass through verbatim — the renderer shows a placeholder
- *   and the data round-trips intact across config rollbacks.
- *
- * Exported for unit tests. Pure — no React, no DOM, no editor.
- */
-export function coerceBlockValues(
-  raw:    Record<string, unknown>,
-  schema: ReadonlyArray<Record<string, unknown>>,
-): Record<string, unknown> {
-  const out: Record<string, unknown> = { ...raw }
-  for (const field of schema) {
-    const name = String(field['name'] ?? '')
-    if (!name) continue
-    const ft = String(field['fieldType'] ?? 'text')
-    const value = out[name]
-    out[name] = coerceField(value, ft, field)
-  }
-  return out
-}
-
-function coerceField(
-  value: unknown,
-  ft:    string,
-  field: Record<string, unknown>,
-): unknown {
-  switch (ft) {
-    case 'toggle':
-    case 'checkbox':
-      return value === 'true' || value === true
-    case 'number':
-    case 'slider':
-      return coerceNumber(value)
-    case 'tagsInput':
-      return parseJsonArray(value)
-    case 'checkboxList':
-      return parseJsonArray(value)
-    case 'keyValue':
-      return parseJsonObject(value)
-    case 'fileUpload': {
-      const multiple = Boolean(field['multiple'])
-      if (multiple) return parseJsonArray(value)
-      return typeof value === 'string' ? value : ''
-    }
-    case 'repeater': {
-      if (!Array.isArray(value)) return []
-      const template = (field['template'] as ReadonlyArray<Record<string, unknown>> | undefined) ?? []
-      return value.map((row) => {
-        if (!row || typeof row !== 'object') return {}
-        return coerceBlockValues(row as Record<string, unknown>, template)
-      })
-    }
-    case 'builder': {
-      if (!Array.isArray(value)) return []
-      const blockMetas = (field['blocks'] as ReadonlyArray<Record<string, unknown>> | undefined) ?? []
-      return value.map((row) => {
-        if (!row || typeof row !== 'object') return { type: '', data: {} }
-        const r = row as Record<string, unknown>
-        const type = String(r['type'] ?? '')
-        const data = (r['data'] as Record<string, unknown> | undefined) ?? {}
-        const block = blockMetas.find((b) => String(b['name'] ?? '') === type)
-        if (!block) return { type, data }
-        const tpl = (block['template'] as ReadonlyArray<Record<string, unknown>> | undefined) ?? []
-        return { type, data: coerceBlockValues(data, tpl) }
-      })
-    }
-    default:
-      return value === undefined ? '' : value
-  }
-}
-
-function coerceNumber(value: unknown): unknown {
-  if (value === '' || value === null || value === undefined) return null
-  if (typeof value === 'number') return value
-  const raw = String(value)
-  if (raw === '') return null
-  const n = Number(raw)
-  return Number.isNaN(n) ? raw : n
-}
-
-function parseJsonArray(value: unknown): unknown[] {
-  if (Array.isArray(value)) return value
-  if (typeof value !== 'string' || value === '') return []
-  try {
-    const parsed = JSON.parse(value)
-    return Array.isArray(parsed) ? parsed : []
-  } catch {
-    return []
-  }
-}
-
-function parseJsonObject(value: unknown): Record<string, unknown> {
-  if (value && typeof value === 'object' && !Array.isArray(value)) {
-    return value as Record<string, unknown>
-  }
-  if (typeof value !== 'string' || value === '') return {}
-  try {
-    const parsed = JSON.parse(value)
-    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-      return parsed as Record<string, unknown>
-    }
-  } catch { /* fall through */ }
-  return {}
-}
-
-/**
- * Read the resolved field value for a given input event target. Kept
- * for back-compat — V1 used this in the per-event handler. V2 reads
- * the entire form via `FormData` instead, but this helper still maps
- * cleanly onto a single-input read for testing and is exported.
- *
- * String passthrough for the common case; explicit coercion for
- * booleans and numerics so the round-trip into the node attrs preserves
- * shape.
- */
-export function readBlockFieldValue(
-  target:    { type?: string; value: string; checked?: boolean },
-  fieldMeta: { fieldType?: unknown },
-): unknown {
-  const ft = String(fieldMeta.fieldType ?? 'text')
-  if (ft === 'toggle' || ft === 'checkbox') {
-    return target.checked === true
-  }
-  if (ft === 'number' || ft === 'slider') {
-    const raw = target.value
-    if (raw === '') return null
-    const n = Number(raw)
-    return Number.isNaN(n) ? raw : n
-  }
-  return target.value
-}
-
-interface PMNode {
-  type:  { name: string }
-  attrs: Record<string, unknown>
-}
-
-function readBlockData(editor: Editor, pos: number): Record<string, unknown> {
-  const node = nodeAt(editor, pos)
-  if (!node) return {}
-  return (node.attrs['blockData'] as Record<string, unknown> | null) ?? {}
-}
-
-function nodeAt(editor: Editor, pos: number): PMNode | null {
-  try {
-    return (editor.state.doc as unknown as { nodeAt: (p: number) => PMNode | null }).nodeAt(pos)
-  } catch {
-    return null
-  }
-}

package/src/react/CollabTextRenderer.tsx

@@ -1,230 +0,0 @@
-import { useEffect, useMemo, useRef } from 'react'
-import { useEditor, EditorContent, type Extension } from '@tiptap/react'
-import type { AnyExtension } from '@tiptap/core'
-import {
-  useCollabRoom,
-  getCollabExtensions,
-  useCollabSeed,
-  type CollabTextRendererProps,
-} from '@pilotiq/pilotiq/react'
-import { createPlainTextEditor, plainTextOf, plainTextToDoc } from '../PlainTextEditor.js'
-import { AiSuggestionExtension } from '../extensions/AiSuggestionExtension.js'
-import { useAiSuggestionBridge } from './useAiSuggestionBridge.js'
-import type { YDocShape } from '../collabShapes.js'
-
-/**
- * Tiptap-backed plain-text editor for pilotiq's `TextField` / `TextareaField`
- * / similar single-line / multi-line text fields when collab is on.
- *
- * Lifts the cursor-bookkeeping burden off the field renderer: y-prosemirror
- * anchors selections to `Yjs.RelativePosition` items, so concurrent and
- * mid-word remote edits translate the local cursor correctly without any
- * heuristic. Replaces the legacy `Y.Text` + `computeDelta` + `preserveCursor`
- * path documented in `docs/plans/text-fields-tiptap-backed-collab.md`.
- *
- * Mount conditions (enforced upstream by `TextLikeInput`):
- *   - A `<RecordCollabRoom>` is mounted up-tree (`useCollabRoom() !== null`).
- *   - A collab extension factory was registered (`getCollabExtensions() !== null`).
- *   - The field hasn't opted out via `.collab(false)`.
- *   - The field is not masked (`.mask(pattern)`).
- *   - The field is top-level (not a Repeater / Builder row leaf).
- *
- * If either the room or the factory disappears at runtime (e.g. the plugin
- * was never installed), we still render an editor — it's just a non-collab
- * plain Tiptap. That's a regression vs `<input>` ergonomically but never
- * crashes; in practice the upstream gate prevents this branch from mounting
- * when collab isn't wired.
- */
-export function CollabTextRenderer({
-  name,
-  fragmentKey,
-  multiline,
-  defaultValue,
-  placeholder,
-  disabled,
-  onChange,
-  onBlur,
-  onSubmit,
-  className,
-  editorAttributes,
-}: CollabTextRendererProps): React.ReactElement {
-  const room    = useCollabRoom()
-  const factory = getCollabExtensions()
-  const collabActive = !!(room && factory)
-
-  // Capture the initial non-empty `defaultValue` on mount + keep it stable.
-  // The seedFn (below) needs to re-seed the empty fragment with the
-  // SSR-loaded value even if the host's `defaultValue` prop has been
-  // clobbered to '' by a sync-triggered empty `onChange` round-trip
-  // (handleChange → setText('') → setValue('') → ctx.values.title=''  →
-  // FormBody re-renders the field with the new empty value). Closing
-  // over the live prop in seedFn means seed-on-resync silently fails;
-  // the ref preserves the seed source. Once the user types into the
-  // editor the seedFn will no longer fire — the fragment won't be
-  // empty — so this ref is read-only after the first non-empty seed.
-  const initialDefaultValueRef = useRef<string>(defaultValue)
-  if (defaultValue && !initialDefaultValueRef.current) {
-    initialDefaultValueRef.current = defaultValue
-  }
-
-  // Collab-stable identifier — `name` on top-level fields, but the
-  // row-id-anchored composite (`items.<rowId>.title`) on Repeater /
-  // Builder row leaves so the Y.XmlFragment survives reorders. Routes
-  // ONLY into the collab branches (factory + first-load seed); AI
-  // suggestion bridge + onChange + hidden FormData input stay on
-  // `name` (the positional FormData path) so AI tool calls referencing
-  // the field by its FormData name still reach the editor.
-  const collabName = fragmentKey ?? name
-
-  // Built once per editor mount. The factory closes over the room's `ydoc`
-  // + `provider` and the field name to produce a `Collaboration` (and
-  // optional `CollaborationCursor`) extension targeting the field's
-  // `Y.XmlFragment`. Re-running on every render would tear down the editor.
-  const collabExtensions = useMemo<AnyExtension[]>(() => {
-    if (!collabActive || !room || !factory) return []
-    return factory({
-      ydoc:      room.ydoc,
-      provider:  room.provider,
-      fieldName: collabName,
-      ...(room.user ? { user: room.user } : {}),
-    }) as Extension[]
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [collabActive])
-
-  const editor = useEditor(
-    {
-      // Tiptap v3 SSR guard. With `immediatelyRender: true` (default)
-      // `useEditor` touches the DOM during construction; under Vike's
-      // `onRenderHtml` that throws "SSR has been detected, please set
-      // `immediatelyRender` explicitly to `false` to avoid hydration
-      // mismatches." Deferring until the first React effect lets SSR
-      // produce an empty shell + hydration mount the live editor.
-      //
-      // Load-bearing for the AI-attached auto-upgrade path: with rule
-      // #2, AI fields render the Tiptap surface during SSR (where
-      // `useCollabRoom()` is null but `aiActions.length > 0` flips the
-      // host's gate). Without this flag the dev server would crash on
-      // the first SSR pass of any record-edit page touching AI fields.
-      immediatelyRender: false,
-      ...createPlainTextEditor({
-        multiline,
-        ...(placeholder !== undefined ? { placeholder } : {}),
-        editable: !disabled,
-        // When Collaboration owns the doc, omit `content` so the editor
-        // doesn't race the y-prosemirror sync. The post-`synced` effect below
-        // seeds the fragment on first connect when it's still empty. When
-        // collab is off, seed from defaultValue directly.
-        content: collabActive ? '' : defaultValue,
-        // AI suggestions — always-on extension that tracks suggested edits as
-        // inline strikethrough + Approve/Reject chip widgets. Idle until the
-        // host calls `editor.commands.addAiSuggestion(...)` via the bridge below.
-        // Matches the `TiptapEditor` wiring so suggestion mode works uniformly
-        // across RichTextField / MarkdownField / TextField+TextareaField.
-        extensions: [...collabExtensions, AiSuggestionExtension],
-        onUpdate: (text) => onChange(text),
-        ...(onSubmit ? { onSubmit: () => { onSubmit(); return false } } : {}),
-        ...(className || editorAttributes
-          ? {
-              editorAttributes: {
-                ...(editorAttributes ?? {}),
-                ...(className ? { class: className } : {}),
-              },
-            }
-          : {}),
-      }),
-    },
-    // Re-mount when collab toggles. Other props (multiline, name, etc) are
-    // stable per mount under the upstream gate.
-    [collabActive],
-  )
-
-  // Mirror the editor's editable state with the prop. `useEditor` snapshots
-  // `editable` at first call, so we update it imperatively on changes.
-  useEffect(() => {
-    if (!editor) return
-    editor.setEditable(!disabled)
-  }, [editor, disabled])
-
-  // Cross-package suggestion bridge — sync the host's
-  // `<PendingSuggestionsContext>` queue with the editor's `AiSuggestion`
-  // extension. No-op when no provider is mounted (default no-op context).
-  //
-  // Whole-field fallback: chat-driven suggestions (e.g. `update_form_state`)
-  // arrive without `meta.editorRange`. Plain-text editors opt into a
-  // synthesized full-doc range so the inline-diff chip (red strikethrough on
-  // the current value + green chip with the suggested text + ✓/✕ buttons)
-  // renders BEFORE the user approves. The extension's `applyApprove` is
-  // text-node-based which fits the plain-text schema exactly. The
-  // `onApplyWholeField` callback stays as a fallback for cases that don't
-  // synthesize (e.g. an empty doc — `from === to` skips the chip but the
-  // applier still needs to swap content).
-  useAiSuggestionBridge(editor ?? null, name, {
-    synthesizeWholeFieldRange: (ed) => ({
-      from: 0,
-      to:   ed.state.doc.content.size,
-    }),
-    onApplyWholeField: (value) => {
-      if (!editor || editor.isDestroyed) return
-      editor.commands.setContent(plainTextToDoc(value, !!multiline))
-    },
-  })
-
-  // First-load seed when collab is active. Collaboration starts the editor
-  // empty regardless of `defaultValue`; once the room's first sync
-  // resolves, `useCollabSeed` runs the callback inside `ydoc.transact`.
-  // Empty fragment + we have an initial value = first session for this
-  // record — push the SSR-rendered default into the editor once.
-  //
-  // Race caveat: two peers simultaneously mounting against a brand-new
-  // record (both seeing `fragment.length === 0`) can both seed and produce
-  // duplicated text. Same window as `TiptapEditor`'s rich-text seed path.
-  // Acceptable for now; can be tightened later via a deterministic
-  // first-writer election or a server-side seed handoff.
-  //
-  // Subscribe-after-sync mirror: after the seed branch (or no-op when the
-  // fragment already has content from a remote peer), replay the editor's
-  // current text into `onChange`. The mount-time safety-net effect below
-  // fires once when the editor instance materializes, but in the cold-mount
-  // case (fresh peer joining a populated doc) y-prosemirror's `ySyncPlugin`
-  // view hook may run _forceRerender before the React owner has installed
-  // the `update` listener that drives `onUpdate` — leaving the hidden
-  // FormData input empty. Mirroring after `room.synced` resolves closes the
-  // gap. Idempotent — when `onUpdate` already propagated the value, this is
-  // a no-op `setText(sameValue)`. Same shape as the catch-up replay in
-  // `@pilotiq-pro/collab`'s `rowArrayBinding.subscribeRows`.
-  useCollabSeed(
-    editor && collabActive ? room : null,
-    collabName,
-    (doc) => {
-      const fragment = (doc as YDocShape).getXmlFragment(collabName)
-      const seedValue = initialDefaultValueRef.current
-      if (fragment && fragment.length === 0 && seedValue && editor) {
-        editor.commands.setContent(plainTextToDoc(seedValue, multiline))
-      }
-      if (editor) onChange(plainTextOf(editor))
-    },
-  )
-
-  // Bubble the editor's blur event up to the host. Tiptap exposes this via
-  // `editor.on('blur', ...)`. The simpler `onBlur` prop on `EditorContent`
-  // fires on the DOM node, but selection inside contenteditable can land on
-  // child nodes; the Tiptap event is the canonical "editor lost focus".
-  useEffect(() => {
-    if (!editor) return
-    const handler = (): void => onBlur()
-    editor.on('blur', handler)
-    return () => { editor.off('blur', handler) }
-  }, [editor, onBlur])
-
-  // Best-effort getText safety net — onUpdate should fire on every
-  // y-prosemirror sync, but if a remote update somehow doesn't trigger
-  // `onUpdate`, the wrapper's hidden input goes stale. Re-emit on every
-  // editor render tick. No-op when text matches the last emit.
-  useEffect(() => {
-    if (!editor) return
-    onChange(plainTextOf(editor))
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [editor])
-
-  return <EditorContent editor={editor} />
-}