@pilotiq/tiptap 3.10.5 → 3.10.7

package/src/react/useAiInlineDiff.ts

@@ -1,342 +0,0 @@
-/**
- * Bridge between the host's `<PendingSuggestionsContext>` queue and the
- * editor's `AiInlineDiffExtension`. When a whole-field suggestion arrives
- * for the field, the hook:
- *
- *   1. Parses the suggested value into a ProseMirror `Slice` via the
- *      renderer-supplied parser. Each Tiptap surface owns its own
- *      content shape — markdown source for `MarkdownEditor`, HTML / JSON
- *      for `TiptapEditor`, plain text for `CollabTextRenderer`.
- *   2. Calls `editor.commands.startAiInlineDiff(id, slice)` — the
- *      extension snapshots the current doc as the baseline, replaces
- *      the doc content with the proposed slice, and starts a
- *      `prosemirror-changeset` tracking the diff.
- *   3. Registers an applier on the cross-tree pending-suggestion
- *      registry so the host's `<AiSuggestionBanner>` Accept button (and
- *      any other surface calling `pendingSuggestions.approve(id)`) runs
- *      `acceptAiInlineDiff()` instead of the legacy `onApplyWholeField`
- *      callback. The current doc IS the accepted state — no extra
- *      content swap needed.
- *
- * Reject handling: not registered on the applier (the registry only
- * tracks Approve). Renderers wire Reject through the banner's
- * `onRejectWithEditor` prop, which calls `rejectAiInlineDiff()` to revert
- * the doc to the baseline before dismissing the suggestion.
- *
- * Defensive: only one inline diff active at a time per editor. If a new
- * synthesized suggestion arrives while one is still pending review, the
- * hook drops it (the producer should have waited). This matches
- * `AiSuggestionExtension`'s chip path which also allows only one
- * suggestion at a time per id.
- */
-
-import { useEffect, useRef } from 'react'
-import type { Editor } from '@tiptap/core'
-import type { Slice } from '@tiptap/pm/model'
-import { useEditorState } from '@tiptap/react'
-import {
-  registerPendingSuggestionApplier,
-  usePendingSuggestionsForField,
-  useFormId,
-  type PendingSuggestion,
-  type PendingSuggestionApplier,
-} from '@pilotiq/pilotiq/react'
-import { aiInlineDiffPluginKey } from '../extensions/AiInlineDiffExtension.js'
-import {
-  planReplaceBlock,
-  planInsertBlockBefore,
-  planDeleteBlock,
-  planUpdateBlockMark,
-  type BlockMarkRange,
-  type TransactionModifier,
-} from '../surgicalOps.js'
-
-export interface UseAiInlineDiffOptions {
-  /**
-   * Parse the suggested string value into a ProseMirror Slice that's
-   * compatible with this editor's schema. Returns `null` to skip (e.g.
-   * malformed content, unsupported markup) — the suggestion stays in
-   * the queue but no diff renders, and the host's fallback path (banner
-   * with `onApplyWholeField`) takes over.
-   *
-   * Renderers implement this per content shape:
-   *   - plain text → wrap each line in a `paragraph` node
-   *   - markdown   → run through the Markdown extension's parseMarkdown
-   *   - HTML       → DOMParser + ProseMirror's DOMParser.parse
-   */
-  parseSuggestion: (editor: Editor, value: string) => Slice | null
-}
-
-/**
- * Returns whether a diff is currently active in the editor. Hosts use
- * this to gate the banner's UI between the legacy `onApplyWholeField`
- * mode and the diff-aware mode (Reject routes through
- * `rejectAiInlineDiff` to revert the doc).
- */
-export function useIsAiInlineDiffActive(editor: Editor | null): boolean {
-  const active = useEditorState({
-    editor,
-    selector: ({ editor: ed }) => !!ed && aiInlineDiffPluginKey.getState(ed.state) !== null,
-  })
-  return active ?? false
-}
-
-export function useAiInlineDiff(
-  editor: Editor | null,
-  fieldName: string,
-  options: UseAiInlineDiffOptions,
-): void {
-  const { list } = usePendingSuggestionsForField(fieldName)
-  // Scope the applier registration by the surrounding form's id so
-  // multi-form pages route suggestions to the editor instance inside the
-  // matching form — without this, two editors on different forms but
-  // sharing a field name (e.g. two "summary" RichTextFields, one in the
-  // main edit form + one in a Replicate modal) would race on
-  // `registerPendingSuggestionApplier(undefined, …)` and the last-mounted
-  // editor would steal every approval. Falls back to wildcard scope
-  // (`undefined`) when no form is up-tree.
-  const formId = useFormId()
-
-  const parseRef = useRef(options.parseSuggestion)
-  useEffect(() => { parseRef.current = options.parseSuggestion }, [options.parseSuggestion])
-
-  // Track which ids we've handed off to the editor's diff extension
-  // so we don't re-start the diff every render or for already-active
-  // suggestions.
-  const startedRef = useRef<Set<string>>(new Set())
-
-  // Re-evaluate the suggestion queue when the editor's doc shape
-  // changes. Specifically guards against the seed race: collab-enabled
-  // markdown/richtext editors mount empty and seed their content
-  // asynchronously after the Yjs provider syncs. A suggestion arriving
-  // during that window (or before the first user keystroke) sees an
-  // empty doc, `planReplaceBlock` returns null for any blockIndex >= 1,
-  // the effect bails — and never re-runs because `list` hasn't changed
-  // and React doesn't track ProseMirror's doc state. Watching
-  // `doc.childCount` flips the diff-start effect from "ran once at
-  // suggestion-push time" to "re-runs when the doc reaches usable
-  // shape," which closes the silent no-preview gap.
-  const childCount = useEditorState({
-    editor,
-    selector: ({ editor: ed }) => ed?.state.doc.childCount ?? 0,
-  }) ?? 0
-
-  // Context → editor: start the diff for each new whole-field /
-  // surgical-block suggestion. `meta.surgical` (if present) routes to a
-  // precise PM transaction; otherwise we treat the suggested value as a
-  // whole-field replacement. `meta.editorRange` (chip path) is filtered
-  // out — handled by AiSuggestionExtension elsewhere.
-  useEffect(() => {
-    if (!editor) return
-    const diffable = list.filter(s => !hasEditorRange(s))
-    for (const s of diffable) {
-      if (startedRef.current.has(s.id)) continue
-      const diffActive = aiInlineDiffPluginKey.getState(editor.state) !== null
-      const surgical   = readSurgicalMeta(s)
-
-      // Cross-tool-call surgical stacking. When a diff is already active
-      // and a fresh surgical suggestion arrives (typically the model
-      // emitted a second `update_form_state` tool call instead of
-      // batching ops in one), fold the new modifier into the active
-      // diff. We dispatch a plain transaction with no extension meta;
-      // the plugin's existing "no explicit meta + tr.docChanged" branch
-      // adds the steps to the running changeset, so decorations update
-      // to cover both ops' ranges and the banner shows the combined
-      // count. Accept commits the union, Reject reverts to the same
-      // baseline captured when the FIRST suggestion started the diff —
-      // semantically "reject all pending suggested changes", which
-      // matches the banner copy.
-      //
-      // Whole-field suggestions still bail when a diff is active —
-      // dropping a fresh slice on top of an active review is too
-      // disruptive (it'd swap the entire doc mid-review).
-      if (diffActive) {
-        if (!surgical) continue
-        const modifier = planSurgicalModifier(editor, surgical)
-        if (!modifier) continue
-        editor.commands.command(({ tr, dispatch }) => {
-          modifier(tr)
-          if (!tr.docChanged) return false
-          if (dispatch) dispatch(tr)
-          return true
-        })
-        startedRef.current.add(s.id)
-        continue
-      }
-
-      if (surgical) {
-        const modifier = planSurgicalModifier(editor, surgical)
-        if (!modifier) continue
-        editor.commands.applySurgicalAiInlineDiff(s.id, modifier)
-        startedRef.current.add(s.id)
-        continue
-      }
-
-      if (typeof s.suggestedValue !== 'string') continue
-      const slice = parseRef.current(editor, s.suggestedValue)
-      if (!slice) continue
-      editor.commands.startAiInlineDiff(s.id, slice)
-      startedRef.current.add(s.id)
-    }
-    // Cleanup: when a suggestion leaves the context AND we previously
-    // started a diff for it, the editor should drop the diff state too.
-    // Approve dismisses via context → here we drop from startedRef.
-    const contextIds = new Set(list.map(s => s.id))
-    for (const id of Array.from(startedRef.current)) {
-      if (!contextIds.has(id)) startedRef.current.delete(id)
-    }
-  }, [editor, list, childCount])
-
-  // Cross-tree applier — two paths:
-  //
-  //   1. Review-mode accept. Banner / chat-sidebar pill calls
-  //      `pendingSuggestions.approve(id)` for a suggestion we've already
-  //      started a diff for. Clear the diff state — current doc IS the
-  //      accepted state.
-  //   2. Auto-mode direct apply. AI tool binding bypassed the queue and
-  //      called the registry's applier with a synthetic suggestion
-  //      carrying `meta.surgical` (the suggestion was never pushed to
-  //      the context, so it's not in `startedRef`). Plan the modifier
-  //      and dispatch it as a plain transaction — no diff overlay, no
-  //      Accept / Reject step. Mirrors `set_value` auto-mode, which
-  //      writes directly via the same registry.
-  useEffect(() => {
-    if (!editor) return
-    const applier: PendingSuggestionApplier = (suggestion) => {
-      if (startedRef.current.has(suggestion.id)) {
-        editor.commands.acceptAiInlineDiff()
-        return
-      }
-      const surgical = readSurgicalMeta(suggestion)
-      if (!surgical) return
-      const modifier = planSurgicalModifier(editor, surgical)
-      if (!modifier) return
-      editor.commands.command(({ tr, dispatch }) => {
-        modifier(tr)
-        if (!tr.docChanged) return false
-        if (dispatch) dispatch(tr)
-        return true
-      })
-    }
-    return registerPendingSuggestionApplier(formId, fieldName, applier)
-  }, [editor, fieldName, formId])
-}
-
-function hasEditorRange(s: PendingSuggestion): boolean {
-  const meta = (s.meta ?? {}) as Record<string, unknown>
-  const range = meta['editorRange'] as { from?: unknown; to?: unknown } | undefined
-  return !!(range && typeof range.from === 'number' && typeof range.to === 'number')
-}
-
-/**
- * Surgical op carried in `PendingSuggestion.meta.surgical`. The pilotiq-
- * pro `update_form_state` client handler stamps this when the AI agent
- * picks a block-level op instead of `set_value`.
- *
- * `content` is HTML for replace/insert ops, ignored otherwise. `mark` +
- * `range` apply only to the mark op. Discriminated union; readers should
- * narrow on `op`.
- */
-type SurgicalOp =
-  | { op: 'replace_block';       blockIndex: number; content: string }
-  | { op: 'insert_block_before'; blockIndex: number; content: string }
-  | { op: 'delete_block';        blockIndex: number }
-  | { op: 'update_block_mark';   blockIndex: number; mark: string; range: BlockMarkRange; apply: boolean; attrs?: Record<string, unknown> }
-
-/**
- * Either a single op (when the AI emitted only one surgical change) or
- * an `{ ops: [...] }` batch (when the AI emitted multiple surgical ops
- * in one `update_form_state` tool call). We apply a batch as a single
- * combined diff so the user sees one Accept / Reject for the whole set.
- */
-type SurgicalMeta = SurgicalOp | { ops: SurgicalOp[] }
-
-function parseSurgicalOp(obj: Record<string, unknown>): SurgicalOp | null {
-  const op = obj['op']
-  const blockIndex = obj['blockIndex']
-  if (typeof blockIndex !== 'number') return null
-  switch (op) {
-    case 'replace_block':
-    case 'insert_block_before': {
-      const content = obj['content']
-      if (typeof content !== 'string') return null
-      return { op, blockIndex, content }
-    }
-    case 'delete_block':
-      return { op, blockIndex }
-    case 'update_block_mark': {
-      const mark  = obj['mark']
-      const range = obj['range'] as { from?: unknown; to?: unknown } | undefined
-      const apply = obj['apply']
-      const attrs = obj['attrs']
-      if (typeof mark !== 'string') return null
-      if (!range || typeof range.from !== 'number' || typeof range.to !== 'number') return null
-      if (typeof apply !== 'boolean') return null
-      return {
-        op,
-        blockIndex,
-        mark,
-        range: { from: range.from, to: range.to },
-        apply,
-        ...(attrs && typeof attrs === 'object' ? { attrs: attrs as Record<string, unknown> } : {}),
-      }
-    }
-    default:
-      return null
-  }
-}
-
-function readSurgicalMeta(s: PendingSuggestion): SurgicalMeta | null {
-  const meta = (s.meta ?? {}) as Record<string, unknown>
-  const raw  = meta['surgical']
-  if (!raw || typeof raw !== 'object') return null
-  const obj = raw as Record<string, unknown>
-  // Batch form: { ops: [SurgicalOp, ...] }
-  if (Array.isArray(obj['ops'])) {
-    const parsed: SurgicalOp[] = []
-    for (const entry of obj['ops'] as unknown[]) {
-      if (!entry || typeof entry !== 'object') continue
-      const op = parseSurgicalOp(entry as Record<string, unknown>)
-      if (op) parsed.push(op)
-    }
-    if (parsed.length === 0) return null
-    return { ops: parsed }
-  }
-  return parseSurgicalOp(obj)
-}
-
-function planOp(editor: Editor, op: SurgicalOp): TransactionModifier | null {
-  switch (op.op) {
-    case 'replace_block':       return planReplaceBlock(editor, op.blockIndex, op.content)
-    case 'insert_block_before': return planInsertBlockBefore(editor, op.blockIndex, op.content)
-    case 'delete_block':        return planDeleteBlock(editor, op.blockIndex)
-    case 'update_block_mark':   return planUpdateBlockMark(editor, op.blockIndex, op.mark, op.range, op.apply, op.attrs)
-  }
-}
-
-/**
- * Translate a surgical meta into a single TransactionModifier the diff
- * extension can wrap with a snapshot. For batches, modifiers are
- * computed against the original (pre-transaction) doc and then applied
- * in DESC `blockIndex` order — each subsequent modifier touches earlier
- * positions, so the prior modifiers' edits (at higher positions) don't
- * shift the absolute positions the later modifiers were planned with.
- *
- * Returns null when the batch has no plannable ops (all out-of-range /
- * unparseable). Drops individual non-plannable ops from a batch but
- * still runs whatever did plan, so a single bad op doesn't kill the
- * whole batch.
- */
-function planSurgicalModifier(editor: Editor, surgical: SurgicalMeta): TransactionModifier | null {
-  if ('ops' in surgical) {
-    const sorted = [...surgical.ops].sort((a, b) => b.blockIndex - a.blockIndex)
-    const modifiers: TransactionModifier[] = []
-    for (const op of sorted) {
-      const mod = planOp(editor, op)
-      if (mod) modifiers.push(mod)
-    }
-    if (modifiers.length === 0) return null
-    return (tr) => { for (const mod of modifiers) mod(tr) }
-  }
-  return planOp(editor, surgical)
-}

