@pilotiq/tiptap 3.19.2 → 3.20.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @pilotiq/tiptap
 
+## 3.20.0
+
+### Minor Changes
+
+- 47c8187: Custom blocks now edit inline (accordion) instead of in a right-docked side panel.
+
+  Clicking **Edit** on an inserted custom block (`Block.make().schema([...])`) expands the block in place and renders its schema as a `FormFields` form; edits write straight back onto the node via `updateAttributes({ blockData })` on every change — no popup, no save button.
+
+  This replaces the `BlockSidePanel` and removes the machinery that existed only to host the form outside the NodeView: the `onEdit` bridge + `Mod-e` shortcut on `BlockNodeExtension`, and the host-side `selectedBlock` state / position-remapping in `TiptapEditor`. The form lives in a `contentEditable=false` region with event guards so ProseMirror never treats the inputs as document content. Pure `coerceBlockValues` / `readBlockFieldValue` helpers moved to `react/blockValues.ts`.
+
+### Patch Changes
+
+- 1a1026d: Inline format toolbar visibility fixed for block nodes (#155).
+
+  Two adjustments to `shouldShowFloatingToolbar`:
+
+  - **Hidden on a whole-node block selection.** Clicking a schema-form custom block card (`pilotiqBlock`), an image, an hr, or picking a whole Alert via the drag handle produces a `NodeSelection` with no inline text to format — the bold/italic/link toolbar no longer appears for any of these. Previously only the built-in `alert` block was special-cased, so custom block cards still surfaced the toolbar.
+  - **Shown inside the Alert block's editable text.** The Alert block has an editable title and body; the mark toolbar now works there like anywhere else. An earlier fix over-suppressed the entire Alert (including its editable text) — that suppression is reversed; only the whole-node pick is hidden now.
+
 ## 3.19.2
 
 ### Patch Changes

package/dist/extensions/BlockNodeExtension.d.ts

@@ -17,15 +17,6 @@ export interface BlockNodeOptions {
      * registry data via React context.
      */
     blocks: BlockMeta[];
-    /**
-     * Bridge from the NodeView's separate React tree back to the editor's
-     * own tree, where the side panel lives. Set by `TiptapEditor` so the
-     * "Edit" button on each block can request the panel open against this
-     * specific node. `undefined` means no host is listening — the NodeView
-     * falls back to a no-op (does not render an Edit affordance, or does
-     * so disabled, depending on the consumer's chrome).
-     */
-    onEdit?: (pos: number) => void;
 }
 /**
  * Single ProseMirror node type that represents every custom block. The

package/dist/extensions/BlockNodeExtension.js

@@ -25,9 +25,6 @@ export const BlockNodeExtension = Node.create({
     // dispatch — even before any block was inserted.
     draggable: true,
     addOptions() {
-        // `onEdit` intentionally omitted — `exactOptionalPropertyTypes` makes
-        // an explicit `undefined` non-assignable to the optional field, and
-        // the host wires it via `BlockNodeExtension.configure({ onEdit })`.
         return { blocks: [] };
     },
     addAttributes() {
@@ -82,21 +79,4 @@ export const BlockNodeExtension = Node.create({
             }),
         };
     },
-    // `Mod-e` opens the side panel for the currently NodeSelected block.
-    // Returns false when no block is selected so the browser's default
-    // (Safari "Use Selection for Find", etc.) still applies in plain text.
-    addKeyboardShortcuts() {
-        return {
-            'Mod-e': () => {
-                const onEdit = this.options.onEdit;
-                if (!onEdit)
-                    return false;
-                const sel = this.editor.state.selection;
-                if (sel.node?.type.name !== this.name)
-                    return false;
-                onEdit(sel.from);
-                return true;
-            },
-        };
-    },
 });

package/dist/react/BlockNodeView.d.ts

@@ -1,19 +1,30 @@
 import { type NodeViewProps } from '@tiptap/react';
 /**
- * Generic React NodeView for the `pilotiqBlock` ProseMirror node. Reads
- * the block type from `node.attrs.blockType`, looks up its `BlockMeta`
- * in `BlockNodeExtension.options.blocks`, and renders a compact inline
- * summary card with an "Edit" button.
+ * React NodeView for the `pilotiqBlock` ProseMirror node. Reads the block
+ * type from `node.attrs.blockType`, looks up its `BlockMeta` in
+ * `BlockNodeExtension.options.blocks`, and renders a compact summary card.
  *
- * Editing happens in a side panel hosted by `TiptapEditor`, NOT inline.
- * The NodeView fires `BlockNodeExtension.options.onEdit(getPos())` when
- * the Edit button is clicked; the host opens its panel anchored to the
- * editor wrapper. NodeViews live in a separate React tree from the host
- * editor, so the bridge has to go through extension options — context
- * doesn't cross trees.
+ * Editing is **inline** (accordion): clicking the card (or the Edit chevron)
+ * expands a panel below the summary that hosts the block's `Block.schema([…])`
+ * as a real pilotiq form via `<FormFields>`. Edits write straight back onto
+ * the node with `updateAttributes({ blockData })` on every change — the
+ * NodeView already owns the node, so there's no host bridge / side panel /
+ * position-remapping to thread through.
  *
- * If no `onEdit` is wired (e.g. a consumer that uses `BlockNodeExtension`
- * standalone without `TiptapEditor`'s panel), the Edit button is hidden.
+ * The form is rendered in a `contentEditable={false}` region and every input
+ * event is stopped from bubbling into ProseMirror, so the editor never treats
+ * the form inputs as document content or hijacks their focus/selection.
+ *
+ * Reads: each field's `defaultValue` is overridden from the block's stored
+ * `blockData`, snapshotted once per expand into `initialValuesRef`. Inputs are
+ * uncontrolled (outside a `FormStateProvider`, pilotiq's renderers fall back to
+ * `defaultValue`), so write-back transactions re-rendering the NodeView never
+ * reset the user's in-progress typing.
+ *
+ * Writes: container-level `onInput` / `onChange` delegation. Every change
+ * snapshots the whole form via `new FormData(formEl)` → `parseFormDataToNested`
+ * (rebuilds nested arrays/objects from dotted-path inputs like `items.0.title`)
+ * → `coerceBlockValues` (per-fieldType JSON parse / boolean / number coerce).
  */
 export declare function BlockNodeView(props: NodeViewProps): import("react").JSX.Element | null;
 //# sourceMappingURL=BlockNodeView.d.ts.map

package/dist/react/BlockNodeView.js

@@ -1,33 +1,52 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { NodeViewWrapper } from '@tiptap/react';
+import { FormFields, parseFormDataToNested } from '@pilotiq/pilotiq/react';
+import { coerceBlockValues } from './blockValues.js';
 /**
- * Generic React NodeView for the `pilotiqBlock` ProseMirror node. Reads
- * the block type from `node.attrs.blockType`, looks up its `BlockMeta`
- * in `BlockNodeExtension.options.blocks`, and renders a compact inline
- * summary card with an "Edit" button.
+ * React NodeView for the `pilotiqBlock` ProseMirror node. Reads the block
+ * type from `node.attrs.blockType`, looks up its `BlockMeta` in
+ * `BlockNodeExtension.options.blocks`, and renders a compact summary card.
  *
- * Editing happens in a side panel hosted by `TiptapEditor`, NOT inline.
- * The NodeView fires `BlockNodeExtension.options.onEdit(getPos())` when
- * the Edit button is clicked; the host opens its panel anchored to the
- * editor wrapper. NodeViews live in a separate React tree from the host
- * editor, so the bridge has to go through extension options — context
- * doesn't cross trees.
+ * Editing is **inline** (accordion): clicking the card (or the Edit chevron)
+ * expands a panel below the summary that hosts the block's `Block.schema([…])`
+ * as a real pilotiq form via `<FormFields>`. Edits write straight back onto
+ * the node with `updateAttributes({ blockData })` on every change — the
+ * NodeView already owns the node, so there's no host bridge / side panel /
+ * position-remapping to thread through.
  *
- * If no `onEdit` is wired (e.g. a consumer that uses `BlockNodeExtension`
- * standalone without `TiptapEditor`'s panel), the Edit button is hidden.
+ * The form is rendered in a `contentEditable={false}` region and every input
+ * event is stopped from bubbling into ProseMirror, so the editor never treats
+ * the form inputs as document content or hijacks their focus/selection.
+ *
+ * Reads: each field's `defaultValue` is overridden from the block's stored
+ * `blockData`, snapshotted once per expand into `initialValuesRef`. Inputs are
+ * uncontrolled (outside a `FormStateProvider`, pilotiq's renderers fall back to
+ * `defaultValue`), so write-back transactions re-rendering the NodeView never
+ * reset the user's in-progress typing.
+ *
+ * Writes: container-level `onInput` / `onChange` delegation. Every change
+ * snapshots the whole form via `new FormData(formEl)` → `parseFormDataToNested`
+ * (rebuilds nested arrays/objects from dotted-path inputs like `items.0.title`)
+ * → `coerceBlockValues` (per-fieldType JSON parse / boolean / number coerce).
  */
 export function BlockNodeView(props) {
-    const { editor, node, getPos, deleteNode } = props;
+    const { editor, node, deleteNode, updateAttributes } = props;
     const blockType = String(node.attrs['blockType'] ?? '');
     const blockData = node.attrs['blockData'] ?? {};
+    const editable = editor.isEditable;
     // Tiptap mounts NodeViews in a separate React tree, so we can't read the
     // block registry through context. Pull it off the extension's options
     // instead — set by RichTextField via BlockNodeExtension.configure({ blocks }).
     const blockExt = editor.extensionManager.extensions.find((e) => e.name === 'pilotiqBlock');
     const blocks = blockExt?.options['blocks'] ?? [];
-    const onEdit = blockExt?.options['onEdit'];
     const meta = blocks.find((b) => b.name === blockType);
+    const [expanded, setExpanded] = useState(false);
+    // Seeds the form's `defaultValue`s. Re-snapshotted from the live node each
+    // time the panel opens; not updated mid-edit (uncontrolled inputs hold their
+    // own state while open).
+    const initialValuesRef = useRef(blockData);
+    const formRef = useRef(null);
     // Self-heal: a block with no `blockType` is malformed — almost always
     // means a stale node from a prior buggy insert. Delete it on mount so
     // the editor doesn't get stuck in an unrecoverable state.
@@ -47,13 +66,28 @@ export function BlockNodeView(props) {
     })
         .filter(Boolean)
         .join(' · ') || meta.label;
-    const handleEdit = () => {
-        if (!onEdit)
+    const toggleExpanded = () => {
+        if (!editable)
             return;
-        const pos = getPos();
-        if (typeof pos !== 'number')
+        setExpanded((prev) => {
+            const next = !prev;
+            if (next) {
+                initialValuesRef.current =
+                    node.attrs['blockData'] ?? {};
+            }
+            return next;
+        });
+    };
+    const handleChange = () => {
+        const formEl = formRef.current;
+        if (!formEl)
             return;
-        onEdit(pos);
+        const raw = parseFormDataToNested(new FormData(formEl));
+        const coerced = coerceBlockValues(raw, meta.schema);
+        updateAttributes({ blockData: coerced });
     };
-    return (_jsx(NodeViewWrapper, { className: "pilotiq-block my-3 rounded-lg border bg-muted/30", children: _jsxs("div", { className: "flex items-start justify-between gap-2 px-3 py-2", children: [_jsxs("button", { type: "button", onClick: handleEdit, disabled: !onEdit, className: "flex items-center gap-2 text-left text-sm disabled:cursor-default", children: [meta.icon && _jsx("span", { "aria-hidden": "true", children: meta.icon }), _jsx("span", { className: "font-medium", children: meta.label }), _jsx("span", { className: "text-xs text-muted-foreground line-clamp-1", children: summary })] }), _jsxs("div", { className: "flex items-center gap-2", children: [onEdit && (_jsx("button", { type: "button", onClick: handleEdit, className: "text-xs text-muted-foreground hover:text-foreground", children: "Edit" })), _jsx("button", { type: "button", onClick: () => deleteNode(), className: "text-xs text-destructive hover:underline", children: "Remove" })] })] }) }));
+    return (_jsxs(NodeViewWrapper, { className: "pilotiq-block my-3 rounded-lg border bg-muted/30", children: [_jsxs("div", { className: "flex items-start justify-between gap-2 px-3 py-2", children: [_jsxs("button", { type: "button", onClick: toggleExpanded, disabled: !editable, className: "flex min-w-0 items-center gap-2 text-left text-sm disabled:cursor-default", children: [meta.icon && _jsx("span", { "aria-hidden": "true", children: meta.icon }), _jsx("span", { className: "font-medium", children: meta.label }), _jsx("span", { className: "line-clamp-1 text-xs text-muted-foreground", children: summary })] }), editable && (_jsxs("div", { className: "flex shrink-0 items-center gap-2", children: [_jsxs("button", { type: "button", onClick: toggleExpanded, "aria-expanded": expanded, className: "flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground", children: [expanded ? 'Done' : 'Edit', _jsx("svg", { viewBox: "0 0 24 24", className: 'size-3.5 transition-transform ' + (expanded ? 'rotate-180' : ''), fill: "none", stroke: "currentColor", strokeWidth: 2, strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": true, children: _jsx("path", { d: "m6 9 6 6 6-6" }) })] }), _jsx("button", { type: "button", onClick: () => deleteNode(), className: "text-xs text-destructive hover:underline", children: "Remove" })] }))] }), expanded && editable && (
+            // contentEditable=false + event guards keep ProseMirror from treating
+            // the form inputs as document content or stealing their focus/caret.
+            _jsx("div", { contentEditable: false, className: "border-t px-3 py-3", onMouseDown: (e) => e.stopPropagation(), onPointerDown: (e) => e.stopPropagation(), onKeyDown: (e) => e.stopPropagation(), onKeyUp: (e) => e.stopPropagation(), onPaste: (e) => e.stopPropagation(), onDrop: (e) => e.stopPropagation(), children: _jsx("form", { ref: formRef, onInput: handleChange, onChange: handleChange, onSubmit: (e) => e.preventDefault(), className: "flex flex-col gap-3", children: _jsx(FormFields, { elements: meta.schema, values: initialValuesRef.current }) }) }))] }));
 }

package/dist/react/TiptapEditor.js

@@ -34,7 +34,6 @@ import { MentionMenu } from './MentionMenu.js';
 import { FloatingToolbar } from './FloatingToolbar.js';
 import { TableFloatingToolbar } from './TableFloatingToolbar.js';
 import { Toolbar, AttachFilesDialog, useEditorTick } from './Toolbar.js';
-import { BlockSidePanel } from './BlockSidePanel.js';
 /**
  * The pilotiq field renderer for `RichTextField`. Registered globally via
  * `registerTiptap()`; pilotiq's `SchemaRenderer` looks it up by `fieldType:
@@ -168,36 +167,9 @@ function ClientEditor(props) {
             setMentionDismissed(false);
         setRawMentionState(s);
     }, []);
-    // Custom-block side panel — opens when a block's NodeView fires its
-    // Edit button. The NodeView lives in a separate React tree and reaches
-    // us via `BlockNodeExtension.options.onEdit` (set during configure()
-    // below). Stores `pos` + `blockType` at open-time; `BlockSidePanel`
-    // tracks the position forward through transactions and writes attrs
-    // back via setNodeMarkup. Closing nullifies the slot — re-opening
-    // remounts the panel fresh, including a re-snapshot of `blockData`.
-    const [selectedBlock, setSelectedBlock] = useState(null);
-    const handleEditBlock = useCallback((pos) => {
-        // We resolve `blockType` here against the current doc so a stale
-        // pos (e.g. the block was just deleted before the click landed)
-        // produces a no-op rather than an empty panel.
-        setSelectedBlock((prev) => {
-            // Read from the editor lazily — the editor ref isn't stable yet
-            // on the very first render where this callback is created, so
-            // defer the lookup to call time.
-            const ed = editorRef.current;
-            if (!ed)
-                return prev;
-            const node = ed.state.doc.nodeAt(pos);
-            if (!node || node.type.name !== 'pilotiqBlock')
-                return prev;
-            return { pos, blockType: String(node.attrs['blockType'] ?? '') };
-        });
-    }, []);
-    const closeBlockPanel = useCallback(() => { setSelectedBlock(null); }, []);
-    // editorRef gives the onEdit callback access to the editor instance
-    // without re-creating the callback on every render (which would force
-    // the extension config to re-evaluate, triggering a full editor reset).
-    const editorRef = useRef(null);
+    // Custom blocks (`pilotiqBlock`) edit inline now — the NodeView expands an
+    // accordion form and writes attrs back via `updateAttributes` itself, so the
+    // host needs no side panel, no `onEdit` bridge, and no position tracking.
     // Resolve the collab-attached extensions once per editor build.
     // `Collaboration` is constructed eagerly here (during `useEditor`'s
     // first call); the keyed remount above guarantees we never swap it.
@@ -283,10 +255,9 @@ function ClientEditor(props) {
             Placeholder.configure({ placeholder: placeholder ?? 'Start writing…' }),
             // BlockNodeExtension carries the block registry on its options —
             // NodeViews mount in a separate React tree and can't see context.
-            // `onEdit` is the bridge back to the host editor's tree where the
-            // side panel lives; the NodeView's Edit button calls it with its
-            // own `getPos()`.
-            BlockNodeExtension.configure({ blocks, onEdit: handleEditBlock }),
+            // The NodeView edits inline (accordion) and writes back itself, so no
+            // host callback is threaded here.
+            BlockNodeExtension.configure({ blocks }),
             ...(slashEnabled ? [SlashCommandExtension.configure({
                     blocks,
                     mergeTags,
@@ -400,12 +371,6 @@ function ClientEditor(props) {
         if (debounceRef.current)
             clearTimeout(debounceRef.current);
     }, []);
-    // Mirror the editor instance into a ref so callbacks captured during
-    // `useEditor`'s extension config (notably the BlockNode `onEdit`
-    // bridge) can reach the live editor without re-creating themselves
-    // every render. Re-creation would force the editor to rebuild from
-    // scratch on every keystroke.
-    useEffect(() => { editorRef.current = editor ?? null; }, [editor]);
     // Mirror `disabled` onto the live editor at runtime. `useEditor`'s
     // `editable: !disabled` only fires at construction time, so a parent
     // flipping read-only after mount (e.g. policy denial mid-edit, form
@@ -505,7 +470,7 @@ function ClientEditor(props) {
                         onAcceptViaEditor: () => editor.commands.acceptAiInlineDiff(),
                         onRejectViaEditor: () => editor.commands.rejectAiInlineDiff(),
                     }
-                    : {}) }), editor && floatingEnabled && _jsx(FloatingToolbar, { editor: editor }), editor && _jsx(TableFloatingToolbar, { editor: editor }), _jsx(SlashPopover, { state: slashState, keyHandlerRef: slashKeyRef }), _jsx(MentionPopover, { state: mentionState, keyHandlerRef: mentionKeyRef }), editor && selectedBlock && (_jsx(BlockSidePanel, { editor: editor, initialPos: selectedBlock.pos, blockType: selectedBlock.blockType, blocks: blocks, onClose: closeBlockPanel }, `${selectedBlock.pos}:${selectedBlock.blockType}`))] }));
+                    : {}) }), editor && floatingEnabled && _jsx(FloatingToolbar, { editor: editor }), editor && _jsx(TableFloatingToolbar, { editor: editor }), _jsx(SlashPopover, { state: slashState, keyHandlerRef: slashKeyRef }), _jsx(MentionPopover, { state: mentionState, keyHandlerRef: mentionKeyRef })] }));
 }
 /**
  * Cursor-anchored popover for the mention menu. Same Floating-UI / virtual-

package/dist/react/blockValues.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Pure value-coercion helpers for custom-block (`pilotiqBlock`) form data.
+ *
+ * The inline accordion editor in `BlockNodeView` snapshots its `<form>` via
+ * `new FormData(formEl)` → `parseFormDataToNested` (rebuilds nested arrays /
+ * objects from dotted-path inputs like `items.0.title`) → `coerceBlockValues`
+ * (per-fieldType JSON parse / boolean / number coerce so nested-shape fields
+ * round-trip in their canonical wire form) before writing the result back onto
+ * the node via `updateAttributes({ blockData })`.
+ *
+ * No React, no DOM, no editor — exported for unit tests.
+ */
+/**
+ * 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
+ * inline block editor — top-level block fields plus the immediate
+ * children of any Repeater rows / Builder rows.data.
+ *
+ * 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.
+ */
+export declare function coerceBlockValues(raw: Record<string, unknown>, schema: ReadonlyArray<Record<string, unknown>>): Record<string, unknown>;
+/**
+ * Read the resolved field value for a given input event target. Maps a
+ * single-input change onto its coerced wire shape — string passthrough
+ * for the common case; explicit coercion for booleans and numerics so
+ * the round-trip into the node attrs preserves shape. Exported for tests.
+ */
+export declare function readBlockFieldValue(target: {
+    type?: string;
+    value: string;
+    checked?: boolean;
+}, fieldMeta: {
+    fieldType?: unknown;
+}): unknown;
+//# sourceMappingURL=blockValues.d.ts.map

package/dist/react/blockValues.js

@@ -0,0 +1,161 @@
+/**
+ * Pure value-coercion helpers for custom-block (`pilotiqBlock`) form data.
+ *
+ * The inline accordion editor in `BlockNodeView` snapshots its `<form>` via
+ * `new FormData(formEl)` → `parseFormDataToNested` (rebuilds nested arrays /
+ * objects from dotted-path inputs like `items.0.title`) → `coerceBlockValues`
+ * (per-fieldType JSON parse / boolean / number coerce so nested-shape fields
+ * round-trip in their canonical wire form) before writing the result back onto
+ * the node via `updateAttributes({ blockData })`.
+ *
+ * No React, no DOM, no editor — exported for unit tests.
+ */
+/**
+ * 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
+ * inline block editor — top-level block fields plus the immediate
+ * children of any Repeater rows / Builder rows.data.
+ *
+ * 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.
+ */
+export function coerceBlockValues(raw, schema) {
+    const out = { ...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, ft, field) {
+    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'] ?? [];
+            return value.map((row) => {
+                if (!row || typeof row !== 'object')
+                    return {};
+                return coerceBlockValues(row, template);
+            });
+        }
+        case 'builder': {
+            if (!Array.isArray(value))
+                return [];
+            const blockMetas = field['blocks'] ?? [];
+            return value.map((row) => {
+                if (!row || typeof row !== 'object')
+                    return { type: '', data: {} };
+                const r = row;
+                const type = String(r['type'] ?? '');
+                const data = r['data'] ?? {};
+                const block = blockMetas.find((b) => String(b['name'] ?? '') === type);
+                if (!block)
+                    return { type, data };
+                const tpl = block['template'] ?? [];
+                return { type, data: coerceBlockValues(data, tpl) };
+            });
+        }
+        default:
+            return value === undefined ? '' : value;
+    }
+}
+function coerceNumber(value) {
+    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) {
+    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) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== 'string' || value === '')
+        return {};
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch { /* fall through */ }
+    return {};
+}
+/**
+ * Read the resolved field value for a given input event target. Maps a
+ * single-input change onto its coerced wire shape — string passthrough
+ * for the common case; explicit coercion for booleans and numerics so
+ * the round-trip into the node attrs preserves shape. Exported for tests.
+ */
+export function readBlockFieldValue(target, fieldMeta) {
+    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;
+}

package/dist/react/floatingToolbarVisibility.d.ts

@@ -1,4 +1,4 @@
-import type { EditorState } from '@tiptap/pm/state';
+import { type EditorState } from '@tiptap/pm/state';
 /**
  * Inline marks the `FloatingToolbar` can toggle — bold / italic / strike /
  * code / link. A caret (empty selection) sitting inside any of these surfaces
@@ -10,7 +10,14 @@ export declare const TOOLBAR_MARKS: readonly ["bold", "italic", "strike", "code"
  * Whether the selection-based `FloatingToolbar` should be visible. A PURE
  * decision (no DOM / coords) so it's unit-testable against the real schema:
  *
- *  - never inside a callout/alert block — it owns its own chrome (#155);
+ *  - never on a whole-node selection of a non-text block — a schema-form
+ *    custom block card (`pilotiqBlock`), an image, an hr, or a whole Alert
+ *    block picked via the drag handle has no inline text to format, so it
+ *    must not surface the mark toolbar (#155);
+ *  - the toolbar DOES show for text inside the Alert's editable title/body —
+ *    those are real editable text nodes, so the formatting actions should
+ *    work there like anywhere else (an earlier over-correction suppressed the
+ *    whole Alert, including its editable text);
  *  - a caret (empty selection) shows ONLY when it sits inside a formatting
  *    mark (link / bold / …) so the mark can be edited without selecting (#156);
  *  - a non-empty range shows whenever it actually spans inline content (the

package/dist/react/floatingToolbarVisibility.js

@@ -1,4 +1,4 @@
-import { isSelectionInAlert } from '../extensions/contentBlocks.js';
+import { NodeSelection } from '@tiptap/pm/state';
 /**
  * Inline marks the `FloatingToolbar` can toggle — bold / italic / strike /
  * code / link. A caret (empty selection) sitting inside any of these surfaces
@@ -23,15 +23,24 @@ function caretInToolbarMark(state) {
  * Whether the selection-based `FloatingToolbar` should be visible. A PURE
  * decision (no DOM / coords) so it's unit-testable against the real schema:
  *
- *  - never inside a callout/alert block — it owns its own chrome (#155);
+ *  - never on a whole-node selection of a non-text block — a schema-form
+ *    custom block card (`pilotiqBlock`), an image, an hr, or a whole Alert
+ *    block picked via the drag handle has no inline text to format, so it
+ *    must not surface the mark toolbar (#155);
+ *  - the toolbar DOES show for text inside the Alert's editable title/body —
+ *    those are real editable text nodes, so the formatting actions should
+ *    work there like anywhere else (an earlier over-correction suppressed the
+ *    whole Alert, including its editable text);
  *  - a caret (empty selection) shows ONLY when it sits inside a formatting
  *    mark (link / bold / …) so the mark can be edited without selecting (#156);
  *  - a non-empty range shows whenever it actually spans inline content (the
  *    `childCount === 0` guard skips degenerate full-block selections).
  */
 export function shouldShowFloatingToolbar(state) {
-    if (isSelectionInAlert(state.selection))
+    const sel = state.selection;
+    if (sel instanceof NodeSelection && sel.node.isBlock && !sel.node.isTextblock) {
         return false;
+    }
     if (state.selection.empty)
         return caretInToolbarMark(state);
     const { from, to } = state.selection;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pilotiq/tiptap",
-  "version": "3.19.2",
+  "version": "3.20.0",
   "description": "Tiptap rich-text editor adapter for @pilotiq/pilotiq — slash menu, draggable blocks, custom-block API",
   "license": "MIT",
   "repository": {

package/dist/react/BlockSidePanel.d.ts

@@ -1,105 +0,0 @@
-import type { Editor } from '@tiptap/react';
-import type { BlockMeta } from '../Block.js';
-/**
- * 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 declare function BlockSidePanel({ editor, initialPos, blockType, blocks, onClose, }: BlockSidePanelProps): React.ReactElement | null;
-/**
- * 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 declare function clampPanelWidth(value: unknown): number;
-/**
- * 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 declare function coerceBlockValues(raw: Record<string, unknown>, schema: ReadonlyArray<Record<string, unknown>>): Record<string, unknown>;
-/**
- * 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 declare function readBlockFieldValue(target: {
-    type?: string;
-    value: string;
-    checked?: boolean;
-}, fieldMeta: {
-    fieldType?: unknown;
-}): unknown;
-//# sourceMappingURL=BlockSidePanel.d.ts.map

package/dist/react/BlockSidePanel.js

@@ -1,338 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { FormFields, parseFormDataToNested, clampPanelWidth as clampPanelWidthShared, useResizableWidth, } from '@pilotiq/pilotiq/react';
-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(',');
-export function BlockSidePanel({ editor, initialPos, blockType, blocks, onClose, }) {
-    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(initialPos);
-    const posRef = useRef(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(pos !== null ? readBlockData(editor, pos) : {});
-    const asideRef = useRef(null);
-    const formRef = useRef(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);
-        const aside = asideRef.current;
-        if (aside) {
-            const first = aside.querySelector(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) => {
-            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;
-            if (!active || !aside.contains(active))
-                return;
-            const focusables = Array.from(aside.querySelectorAll(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 }) => {
-            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) => {
-        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.view;
-        const state = editor.state;
-        const tr = state.tr.setNodeMarkup(at, null, { blockType, blockData: nextValues });
-        view.dispatch(tr);
-    }, [editor, blockType]);
-    const handleChange = useCallback(() => {
-        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 (_jsxs("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", children: [_jsx("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" }), _jsxs("header", { className: "sticky top-0 z-10 flex items-center justify-between gap-2 border-b bg-background px-3 py-2", children: [_jsxs("div", { className: "flex items-center gap-2 min-w-0", children: [meta.icon && _jsx("span", { "aria-hidden": "true", children: meta.icon }), _jsx("span", { className: "text-sm font-medium truncate", children: meta.label })] }), _jsx("button", { type: "button", onClick: onClose, "aria-label": "Close panel", className: "text-muted-foreground hover:text-foreground text-sm", children: "\u00D7" })] }), _jsx("form", { ref: formRef, onInput: handleChange, onChange: handleChange, onSubmit: (e) => { e.preventDefault(); }, className: "flex flex-col gap-3 px-3 py-3", children: _jsx(FormFields, { elements: meta.schema, values: initialValuesRef.current }) })] }));
-}
-/**
- * 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) {
-    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, schema) {
-    const out = { ...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, ft, field) {
-    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'] ?? [];
-            return value.map((row) => {
-                if (!row || typeof row !== 'object')
-                    return {};
-                return coerceBlockValues(row, template);
-            });
-        }
-        case 'builder': {
-            if (!Array.isArray(value))
-                return [];
-            const blockMetas = field['blocks'] ?? [];
-            return value.map((row) => {
-                if (!row || typeof row !== 'object')
-                    return { type: '', data: {} };
-                const r = row;
-                const type = String(r['type'] ?? '');
-                const data = r['data'] ?? {};
-                const block = blockMetas.find((b) => String(b['name'] ?? '') === type);
-                if (!block)
-                    return { type, data };
-                const tpl = block['template'] ?? [];
-                return { type, data: coerceBlockValues(data, tpl) };
-            });
-        }
-        default:
-            return value === undefined ? '' : value;
-    }
-}
-function coerceNumber(value) {
-    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) {
-    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) {
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-        return value;
-    }
-    if (typeof value !== 'string' || value === '')
-        return {};
-    try {
-        const parsed = JSON.parse(value);
-        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-            return parsed;
-        }
-    }
-    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, fieldMeta) {
-    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;
-}
-function readBlockData(editor, pos) {
-    const node = nodeAt(editor, pos);
-    if (!node)
-        return {};
-    return node.attrs['blockData'] ?? {};
-}
-function nodeAt(editor, pos) {
-    try {
-        return editor.state.doc.nodeAt(pos);
-    }
-    catch {
-        return null;
-    }
-}