package/src/react/useAiSuggestionBridge.ts

@@ -1,223 +0,0 @@
-import { useEffect, useRef } from 'react'
-import type { Editor } from '@tiptap/core'
-import {
-  registerPendingSuggestionApplier,
-  usePendingSuggestionsForField,
-  useFormId,
-  type PendingSuggestion,
-  type PendingSuggestionApplier,
-} from '@pilotiq/pilotiq/react'
-import { aiSuggestionPluginKey } from '../extensions/AiSuggestionExtension.js'
-
-/**
- * Two-way sync between the cross-package `<PendingSuggestionsContext>`
- * queue and this editor's `AiSuggestionExtension` state.
- *
- *   - **Context → editor**: every entry whose `meta.editorRange = { from, to }`
- *     is present and whose `suggestedValue` is a string gets pushed into the
- *     editor as an inline-diff hunk via `addAiSuggestion`. Entries leaving the
- *     queue are removed from the editor via `rejectAiSuggestion` (no doc edit).
- *
- *   - **Editor → context**: when a chip's Approve / Reject button removes a
- *     hunk from the editor's plugin state, the matching id is dismissed from
- *     the queue (`dismiss(id)`) so other surfaces (e.g. the chat-sidebar pill,
- *     a future FieldShell overlay) clear in lock-step. The doc mutation
- *     itself happens inside the editor — context is just a notification.
- *
- * Cycle protection: the hook tracks which ids it has personally pushed to
- * the editor (`pushed`). The Context→editor pass never re-pushes an id that's
- * already there, and the Editor→context pass only dismisses ids that this
- * hook had previously pushed (so an id added directly by host code via
- * `editor.commands.addAiSuggestion(...)` doesn't get reflected back through
- * a context that never knew about it).
- *
- * **Whole-field fallback** (chat-driven suggestions). Producers like
- * `@pilotiq-pro/ai`'s `update_form_state` tool push suggestions that target
- * the whole field — no `meta.editorRange`, just `suggestedValue` as a string.
- * Without `editorRange` the bridge can't render the inline-diff chip widget
- * (it has nowhere to anchor), so the host renderer passes an
- * `onApplyWholeField(value)` callback. When the chat-sidebar Approve fires
- * for a non-bridge-pushed id, the registered applier calls this callback
- * instead of no-op'ing — letting each renderer apply the suggestion the
- * right way for its shape (plain text → `plainTextToDoc`, markdown → set
- * markdown source, richtext → setContent with HTML/JSON). The host is also
- * responsible for the Approve UI — FieldShell hides its legacy overlay
- * whenever a Tiptap renderer is mounted (richtext / markdown / collab text).
- */
-export interface UseAiSuggestionBridgeOptions {
-  /**
-   * Apply a whole-field suggestion that lacks `meta.editorRange`. Each
-   * Tiptap renderer passes its own implementation (different content
-   * shapes — plain text, markdown source, HTML/JSON). Omit for editors
-   * that should ignore whole-field suggestions entirely.
-   */
-  onApplyWholeField?: (suggestedValue: string) => void
-
-  /**
-   * Synthesize a `{ from, to }` range for whole-field suggestions so the
-   * inline-diff chip widget can render BEFORE the user approves. The
-   * extension's `applyApprove` inserts a plain text node spanning the
-   * synthesized range — safe only for editors whose schema accepts a
-   * text-node replacement covering the whole doc (CollabTextRenderer's
-   * plain-text schema fits; richtext / markdown lose formatting if
-   * approved that way). Return `undefined` to skip synthesis and fall
-   * through to the legacy `onApplyWholeField` callback (silent swap).
-   */
-  synthesizeWholeFieldRange?: (
-    editor:     Editor,
-    suggestion: PendingSuggestion,
-  ) => { from: number; to: number } | undefined
-}
-
-export function useAiSuggestionBridge(
-  editor: Editor | null,
-  fieldName: string,
-  options: UseAiSuggestionBridgeOptions = {},
-): void {
-  const { list, dismiss } = usePendingSuggestionsForField(fieldName)
-  // Scope the applier under the surrounding form's id — same reasoning
-  // as `useAiInlineDiff`: two editors with the same field name across
-  // different forms (main edit form vs. a Replicate modal, say) would
-  // otherwise race on `registerPendingSuggestionApplier(undefined, …)`
-  // and the last-mounted editor would steal every approval.
-  const formId = useFormId()
-
-  // Hold the latest `dismiss` in a ref so the editor-side listener — which
-  // installs once per editor — always reaches the up-to-date context API.
-  const dismissRef = useRef(dismiss)
-  useEffect(() => { dismissRef.current = dismiss }, [dismiss])
-
-  // Same ref pattern for the whole-field applier — captured here so the
-  // applier closure registered below stays stable across re-renders without
-  // re-registering on every option change.
-  const onApplyWholeFieldRef = useRef(options.onApplyWholeField)
-  useEffect(() => { onApplyWholeFieldRef.current = options.onApplyWholeField }, [options.onApplyWholeField])
-  const synthesizeRangeRef = useRef(options.synthesizeWholeFieldRange)
-  useEffect(() => { synthesizeRangeRef.current = options.synthesizeWholeFieldRange }, [options.synthesizeWholeFieldRange])
-
-  // Set of ids this hook pushed; used by both directions for cycle control.
-  const pushedRef = useRef<Set<string>>(new Set())
-  // Subset of `pushedRef` whose range was synthesized (no producer-supplied
-  // `meta.editorRange`). Approving these must NOT route through the chip's
-  // plain-text replace — that would clobber HTML / markdown formatting on
-  // rich editors. Instead the applier delegates to `onApplyWholeField`,
-  // which sets content via the renderer's content-shape-aware command
-  // (`setContent(plainTextToDoc(...))` / `setContent(markdownSrc)` /
-  // `setContent(html)`), then clears the chip without a doc edit.
-  const synthesizedRef = useRef<Set<string>>(new Set())
-
-  // Context → editor.
-  useEffect(() => {
-    if (!editor) return
-    const contextIds = new Set(list.map(s => s.id))
-
-    for (const s of list) {
-      if (pushedRef.current.has(s.id)) continue
-      const meta = (s.meta ?? {}) as Record<string, unknown>
-      const rawRange = meta['editorRange'] as { from?: unknown; to?: unknown } | undefined
-      let range: { from: number; to: number } | undefined
-      let isSynthesized = false
-      if (rawRange && typeof rawRange.from === 'number' && typeof rawRange.to === 'number') {
-        range = { from: rawRange.from, to: rawRange.to }
-      } else {
-        // Producer didn't supply a range — let the renderer synthesize one
-        // so the inline-diff chip widget can still render. Renderers that
-        // can't safely round-trip a plain-text replace (richtext/markdown
-        // losing formatting on approve) STILL benefit by synthesizing for
-        // visualization — the applier below routes Approve through
-        // `onApplyWholeField` for synthesized ids instead of the chip's
-        // text-node replace.
-        range = synthesizeRangeRef.current?.(editor, s)
-        if (!range) continue
-        isSynthesized = true
-      }
-      const replacement = typeof s.suggestedValue === 'string' ? s.suggestedValue : ''
-      editor.commands.addAiSuggestion({
-        id:          s.id,
-        from:        range.from,
-        to:          range.to,
-        replacement,
-        ...(s.source ? { source: s.source } : {}),
-      })
-      pushedRef.current.add(s.id)
-      if (isSynthesized) synthesizedRef.current.add(s.id)
-    }
-
-    for (const id of Array.from(pushedRef.current)) {
-      if (contextIds.has(id)) continue
-      // Context dropped the suggestion — remove from editor without
-      // mutating the doc (rejectAiSuggestion drops state only).
-      editor.commands.rejectAiSuggestion(id)
-      pushedRef.current.delete(id)
-      synthesizedRef.current.delete(id)
-    }
-  }, [editor, list])
-
-  // Editor → context.
-  useEffect(() => {
-    if (!editor) return
-    const handler = () => {
-      const ps = aiSuggestionPluginKey.getState(editor.state)
-      if (!ps) return
-      const editorIds = new Set(ps.suggestions.map((s: { id: string }) => s.id))
-      for (const id of Array.from(pushedRef.current)) {
-        if (editorIds.has(id)) continue
-        // Chip removed the suggestion (Approve mutated the doc, Reject did
-        // not — either way it's gone from editor state). Mirror to context.
-        pushedRef.current.delete(id)
-        dismissRef.current(id)
-      }
-    }
-    editor.on('transaction', handler)
-    return () => { editor.off('transaction', handler) }
-  }, [editor])
-
-  // Cross-tree applier (Phase 8.5). When an aggregate consumer (e.g. a
-  // chat-sidebar pending-pill) calls `pendingSuggestions.approve(id)`,
-  // the pro provider looks up the applier registered for this
-  // `(formId, fieldName)` and invokes it. We translate that into the
-  // editor's own approve command — same path the inline chip click takes.
-  useEffect(() => {
-    if (!editor) return
-    const applier: PendingSuggestionApplier = (suggestion) => {
-      const apply = onApplyWholeFieldRef.current
-      const hasSynthesized = synthesizedRef.current.has(suggestion.id)
-      const hasPushed      = pushedRef.current.has(suggestion.id)
-
-      // Synthesized whole-field range — the chip rendered for visualization,
-      // but routing Approve through the editor's `approveAiSuggestion` would
-      // do a plain-text replace and clobber HTML / markdown formatting.
-      // Delegate to the renderer-supplied applier (content-shape-aware)
-      // and clear the chip state without a doc edit.
-      if (hasSynthesized && apply && typeof suggestion.suggestedValue === 'string') {
-        apply(suggestion.suggestedValue)
-        editor.commands.rejectAiSuggestion(suggestion.id)
-        return
-      }
-      // Producer-supplied editor range — surgical edit. Forward Approve to
-      // the editor command; the transaction listener above mirrors the
-      // dismiss back into context.
-      if (hasPushed) {
-        editor.chain().focus().approveAiSuggestion(suggestion.id).run()
-        return
-      }
-      // Whole-field path WITHOUT visualization — producer skipped the range
-      // and the renderer didn't synthesize. Same applier as above, no chip
-      // to clear. Context's `approve()` dismisses the queue entry.
-      if (apply && typeof suggestion.suggestedValue === 'string') {
-        apply(suggestion.suggestedValue)
-      }
-    }
-    // formId comes from `useFormId()` on the form-context side — scopes
-    // the registration per-form so multi-form pages route approvals to
-    // the matching editor. Falls back to wildcard (`undefined`) when no
-    // FormRenderer is up-tree (modal action schemas, action-modal forms
-    // mounted outside the main page form).
-    return registerPendingSuggestionApplier(formId, fieldName, applier)
-  }, [editor, fieldName, formId])
-}
-
-// Re-export the pending-suggestion type for consumers that import the hook
-// from this module directly — saves them a separate `@pilotiq/pilotiq/react`
-// import when wiring an external producer.
-export type { PendingSuggestion }

package/src/register.test.ts

@@ -1,14 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { getFieldRenderer } from '@pilotiq/pilotiq/react'
-
-import { registerTiptap } from './register.js'
-
-describe('registerTiptap', () => {
-  it('installs a renderer for fieldType="richtext"', () => {
-    assert.equal(getFieldRenderer('richtext'), undefined)
-    registerTiptap()
-    const renderer = getFieldRenderer('richtext')
-    assert.equal(typeof renderer, 'function')
-  })
-})

package/src/register.ts

@@ -1,42 +0,0 @@
-import { registerFieldRenderer, registerCollabTextRenderer, registerMarkdownEditor } from '@pilotiq/pilotiq/react'
-import { registerRichTextRenderer } from '@pilotiq/pilotiq/richtext'
-import { TiptapEditor } from './react/TiptapEditor.js'
-import { CollabTextRenderer } from './react/CollabTextRenderer.js'
-import { MarkdownEditor } from './react/MarkdownEditor.js'
-import { renderRichTextToHtml, isRichTextValue } from './render.js'
-
-/**
- * Register the Tiptap editor as the pilotiq renderer for `fieldType: 'richtext'`.
- *
- * Call once in your app's client-side entry point:
- *
- * ```ts
- * import { registerTiptap } from '@pilotiq/tiptap'
- * registerTiptap()
- * ```
- *
- * Also wires the read-side renderer (`@pilotiq/pilotiq/richtext`) so that
- * `TextEntry` / `TextColumn` auto-detect Tiptap content and render finished
- * HTML on `ViewPage` / list tables — without shipping the editor parser to
- * display-only pages.
- *
- * Without this call, `RichTextField` form fields render as nothing —
- * pilotiq's SchemaRenderer can't find a renderer for the `'richtext'` type.
- */
-export function registerTiptap(): void {
-  registerFieldRenderer('richtext', TiptapEditor)
-  registerRichTextRenderer(renderRichTextToHtml, isRichTextValue)
-  // Phase B — opt every plain-text field in the panel into y-prosemirror
-  // backing when collab is on. `TextLikeInput` checks this registry; if it's
-  // populated AND a `<RecordCollabRoom>` is up-tree AND the field hasn't opted
-  // out via `.collab(false)`, the renderer mounts `CollabTextRenderer`
-  // instead of the legacy `Y.Text` + `computeDelta` + `preserveCursor` path.
-  registerCollabTextRenderer(CollabTextRenderer)
-  // WYSIWYG markdown editor — replaces `MarkdownField`'s legacy textarea +
-  // manual-toolbar path with a real rich editor that serializes to markdown
-  // via `tiptap-markdown` on every change. Collab-aware on the same
-  // `useCollabRoom()` + `getCollabExtensions()` plumbing as the rich-text
-  // editor. Without `@pilotiq/tiptap` installed, `MarkdownInput` falls back
-  // to the textarea path so panels that skip the adapter still work.
-  registerMarkdownEditor(MarkdownEditor)
-}