@prolibu-suite/cobalt-core 0.10.4 → 0.11.0

package/dist/esm/{index-BBIYyvq-.js → pagination-D9OfZUnY.js}

@@ -1,5 +1,4 @@
 import { p as purify } from './purify.es-B2QLgWrz.js';
-import { C as COLOR_PALETTE, T as TABLE_CONTEXT_ITEMS, t as toolbarItems } from './toolbar-config-BAYo-RBt.js';
 
 // ::- Persistent data structure representing an ordered mapping from
 // strings to values, with some convenient update methods.
@@ -2655,7 +2654,7 @@ A DOM parser represents a strategy for parsing DOM content into a
 ProseMirror document conforming to a given schema. Its behavior is
 defined by an array of [rules](https://prosemirror.net/docs/ref/#model.ParseRule).
 */
-class DOMParser {
+let DOMParser$1 = class DOMParser {
     /**
     Create a parser that targets the given schema, using the given
     parsing rules.
@@ -2806,7 +2805,7 @@ class DOMParser {
         return schema.cached.domParser ||
             (schema.cached.domParser = new DOMParser(schema, DOMParser.schemaRules(schema)));
     }
-}
+};
 const blockTags = {
     address: true, article: true, aside: true, blockquote: true, canvas: true,
     dd: true, div: true, dl: true, fieldset: true, figcaption: true, figure: true,
@@ -10005,7 +10004,7 @@ function skipIgnoredNodesBefore(view) {
                     break;
             }
         }
-        else if (isBlockNode(node)) {
+        else if (isBlockNode$1(node)) {
             break;
         }
         else {
@@ -10053,7 +10052,7 @@ function skipIgnoredNodesAfter(view) {
             else
                 break;
         }
-        else if (isBlockNode(node)) {
+        else if (isBlockNode$1(node)) {
             break;
         }
         else {
@@ -10079,7 +10078,7 @@ function skipIgnoredNodesAfter(view) {
     if (moveNode)
         setSelFocus(view, moveNode, moveOffset);
 }
-function isBlockNode(dom) {
+function isBlockNode$1(dom) {
     let desc = dom.pmViewDesc;
     return desc && desc.node && desc.node.isBlock;
 }
@@ -10359,7 +10358,7 @@ function parseFromClipboard(view, text, html, plainText, $context) {
             dom = child;
         }
     if (!slice) {
-        let parser = view.someProp("clipboardParser") || view.someProp("domParser") || DOMParser.fromSchema(view.state.schema);
+        let parser = view.someProp("clipboardParser") || view.someProp("domParser") || DOMParser$1.fromSchema(view.state.schema);
         slice = parser.parseSlice(dom, {
             preserveWhitespace: !!(asText || sliceData),
             context: $context,
@@ -12460,7 +12459,7 @@ function parseBetween(view, from_, to_) {
         }
     }
     let startDoc = view.state.doc;
-    let parser = view.someProp("domParser") || DOMParser.fromSchema(view.state.schema);
+    let parser = view.someProp("domParser") || DOMParser$1.fromSchema(view.state.schema);
     let $from = startDoc.resolve(from);
     let sel = null, doc = parser.parse(parent, {
         topNode: $from.parent,
@@ -14322,12 +14321,12 @@ function createNodeFromContent(content, schema, options) {
         })
       });
       if (options.slice) {
-        DOMParser.fromSchema(contentCheckSchema).parseSlice(
+        DOMParser$1.fromSchema(contentCheckSchema).parseSlice(
           elementFromString(content),
           options.parseOptions
         );
       } else {
-        DOMParser.fromSchema(contentCheckSchema).parse(
+        DOMParser$1.fromSchema(contentCheckSchema).parse(
           elementFromString(content),
           options.parseOptions
         );
@@ -14338,7 +14337,7 @@ function createNodeFromContent(content, schema, options) {
         });
       }
     }
-    const parser = DOMParser.fromSchema(schema);
+    const parser = DOMParser$1.fromSchema(schema);
     if (options.slice) {
       return parser.parseSlice(elementFromString(content), options.parseOptions).content;
     }
@@ -34994,6 +34993,799 @@ var Subscript = Mark.create({
   }
 });
 
+function sanitizeFieldName(raw) {
+    return String(raw ?? '')
+        .trim()
+        .replace(/\s+/g, '_')
+        .replace(/[^\p{L}\p{N}_.]/gu, '_');
+}
+/** Admite un grupo `[…]` al final del contenido (enum en JSON). Nueva instancia por llamada (flag g). */
+function fieldTokenRegex() {
+    return /\[\[\s*([^[\]]+?(?:\[[^[\]]*\])?)\s*\]\]/g;
+}
+function parseFieldToken(inner) {
+    const parts = String(inner ?? '').split('|').map((p) => p.trim());
+    let raw = parts[0] ?? '';
+    const required = raw.endsWith('*');
+    if (required)
+        raw = raw.slice(0, -1);
+    const name = sanitizeFieldName(raw);
+    if (!name)
+        return null;
+    const type = parts[1] || 'string';
+    let values = null;
+    if (parts[2]?.startsWith('enum:')) {
+        const rawEnum = parts[2].slice(5).trim();
+        try {
+            const parsed = JSON.parse(rawEnum);
+            values = Array.isArray(parsed) ? parsed.map(String) : null;
+        }
+        catch {
+            values = rawEnum.split(',').map((v) => v.trim()).filter(Boolean);
+        }
+    }
+    return { name, required, type, enum: values };
+}
+
+/** Meta de las transacciones que escribe el HOST (valores): no son edición del usuario. */
+const FIELD_SYNC_META = 'coFieldSync';
+function parseEnumAttr(raw) {
+    if (!raw)
+        return null;
+    try {
+        const v = JSON.parse(raw);
+        return Array.isArray(v) ? v.map(String) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Lista de campos en orden de primera aparición (sin repetidos). Acepta un doc de ProseMirror o su JSON. */
+function collectFields(doc, into = []) {
+    const index = new Map(into.map((f, i) => [f.name, i]));
+    const visit = (attrs) => {
+        const name = attrs?.name;
+        if (!name)
+            return;
+        const at = index.get(name);
+        if (at === undefined) {
+            index.set(name, into.length);
+            into.push({ name, required: !!attrs.required, type: attrs.type || 'string', enum: attrs.enum ?? null });
+        }
+        else if (attrs.required) {
+            into[at].required = true;
+        }
+    };
+    if (typeof doc.descendants === 'function') {
+        doc.descendants((node) => {
+            if (node.type.name === 'mergeField') {
+                visit(node.attrs);
+                return false;
+            }
+            return true;
+        });
+    }
+    else {
+        const walk = (node) => {
+            if (!node)
+                return;
+            if (node.type === 'mergeField')
+                visit(node.attrs ?? {});
+            node.content?.forEach(walk);
+        };
+        walk(doc);
+    }
+    return into;
+}
+/** Textblocks tocados por las transacciones (para no recorrer todo el doc por tecla). */
+function touchedTextblocks(transactions, state) {
+    let ranges = [];
+    transactions.forEach((tr) => {
+        // Lo tocado por transacciones anteriores se lleva a las posiciones de ésta.
+        ranges = ranges.map(([a, b]) => [tr.mapping.map(a, -1), tr.mapping.map(b, 1)]);
+        if (!tr.docChanged)
+            return;
+        tr.mapping.maps.forEach((map, i) => {
+            map.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+                const rest = tr.mapping.slice(i + 1);
+                ranges.push([rest.map(newStart, -1), rest.map(newEnd, 1)]);
+            });
+        });
+    });
+    const out = new Set();
+    const size = state.doc.content.size;
+    ranges.forEach(([from, to]) => {
+        state.doc.nodesBetween(Math.max(0, from), Math.min(size, to), (node, pos) => {
+            if (node.isTextblock) {
+                out.add(pos);
+                return false;
+            }
+            return true;
+        });
+    });
+    return Array.from(out);
+}
+const MergeField = Node3.create({
+    name: 'mergeField',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    selectable: true,
+    addOptions() {
+        return { renameLabel: 'Field name' };
+    },
+    addAttributes() {
+        return {
+            name: { default: '', parseHTML: (el) => el.getAttribute('data-variable') || '', rendered: false },
+            value: { default: '', parseHTML: (el) => el.getAttribute('data-value') ?? '', rendered: false },
+            required: { default: false, parseHTML: (el) => el.getAttribute('data-required') === 'true', rendered: false },
+            type: { default: 'string', parseHTML: (el) => el.getAttribute('data-type') || 'string', rendered: false },
+            enum: { default: null, parseHTML: (el) => parseEnumAttr(el.getAttribute('data-enum')), rendered: false },
+        };
+    },
+    // Prioridad 100: gana a las marcas `span[style]` (color/tamaño), como en V1.
+    parseHTML() {
+        return [{ tag: 'span[data-variable]', priority: 100 }];
+    },
+    // Forma canónica (spec §3.4): SIN estilos (D9), atributos en orden fijo.
+    renderHTML({ node }) {
+        const { name, value, type, required } = node.attrs;
+        const attrs = {
+            class: 'variable-node',
+            'data-variable': name,
+            'data-value': value ?? '',
+            'data-type': type || 'string',
+            'data-required': required ? 'true' : 'false',
+        };
+        if (node.attrs.enum)
+            attrs['data-enum'] = JSON.stringify(node.attrs.enum);
+        attrs.contenteditable = 'false';
+        return ['span', attrs, value || `[[${name}]]`];
+    },
+    renderText({ node }) {
+        return node.attrs.value || `[[${node.attrs.name}]]`;
+    },
+    addNodeView() {
+        const renameLabel = this.options.renameLabel;
+        return ({ node, getPos, editor }) => {
+            const dom = document.createElement('span');
+            dom.className = 'co-doc-field';
+            dom.contentEditable = 'false';
+            let current = node;
+            let editing = false;
+            const paint = (n) => {
+                dom.textContent = n.attrs.value || `[[${n.attrs.name}]]`;
+                dom.classList.toggle('co-doc-field--empty', !n.attrs.value);
+                dom.classList.toggle('co-doc-field--required', !!n.attrs.required);
+                dom.setAttribute('data-variable', n.attrs.name);
+            };
+            const startRename = () => {
+                if (editing || !editor.isEditable)
+                    return;
+                editing = true;
+                const input = document.createElement('input');
+                input.className = 'co-doc-field__input';
+                input.value = current.attrs.name;
+                input.setAttribute('aria-label', renameLabel);
+                dom.textContent = '';
+                dom.appendChild(input);
+                input.focus();
+                input.select();
+                let done = false;
+                const finish = (commit) => {
+                    if (done)
+                        return;
+                    done = true;
+                    editing = false;
+                    const next = sanitizeFieldName(input.value);
+                    const pos = typeof getPos === 'function' ? getPos() : undefined;
+                    if (commit && next && next !== current.attrs.name && typeof pos === 'number') {
+                        // Como V1: el campo renombrado arranca vacío (solo ESTE nodo).
+                        editor.view.dispatch(editor.state.tr.setNodeMarkup(pos, undefined, { ...current.attrs, name: next, value: '' }));
+                    }
+                    else {
+                        paint(current);
+                    }
+                };
+                input.addEventListener('keydown', (ev) => {
+                    ev.stopPropagation(); // Esc no debe cerrar el overlay del host
+                    if (ev.key === 'Enter') {
+                        ev.preventDefault();
+                        finish(true);
+                    }
+                    else if (ev.key === 'Escape') {
+                        ev.preventDefault();
+                        finish(false);
+                    }
+                });
+                input.addEventListener('blur', () => finish(false));
+            };
+            dom.addEventListener('dblclick', (ev) => {
+                ev.preventDefault();
+                startRename();
+            });
+            paint(node);
+            return {
+                dom,
+                update(next) {
+                    if (next.type.name !== 'mergeField')
+                        return false;
+                    current = next;
+                    if (!editing)
+                        paint(next);
+                    return true;
+                },
+                stopEvent: (ev) => ev.target instanceof HTMLInputElement,
+                ignoreMutation: () => true,
+            };
+        };
+    },
+    addCommands() {
+        return {
+            insertField: (name, opts = {}) => ({ commands }) => {
+                const clean = sanitizeFieldName(name);
+                if (!clean)
+                    return false;
+                return commands.insertContent({
+                    type: this.name,
+                    attrs: {
+                        name: clean,
+                        value: opts.value ?? '',
+                        required: !!opts.required,
+                        type: opts.type || 'string',
+                        enum: opts.enum ?? null,
+                    },
+                });
+            },
+            setFieldValues: (values) => ({ tr, state, dispatch }) => {
+                let changed = false;
+                state.doc.descendants((node, pos) => {
+                    if (node.type.name !== this.name)
+                        return true;
+                    if (!Object.prototype.hasOwnProperty.call(values, node.attrs.name))
+                        return false;
+                    const next = String(values[node.attrs.name] ?? '');
+                    if (next !== node.attrs.value) {
+                        changed = true;
+                        if (dispatch)
+                            tr.setNodeMarkup(pos, undefined, { ...node.attrs, value: next });
+                    }
+                    return false;
+                });
+                if (!changed)
+                    return false;
+                if (dispatch) {
+                    tr.setMeta(FIELD_SYNC_META, true);
+                    tr.setMeta('addToHistory', false);
+                }
+                return true;
+            },
+            renameField: (from, to) => ({ tr, state, dispatch }) => {
+                const clean = sanitizeFieldName(to);
+                if (!clean || clean === from)
+                    return false; // renombrar a sí mismo borraría los valores
+                let changed = false;
+                state.doc.descendants((node, pos) => {
+                    if (node.type.name !== this.name)
+                        return true;
+                    if (node.attrs.name === from) {
+                        changed = true;
+                        if (dispatch)
+                            tr.setNodeMarkup(pos, undefined, { ...node.attrs, name: clean, value: '' });
+                    }
+                    return false;
+                });
+                return changed;
+            },
+        };
+    },
+    addProseMirrorPlugins() {
+        const type = this.type;
+        return [
+            new Plugin({
+                key: new PluginKey('coMergeFieldTokens'),
+                // Convierte `[[…]]` escritos o pegados en campos, solo en los textblocks tocados.
+                appendTransaction: (transactions, _old, state) => {
+                    if (!transactions.some((t) => t.docChanged && !t.getMeta(FIELD_SYNC_META)))
+                        return null;
+                    const blocks = touchedTextblocks(transactions, state);
+                    if (!blocks.length)
+                        return null;
+                    const hits = [];
+                    blocks.forEach((blockPos) => {
+                        const block = state.doc.nodeAt(blockPos);
+                        if (!block || block.type.spec.code)
+                            return;
+                        block.forEach((child, offset) => {
+                            if (!child.isText || !child.text || !child.text.includes('[['))
+                                return;
+                            const re = fieldTokenRegex();
+                            let m;
+                            while ((m = re.exec(child.text)) !== null) {
+                                const def = parseFieldToken(m[1]);
+                                if (!def)
+                                    continue;
+                                const from = blockPos + 1 + offset + m.index;
+                                hits.push({ from, to: from + m[0].length, def });
+                            }
+                        });
+                    });
+                    if (!hits.length)
+                        return null;
+                    const tr = state.tr;
+                    hits
+                        .sort((a, b) => b.from - a.from)
+                        .forEach(({ from, to, def }) => {
+                        tr.replaceWith(from, to, type.create({ ...def, value: '' }));
+                    });
+                    return tr;
+                },
+            }),
+        ];
+    },
+});
+
+/**
+ * Marcador de firma `⟦sig:N⟧`. La forma canónica es la de V1
+ * (tiptap-editor-html/utils/normalizeSignatureSlots.js) byte a byte: pdf.js lee
+ * el token transparente de la capa de texto del PDF y deriva la posición.
+ * Con font-size:1px Chromium colapsaba glifos: el token va a 8px y transparente.
+ *
+ * ⚠️ `editor.getHTML()` NO es la forma canónica: el DOMSerializer de ProseMirror
+ * escribe `style` por CSSOM (`top:0` → `top: 0px;`). La forma exacta sale de
+ * `signatureSlotHtml()` o de un serializador que escriba `style` con `setAttribute`
+ * (`serializePrintHtml`).
+ */
+const signatureToken = (n) => `⟦sig:${n}⟧`;
+const SIGNATURE_TOKEN_STYLE = 'position:absolute;top:0;left:0;color:transparent;font-size:8px;line-height:1;white-space:nowrap;pointer-events:none;user-select:none';
+const signatureBoxStyle = (w, h) => `display:inline-block;position:relative;width:${w}px;height:${h}px;vertical-align:top`;
+const SIGNATURE_DEFAULT_W = 150;
+const SIGNATURE_DEFAULT_H = 50;
+function nextFreeSlot(used = []) {
+    const taken = new Set(used);
+    let n = 1;
+    while (taken.has(n))
+        n += 1;
+    return n;
+}
+/** Spec de la forma canónica (orden de atributos = el de V1). Lo usa `renderHTML`. */
+function signatureSlotSpec({ slot, w, h }) {
+    return [
+        'span',
+        {
+            'data-sig-slot': String(slot),
+            'data-w': String(w),
+            'data-h': String(h),
+            contenteditable: 'false',
+            style: signatureBoxStyle(w, h),
+        },
+        ['span', { style: SIGNATURE_TOKEN_STYLE }, signatureToken(slot)],
+    ];
+}
+/**
+ * La forma canónica como string, armada del MISMO spec que `renderHTML` y sin pasar
+ * por CSSOM. Los valores son números y constantes propias: no hay nada que escapar.
+ */
+function signatureSlotHtml(attrs) {
+    const [tag, boxAttrs, [innerTag, innerAttrs, text]] = signatureSlotSpec(attrs);
+    const attrsOf = (a) => Object.entries(a)
+        .map(([k, v]) => ` ${k}="${v}"`)
+        .join('');
+    return `<${tag}${attrsOf(boxAttrs)}><${innerTag}${attrsOf(innerAttrs)}>${text}</${innerTag}></${tag}>`;
+}
+const toInt = (v, fallback) => {
+    const n = parseInt(v ?? '', 10);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+};
+const SignatureSlot = Node3.create({
+    name: 'signatureSlot',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    selectable: true,
+    addOptions() {
+        return { label: (slot) => `Signature ${slot}` };
+    },
+    addAttributes() {
+        return {
+            slot: { default: 1, parseHTML: (el) => toInt(el.getAttribute('data-sig-slot'), 1), rendered: false },
+            w: { default: SIGNATURE_DEFAULT_W, parseHTML: (el) => toInt(el.getAttribute('data-w'), SIGNATURE_DEFAULT_W), rendered: false },
+            h: { default: SIGNATURE_DEFAULT_H, parseHTML: (el) => toInt(el.getAttribute('data-h'), SIGNATURE_DEFAULT_H), rendered: false },
+        };
+    },
+    parseHTML() {
+        return [{ tag: 'span[data-sig-slot]', priority: 100 }];
+    },
+    renderHTML({ node }) {
+        return signatureSlotSpec(node.attrs);
+    },
+    renderText({ node }) {
+        return signatureToken(node.attrs.slot);
+    },
+    addNodeView() {
+        const label = this.options.label;
+        return ({ node }) => {
+            const dom = document.createElement('span');
+            dom.className = 'co-doc-signature';
+            dom.contentEditable = 'false';
+            const paint = (n) => {
+                dom.style.width = `${n.attrs.w}px`;
+                dom.style.height = `${n.attrs.h}px`;
+                dom.textContent = label(n.attrs.slot);
+                dom.setAttribute('data-sig-slot', String(n.attrs.slot));
+            };
+            paint(node);
+            return {
+                dom,
+                update(next) {
+                    if (next.type.name !== 'signatureSlot')
+                        return false;
+                    paint(next);
+                    return true;
+                },
+                ignoreMutation: () => true,
+            };
+        };
+    },
+    addCommands() {
+        return {
+            insertSignatureSlot: (size = {}) => ({ state, commands }) => {
+                const used = [];
+                state.doc.descendants((n) => {
+                    if (n.type.name === this.name)
+                        used.push(n.attrs.slot);
+                });
+                return commands.insertContent({
+                    type: this.name,
+                    attrs: { slot: nextFreeSlot(used), w: size.w ?? SIGNATURE_DEFAULT_W, h: size.h ?? SIGNATURE_DEFAULT_H },
+                });
+            },
+        };
+    },
+});
+
+/** Tamaño base del cuerpo de impresión (SharedContractUtils: 14px/1.5). */
+const BASE_FONT_PX = 14;
+/** Valor crudo de una propiedad del atributo style (conserva `#hex`; `el.style.color` lo pasaría a rgb). */
+function rawStyleValue(el, prop) {
+    const style = el.getAttribute('style') || '';
+    for (const decl of style.split(';')) {
+        const i = decl.indexOf(':');
+        if (i <= 0)
+            continue;
+        if (decl.slice(0, i).trim().toLowerCase() === prop) {
+            const v = decl.slice(i + 1).trim();
+            return v || null;
+        }
+    }
+    return null;
+}
+/** V1 pasaba mal las unidades (12pt → 12px, 1.5em → 1px). Acá se convierten a px de verdad. */
+function normalizeFontSizePx(v) {
+    if (v == null)
+        return null;
+    const m = /^\s*(\d+(?:\.\d+)?)\s*(px|pt|em|rem|%)?\s*$/i.exec(String(v));
+    if (!m)
+        return null;
+    const n = parseFloat(m[1]);
+    const unit = (m[2] || 'px').toLowerCase();
+    const px = unit === 'px' ? n : unit === 'pt' ? (n * 4) / 3 : unit === '%' ? (n / 100) * BASE_FONT_PX : n * BASE_FONT_PX;
+    const r = Math.round(px);
+    return r >= 1 && r <= 400 ? `${r}px` : null;
+}
+/**
+ * Color de texto en la forma de V1: `<span class="editor-text-style" style="color: X">`,
+ * SIEMPRE por fuera del tamaño (un span con color + tamaño pierde el color en V1).
+ * Se llama `textStyle` para que la barra lea `getAttributes('textStyle').color`.
+ * Prioridad alta = marca más externa (link 1003 > color 1002 > tamaño 1001 > resto 100).
+ *
+ * La regla de parse queda con la prioridad por defecto (50): la firma
+ * (`span[data-sig-slot]`) y el campo (`span[data-variable]`) van a 100 y le ganan
+ * aunque lleven `style` inline.
+ */
+const PrintTextColor = Mark.create({
+    name: 'textStyle',
+    priority: 1002,
+    addAttributes() {
+        return {
+            color: { default: null, parseHTML: (el) => rawStyleValue(el, 'color'), rendered: false },
+        };
+    },
+    parseHTML() {
+        return [{ tag: 'span', consuming: false, getAttrs: (el) => (rawStyleValue(el, 'color') ? {} : false) }];
+    },
+    renderHTML({ mark }) {
+        return ['span', { class: 'editor-text-style', style: `color: ${mark.attrs.color}` }, 0];
+    },
+    addCommands() {
+        return {
+            setColor: (color) => ({ commands }) => commands.setMark(this.name, { color }),
+            unsetColor: () => ({ commands }) => commands.unsetMark(this.name),
+        };
+    },
+});
+/** Tamaño en px como marca APARTE, anidada dentro del color: `<span style="font-size: Npx">`. */
+const PrintFontSize = Mark.create({
+    name: 'printFontSize',
+    priority: 1001,
+    addAttributes() {
+        return {
+            size: { default: null, parseHTML: (el) => normalizeFontSizePx(rawStyleValue(el, 'font-size')), rendered: false },
+        };
+    },
+    parseHTML() {
+        return [{ tag: 'span', consuming: false, getAttrs: (el) => (normalizeFontSizePx(rawStyleValue(el, 'font-size')) ? {} : false) }];
+    },
+    renderHTML({ mark }) {
+        return ['span', { style: `font-size: ${mark.attrs.size}` }, 0];
+    },
+    addCommands() {
+        return {
+            setFontSize: (size) => ({ commands }) => {
+                const px = normalizeFontSizePx(size);
+                return px ? commands.setMark(this.name, { size: px }) : false;
+            },
+            unsetFontSize: () => ({ commands }) => commands.unsetMark(this.name),
+        };
+    },
+});
+
+const IMAGE_LAYOUT_MODES = ['inline', 'wrap-left', 'wrap-right', 'break'];
+const MODE_PROPS = new Set(['float', 'clear', 'display', 'padding-left', 'padding-right']);
+const MODE_STYLES = {
+    inline: { wrapper: ['display: inline-block'], container: ['display: inline-block'] },
+    'wrap-left': { wrapper: ['display: inline-block', 'float: left'], container: ['display: inline-block', 'float: left', 'padding-right: 8px'] },
+    'wrap-right': { wrapper: ['display: inline-block', 'float: right'], container: ['display: inline-block', 'float: right', 'padding-left: 8px'] },
+    break: { wrapper: ['display: block'], container: ['display: block'] },
+};
+/** Una imagen nueva nace en línea (ruling del ledger); al leer una de V1 manda su wrapperstyle. */
+const DEFAULT_WRAPPER_STYLE = 'display: inline-block;';
+const DEFAULT_CONTAINER_STYLE = 'height: auto; cursor: pointer; display: inline-block;';
+function stripModeProps(style) {
+    return String(style || '')
+        .split(';')
+        .map((d) => d.trim())
+        .filter((d) => d.includes(':'))
+        .filter((d) => !MODE_PROPS.has(d.slice(0, d.indexOf(':')).trim().toLowerCase()));
+}
+function applyImageLayoutMode(mode, { wrapperStyle = '', containerStyle = '' } = {}) {
+    const preset = MODE_STYLES[mode];
+    if (!preset)
+        return { wrapperStyle: wrapperStyle || '', containerStyle: containerStyle || '' };
+    const join = (mods, rest) => [...mods, ...rest].join('; ').replace(/;?\s*$/, ';');
+    return {
+        wrapperStyle: join(preset.wrapper, stripModeProps(wrapperStyle || '')),
+        containerStyle: join(preset.container, stripModeProps(containerStyle || '')),
+    };
+}
+function getImageLayoutMode({ wrapperStyle = '', containerStyle = '' } = {}) {
+    const style = `${containerStyle || ''};${wrapperStyle || ''}`.toLowerCase();
+    if (/float:\s*left/.test(style))
+        return 'wrap-left';
+    if (/float:\s*right/.test(style))
+        return 'wrap-right';
+    if (/display:\s*block\b/.test(style))
+        return 'break';
+    return 'inline';
+}
+const HEADER_IMG_MAX = { w: 400, h: 40 };
+/** Ancho que entra en la banda del encabezado (port de headerContainerStyle de V1). */
+function headerImageWidth(dims, max = HEADER_IMG_MAX) {
+    if (!dims || !dims.w || !dims.h)
+        return null;
+    const scale = Math.min(1, max.h / dims.h, max.w / dims.w);
+    return Math.max(1, Math.round(dims.w * scale));
+}
+/**
+ * `width:` anclado a inicio de declaración: sin el ancla, `min-width`/`max-width` también
+ * matchean y se leía (y se pisaba) el ancho equivocado de un `containerstyle` de V1.
+ */
+const WIDTH_DECL = /(^|;)(\s*)width:\s*([0-9.]+)px/i;
+function withWidth(style, width) {
+    if (!width)
+        return style;
+    const decl = `width: ${width}px`;
+    return WIDTH_DECL.test(style)
+        ? style.replace(WIDTH_DECL, (_m, sep, ws) => `${sep}${ws}${decl}`)
+        : `${decl}; ${style}`.trim();
+}
+function parseWidth(el) {
+    const attr = parseInt(el.getAttribute('width') || '', 10);
+    if (attr > 0)
+        return attr;
+    const m = WIDTH_DECL.exec(el.getAttribute('containerstyle') || el.getAttribute('style') || '');
+    return m ? Math.round(parseFloat(m[3])) : null;
+}
+/**
+ * H10: el node view de resize de Tiptap solo copia los atributos RENDERIZADOS, y
+ * `wrapperStyle`/`containerStyle` no lo son → en el editor toda imagen se veía en línea.
+ * Se lleva el modo al contenedor (`[data-resize-container]`) para que la hoja pagine
+ * como el PDF. `inline-flex`/`flex` (no `inline-block`/`block`): el contenedor de
+ * resize los necesita para ubicar las manijas.
+ */
+function syncImageModeToContainer(container, node) {
+    const mode = getImageLayoutMode(node.attrs);
+    container.dataset.imageLayout = mode;
+    container.style.float = mode === 'wrap-left' ? 'left' : mode === 'wrap-right' ? 'right' : '';
+    container.style.paddingLeft = mode === 'wrap-right' ? '8px' : '';
+    container.style.paddingRight = mode === 'wrap-left' ? '8px' : '';
+    container.style.display = mode === 'break' ? 'flex' : 'inline-flex';
+}
+const PrintImage = Image.extend({
+    name: 'image',
+    addOptions() {
+        return { ...this.parent?.(), header: false };
+    },
+    addAttributes() {
+        return {
+            ...this.parent?.(),
+            width: { default: null, parseHTML: (el) => parseWidth(el), rendered: false },
+            dataFileId: { default: null, parseHTML: (el) => el.getAttribute('data-file-id'), rendered: false },
+            containerStyle: { default: null, parseHTML: (el) => el.getAttribute('containerstyle'), rendered: false },
+            wrapperStyle: { default: null, parseHTML: (el) => el.getAttribute('wrapperstyle'), rendered: false },
+        };
+    },
+    parseHTML() {
+        return [{ tag: this.options.allowBase64 ? 'img[src]' : 'img[src]:not([src^="data:"])', priority: 100 }];
+    },
+    renderHTML({ node }) {
+        const a = node.attrs;
+        const width = a.width ? Math.round(Number(a.width)) : null;
+        const wrapper = a.wrapperStyle || DEFAULT_WRAPPER_STYLE;
+        const container = withWidth(a.containerStyle || DEFAULT_CONTAINER_STYLE, width);
+        const img = { src: a.src };
+        if (a.alt)
+            img.alt = a.alt;
+        if (a.title)
+            img.title = a.title;
+        if (a.dataFileId)
+            img['data-file-id'] = String(a.dataFileId);
+        if (width) {
+            img.width = String(width);
+            img.style = this.options.header ? `width: ${width}px; height: auto;` : `width: ${width}px;`;
+        }
+        img.containerstyle = container;
+        img.wrapperstyle = wrapper;
+        return ['span', { style: wrapper }, ['img', img]];
+    },
+    addNodeView() {
+        const parent = this.parent?.();
+        if (!parent)
+            return null;
+        return (props) => {
+            const view = parent(props);
+            const container = view.dom;
+            syncImageModeToContainer(container, props.node);
+            const update = view.update?.bind(view);
+            view.update = (node, decorations, inner) => {
+                const ok = update ? update(node, decorations, inner) : node.type === props.node.type;
+                if (ok)
+                    syncImageModeToContainer(container, node);
+                return ok;
+            };
+            return view;
+        };
+    },
+    addCommands() {
+        return {
+            ...this.parent?.(),
+            setImageLayoutMode: (mode) => ({ state, tr, dispatch }) => {
+                const sel = state.selection;
+                if (!(sel instanceof NodeSelection) || sel.node.type.name !== this.name)
+                    return false;
+                if (dispatch) {
+                    const next = applyImageLayoutMode(mode, {
+                        wrapperStyle: sel.node.attrs.wrapperStyle || DEFAULT_WRAPPER_STYLE,
+                        containerStyle: withWidth(sel.node.attrs.containerStyle || DEFAULT_CONTAINER_STYLE, sel.node.attrs.width),
+                    });
+                    tr.setNodeMarkup(sel.from, undefined, { ...sel.node.attrs, ...next });
+                    // H7: la NodeSelection no sobrevive al reemplazo de la hoja; sin esto la barra de imagen se cierra.
+                    tr.setSelection(NodeSelection.create(tr.doc, sel.from));
+                }
+                return true;
+            },
+        };
+    },
+});
+
+/** Validación de V1 (tiptap-editor-html/extensions/index.js): exige un `.`, rechaza `/` y `./`. */
+const printLinkAllowed = (url, ctx) => ctx.defaultValidate(url) && !url.startsWith('./') && !url.startsWith('/') && url.includes('.');
+/** Autolink APAGADO: generaba `<a>` dentro de `{{ }}` y rompía Handlebars. Prioridad 1003 = marca más externa. */
+const PrintLink = Link.extend({ inclusive: () => false, priority: 1003 }).configure({
+    autolink: false,
+    openOnClick: false,
+    defaultProtocol: 'https',
+    protocols: ['mailto', { scheme: 'tel', optionalSlashes: true }],
+    HTMLAttributes: { target: '_blank', rel: 'noopener noreferrer', class: 'editor-link' },
+    isAllowedUri: printLinkAllowed,
+});
+
+/** Resalta `{{ … }}` con una DECORACIÓN: no toca el documento ni se serializa. */
+const HB_RE = /\{\{[^}]*\}\}/g;
+function build(doc) {
+    const decos = [];
+    doc.descendants((node, pos) => {
+        if (!node.isText || !node.text)
+            return true;
+        HB_RE.lastIndex = 0;
+        let m;
+        while ((m = HB_RE.exec(node.text)) !== null) {
+            decos.push(Decoration.inline(pos + m.index, pos + m.index + m[0].length, { class: 'co-doc-hb' }));
+        }
+        return true;
+    });
+    return DecorationSet.create(doc, decos);
+}
+const HandlebarsHighlight = Extension.create({
+    name: 'handlebarsHighlight',
+    addProseMirrorPlugins() {
+        const key = new PluginKey('coHandlebarsHighlight');
+        return [
+            new Plugin({
+                key,
+                state: {
+                    init: (_config, { doc }) => build(doc),
+                    apply: (tr, old) => (tr.docChanged ? build(tr.doc) : old),
+                },
+                props: {
+                    decorations(state) {
+                        return key.getState(state);
+                    },
+                },
+            }),
+        ];
+    },
+});
+
+/**
+ * Presets `print` (cuerpo) y `print-header` (banda). Paridad ESTRICTA de
+ * funciones de V1 (spec §3.5/§3.6, D7): sin subrayado, familia, peso,
+ * interlineado, espaciado ni sangría; autolink apagado; sin nodo `variable`
+ * (comparte selector `span[data-variable]` con el campo). `trailingNode` apagado:
+ * V1 no lo tenía y una tabla al final sumaría una línea vacía al PDF.
+ * Las etiquetas (`labels`) las localiza el host; sin ellas quedan en inglés.
+ */
+function getPrintExtensions(preset, opts = {}) {
+    const header = preset === 'print-header';
+    const { features = {}, labels = {} } = opts;
+    const starter = { underline: false, link: false, trailingNode: false };
+    if (header) {
+        Object.assign(starter, {
+            heading: false, bulletList: false, orderedList: false, listItem: false, listKeymap: false,
+            blockquote: false, codeBlock: false, horizontalRule: false,
+        });
+    }
+    else {
+        starter.heading = { levels: [1, 2, 3, 4] };
+    }
+    const exts = [
+        StarterKit.configure(starter),
+        PrintTextColor,
+        PrintFontSize,
+        Highlight.configure({ multicolor: true }),
+        TextAlign.configure({ types: header ? ['paragraph'] : ['heading', 'paragraph'] }),
+        HandlebarsHighlight,
+    ];
+    if (!header) {
+        exts.push(PrintLink, Table.configure({ resizable: true, renderWrapper: true }), TableRow, TableHeader, TableCell);
+    }
+    exts.push(PrintImage.configure({
+        inline: true,
+        allowBase64: true,
+        header,
+        resize: header
+            ? false
+            : { enabled: true, directions: ['left', 'right', 'bottom-left', 'bottom-right'], minWidth: 50, minHeight: 20, alwaysPreserveAspectRatio: true },
+    }));
+    if (features.fields !== false) {
+        exts.push(MergeField.configure({ renameLabel: labels.fieldName ?? 'Field name' }));
+    }
+    if (!header && features.signatureSlots !== false) {
+        exts.push(labels.signature ? SignatureSlot.configure({ label: labels.signature }) : SignatureSlot);
+    }
+    return exts;
+}
+
 /** Shared link configuration — never auto-opens inside the editor, safe rel. */
 const LINK_CONFIG = {
     openOnClick: false,
@@ -35072,6 +35864,8 @@ const PRESET_TOOLBAR = {
     email: 'full',
     document: 'full',
     'block-email': 'basic',
+    print: 'document',
+    'print-header': 'document',
 };
 /** Suggested max length per preset (null = no limit). */
 const PRESET_MAXLENGTH = {
@@ -35081,10 +35875,22 @@ const PRESET_MAXLENGTH = {
     email: null,
     document: null,
     'block-email': null,
+    print: null,
+    'print-header': null,
 };
 /** Build the ordered extension array for a preset. */
 function getExtensions(preset = 'task', options = {}) {
-    const { placeholder, maxLength, features = {}, includeUiExtensions = true } = options;
+    const { placeholder, maxLength, features = {}, includeUiExtensions = true, labels } = options;
+    // Presets de impresión: schema propio (spec contracts-v2-contract-editor §3.5/§3.6).
+    if (preset === 'print' || preset === 'print-header') {
+        const exts = getPrintExtensions(preset, {
+            features: { fields: features.fields, signatureSlots: features.signatureSlots },
+            labels,
+        });
+        if (includeUiExtensions && placeholder)
+            exts.push(Placeholder.configure({ placeholder }));
+        return exts;
+    }
     const config = STARTERKIT_CONFIG[preset] ?? STARTERKIT_CONFIG.task;
     const exts = [StarterKit.configure(config), CobaltLink];
     // Color requires TextStyle to be registered first. Only presets that keep
@@ -35182,7 +35988,573 @@ function defaultToolbarForPreset(preset = 'task') {
 function maxLengthForPreset(preset = 'task') {
     return PRESET_MAXLENGTH[preset] ?? null;
 }
-const PRESETS = ['comment', 'task', 'notes', 'email', 'document', 'block-email'];
+const PRESETS = ['comment', 'task', 'notes', 'email', 'document', 'block-email', 'print', 'print-header'];
+
+// src/generateHTML.ts
+function getHTMLFromFragment(doc, schema, options) {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "getHTMLFromFragment can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
+    );
+  }
+  const wrap = window.document.createElement("div");
+  DOMSerializer.fromSchema(schema).serializeFragment(
+    doc.content,
+    {
+      document: window.document
+    },
+    wrap
+  );
+  return wrap.innerHTML;
+}
+
+// src/generateHTML.ts
+function generateHTML(doc, extensions) {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "generateHTML can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
+    );
+  }
+  const schema = getSchema(extensions);
+  const contentNode = Node$1.fromJSON(schema, doc);
+  return getHTMLFromFragment(contentNode, schema);
+}
+function generateJSON(html, extensions, options) {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "generateJSON can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
+    );
+  }
+  const schema = getSchema(extensions);
+  const doc = new window.DOMParser().parseFromString(html, "text/html");
+  if (!doc) {
+    throw new Error("Failed to parse HTML string");
+  }
+  return DOMParser$1.fromSchema(schema).parse(doc.body, options).toJSON();
+}
+
+const BASE_INLINE = ['p', 'br', 'strong', 'em', 'a', 'span'];
+const BASE_ATTR = ['href', 'target', 'rel', 'data-mention-id', 'data-mention-label'];
+const SANITIZE_CONFIGS = {
+    // Más ancho que su schema A PROPÓSITO (única excepción al lock-step): el
+    // editor `comment` no puede autorar listas ni headings (STARTERKIT_CONFIG los
+    // apaga y ProseMirror descarta esos nodos al parsear el paste), pero el
+    // VIEWER tiene que pintarlos cuando el HTML entra por API — una nota de
+    // enriquecimiento (Apollo.io) trae <ul>/<li>/<h4> y con KEEP_CONTENT el
+    // texto se hoisteaba al padre: lista corrida, heading fundido en el cuerpo.
+    // Espejo inline en core/co-rich-text-viewer.tsx (ALLOWED_TAGS.comment).
+    comment: {
+        ALLOWED_TAGS: [...BASE_INLINE, 'ul', 'ol', 'li', 'h1', 'h2', 'h3', 'h4'],
+        ALLOWED_ATTR: [...BASE_ATTR],
+        ALLOW_DATA_ATTR: false,
+    },
+    task: {
+        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'input', 'label'],
+        ALLOWED_ATTR: [...BASE_ATTR, 'type', 'checked', 'disabled', 'data-type', 'data-checked', 'data-variant'],
+        ALLOW_DATA_ATTR: false,
+    },
+    // Lock-step con getExtensions('notes'): task sin checklists + TextStyle/Color
+    // (`style` capado a STYLE_ALLOWED_PROPS) + Highlight multicolor (`mark` con
+    // `data-color`).
+    notes: {
+        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'mark'],
+        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-color'],
+        ALLOW_DATA_ATTR: false,
+    },
+    email: {
+        ALLOWED_TAGS: [
+            ...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote',
+            'h2', 'h3', 'div', 'img',
+        ],
+        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'data-transform', 'data-fallback', 'src', 'alt', 'width', 'height', 'data-file-id', 'data-image-layout'],
+        ALLOW_DATA_ATTR: false,
+    },
+    document: {
+        ALLOWED_TAGS: [
+            ...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote',
+            'h1', 'h2', 'h3', 'h4', 'hr', 'div', 'mark', 'img',
+            'table', 'thead', 'tbody', 'tr', 'th', 'td',
+            'input', 'label', 'iframe',
+        ],
+        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'colspan', 'rowspan', 'src', 'alt', 'width', 'height', 'type', 'checked', 'disabled', 'allowfullscreen', 'frameborder', 'allow', 'loading'],
+        ALLOW_DATA_ATTR: true,
+    },
+    'block-email': {
+        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'h2', 'h3', 'div', 'img'],
+        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'data-transform', 'data-fallback', 'src', 'alt', 'width', 'height', 'data-file-id', 'data-image-layout', 'data-type', 'data-label', 'data-href', 'data-bg', 'data-color', 'data-height'],
+        ALLOW_DATA_ATTR: false,
+    },
+    // Espejo de getPrintExtensions('print'): cuerpo del documento de impresión.
+    // `class` y data-* son parte de la forma que V1 re-parsea (editor-text-style,
+    // variable-node, editor-link, tableWrapper, trailingBreak, data-variable…).
+    print: {
+        ALLOWED_TAGS: [
+            'p', 'br', 'strong', 'em', 's', 'code', 'a', 'span', 'mark',
+            'h1', 'h2', 'h3', 'h4', 'ul', 'ol', 'li', 'blockquote', 'pre', 'hr', 'img', 'div',
+            'table', 'colgroup', 'col', 'thead', 'tbody', 'tr', 'th', 'td',
+        ],
+        ALLOWED_ATTR: [
+            'href', 'target', 'rel', 'class', 'style', 'src', 'alt', 'title', 'width', 'height',
+            'colspan', 'rowspan', 'colwidth', 'start', 'contenteditable', 'containerstyle', 'wrapperstyle',
+        ],
+        ALLOW_DATA_ATTR: true,
+        ADD_URI_SAFE_ATTR: ['containerstyle', 'wrapperstyle'],
+    },
+    // Espejo de getPrintExtensions('print-header'): la banda del encabezado.
+    'print-header': {
+        ALLOWED_TAGS: ['p', 'br', 'strong', 'em', 's', 'code', 'span', 'mark', 'img'],
+        ALLOWED_ATTR: ['class', 'style', 'src', 'alt', 'title', 'width', 'height', 'contenteditable', 'containerstyle', 'wrapperstyle'],
+        ALLOW_DATA_ATTR: true,
+        ADD_URI_SAFE_ATTR: ['containerstyle', 'wrapperstyle'],
+    },
+};
+/**
+ * `<iframe>`s are permitted only with an `https:` source (blocks javascript:,
+ * data:, and plain http: embeds). This is what makes allowing iframes safe-ish
+ * for a trusted-author document; YouTube embeds satisfy it too.
+ */
+const SAFE_IFRAME_SRC_RE = /^https:\/\/[^\s"'<>]+$/i;
+/** Tags forbidden in every preset, regardless of the allow-list. */
+const FORBID_TAGS = ['script', 'object', 'embed', 'form', 'textarea', 'style'];
+/** Attributes forbidden in every preset (event handlers handled by DOMPurify itself). */
+const FORBID_ATTR = ['onerror', 'onload', 'onclick'];
+/**
+ * Resolve the effective config for a preset + feature overrides. Features can
+ * only ADD capabilities (mirroring `getExtensions`, where they register extra
+ * nodes); they never narrow a preset's base whitelist.
+ */
+function configFor(preset, features) {
+    const cfg = SANITIZE_CONFIGS[preset] ?? SANITIZE_CONFIGS.task;
+    if (!features)
+        return cfg;
+    const tags = new Set(cfg.ALLOWED_TAGS);
+    const attr = new Set(cfg.ALLOWED_ATTR);
+    if (features.image) {
+        tags.add('img');
+        ['src', 'alt', 'width', 'height'].forEach((a) => attr.add(a));
+    }
+    if (features.variables)
+        attr.add('data-variable');
+    if (features.mentions) {
+        // data-mention-id/label ya están en BASE_ATTR. Los attrs del markup V1
+        // (quill-mention) se suman porque el BACKEND los parsea para notificar —
+        // re-editar una nota no debe destruirlos.
+        // Espejo inline en core/co-rich-text-viewer.tsx (el viewer no importa este módulo para no cargar el engine) — si cambias esta lista, cambia la del viewer.
+        ['data-id', 'data-value', 'data-denotation-char', 'data-index'].forEach((a) => attr.add(a));
+    }
+    return { ...cfg, ALLOWED_TAGS: [...tags], ALLOWED_ATTR: [...attr] };
+}
+/**
+ * `style` is only allowed in notes/email/document, and even there we cap it to
+ * the properties our extensions actually emit (TextStyle/Color/TextAlign,
+ * ListStyleExtension's `list-style-type`). Everything else — position,
+ * background-image url(), etc. — is UI-redressing/tracking surface.
+ */
+const STYLE_ALLOWED_PROPS = new Set(['color', 'background-color', 'text-align', 'list-style-type']);
+const UNSAFE_STYLE_VALUE = /url\s*\(|expression\s*\(/i;
+const DEFAULT_STYLE_POLICY = {
+    attrs: new Set(['style']),
+    allows: (prop) => STYLE_ALLOWED_PROPS.has(prop),
+    keepOriginalWhenClean: false,
+};
+const COLOR_VALUE = /^(#[0-9a-f]{3,8}|rgba?\([\d.\s,%]+\)|hsla?\([\d.\s,%deg]+\)|[a-z]+)$/i;
+const LENGTH_TOKEN = /^(-?\d+(\.\d+)?(px|pt|em|rem|%|mm|cm|in)?|auto)$/i;
+const lengths = (v) => v.split(/\s+/).every((t) => LENGTH_TOKEN.test(t));
+const oneOf = (re) => (v) => re.test(v);
+/** Lo que emiten las extensiones del preset print y la firma canónica (spec §3.4, §4.1). */
+const PRINT_STYLE_RULES = {
+    color: oneOf(COLOR_VALUE),
+    'background-color': oneOf(COLOR_VALUE),
+    'text-align': oneOf(/^(left|center|right|justify)$/i),
+    'font-size': oneOf(/^\d+(\.\d+)?(px|pt|em|rem|%)$/i),
+    width: lengths,
+    height: lengths,
+    'min-width': lengths,
+    'max-width': lengths,
+    display: oneOf(/^(inline-block|inline|block|flex|inline-flex)$/i),
+    float: oneOf(/^(left|right|none)$/i),
+    margin: lengths,
+    'margin-top': lengths,
+    'margin-right': lengths,
+    'margin-bottom': lengths,
+    'margin-left': lengths,
+    padding: lengths,
+    'padding-top': lengths,
+    'padding-right': lengths,
+    'padding-bottom': lengths,
+    'padding-left': lengths,
+    'vertical-align': oneOf(/^(top|middle|bottom|baseline|text-top|text-bottom)$/i),
+    position: oneOf(/^(relative|absolute)$/i),
+    top: lengths,
+    left: lengths,
+    'line-height': oneOf(/^\d+(\.\d+)?(px)?$/i),
+    'white-space': oneOf(/^(nowrap|normal|pre-wrap)$/i),
+    'pointer-events': oneOf(/^none$/i),
+    'user-select': oneOf(/^none$/i),
+    cursor: oneOf(/^(pointer|default)$/i),
+};
+const PRINT_STYLE_POLICY = {
+    // containerstyle/wrapperstyle son CSS que V1 aplica inline a la imagen (H2).
+    attrs: new Set(['style', 'containerstyle', 'wrapperstyle']),
+    allows: (prop, value) => Object.prototype.hasOwnProperty.call(PRINT_STYLE_RULES, prop) && PRINT_STYLE_RULES[prop](value),
+    keepOriginalWhenClean: true,
+};
+const STYLE_POLICIES = {
+    print: PRINT_STYLE_POLICY,
+    'print-header': PRINT_STYLE_POLICY,
+};
+/**
+ * Sanitize an HTML string for the given preset (+ feature overrides — pass the
+ * same `features` you gave `getExtensions`/`createEditor` so the whitelist
+ * stays in lock-step with the schema). Always strips script/object/embed/style/
+ * form/event-handlers and `javascript:` URLs (DOMPurify default). `<iframe>` is
+ * allowed ONLY for the document preset and ONLY with an `https:` source
+ * (YouTube, Vimeo, Loom, Slides, … survive save/render; unsafe embeds are
+ * dropped). `style` is capped to color/background-color/text-align.
+ */
+function sanitize(html, preset = 'task', features) {
+    if (!html)
+        return '';
+    const cfg = configFor(preset, features);
+    purify.addHook('uponSanitizeElement', (node, data) => {
+        // Only allow <input type="checkbox"> (task list checkboxes); strip others.
+        if (data.tagName === 'input' && node.type !== 'checkbox') {
+            node.parentNode?.removeChild(node);
+        }
+        // Allow only https iframes (YouTube and other embeds); drop anything else.
+        if (data.tagName === 'iframe') {
+            const src = node.getAttribute('src') || '';
+            if (!SAFE_IFRAME_SRC_RE.test(src))
+                node.parentNode?.removeChild(node);
+        }
+    });
+    // Cap `style` (and, in print, the image's containerstyle/wrapperstyle) to
+    // the properties the preset's extensions actually emit; strip the rest
+    // (position:fixed, background-image url(), expression(), …). Drop the attr
+    // entirely when nothing survives. The default policy is the pre-print rule
+    // verbatim (guarded by sanitizer.presets.snapshot.test.ts).
+    const policy = STYLE_POLICIES[preset] ?? DEFAULT_STYLE_POLICY;
+    purify.addHook('uponSanitizeAttribute', (_node, data) => {
+        if (!policy.attrs.has(data.attrName))
+            return;
+        const decls = data.attrValue.split(';').map((d) => d.trim()).filter(Boolean);
+        const safe = decls.filter((d) => {
+            const colon = d.indexOf(':');
+            if (colon <= 0)
+                return false;
+            const prop = d.slice(0, colon).trim().toLowerCase();
+            const value = d.slice(colon + 1).trim();
+            return !UNSAFE_STYLE_VALUE.test(d) && policy.allows(prop, value);
+        });
+        if (policy.keepOriginalWhenClean && safe.length === decls.length && safe.length > 0)
+            return;
+        data.attrValue = safe.join('; ');
+        if (!data.attrValue)
+            data.keepAttr = false;
+    });
+    try {
+        const clean = purify.sanitize(html, {
+            ALLOWED_TAGS: cfg.ALLOWED_TAGS,
+            ALLOWED_ATTR: cfg.ALLOWED_ATTR,
+            ALLOW_DATA_ATTR: cfg.ALLOW_DATA_ATTR ?? false,
+            FORBID_TAGS,
+            FORBID_ATTR,
+            ADD_ATTR: ['target', 'allowfullscreen', 'frameborder', 'allow'],
+            ...(cfg.ADD_URI_SAFE_ATTR ? { ADD_URI_SAFE_ATTR: cfg.ADD_URI_SAFE_ATTR } : {}),
+        });
+        return clean;
+    }
+    finally {
+        purify.removeHook('uponSanitizeElement');
+        purify.removeHook('uponSanitizeAttribute');
+    }
+}
+
+/**
+ * Lector tolerante del HTML de impresión (spec contracts-v2-contract-editor §3.3).
+ * Entrada: lo que guardó V1 (documento completo con CSS, fragmento que dejó
+ * cheerio en el backend, cuerpo compilado de generateFromDeal) o lo que escribe
+ * el serializador canónico. Salida: SOLO el cuerpo, sin restos de edición.
+ * No usa schema: el parse lo hace readPrintHtml (print/io.ts).
+ */
+const EDITING_CLASSES = ['ProseMirror-selectednode', 'variable-node--editing', 'selectedCell'];
+const BLOCK_TAGS = new Set(['P', 'DIV', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'UL', 'OL', 'LI', 'TABLE', 'BLOCKQUOTE', 'PRE', 'HR']);
+const INLINE_CONTENT_TAGS = new Set(['P', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6']);
+const HEAD_ONLY = 'style, script, meta, title, link, base';
+function normalizePrintHtml(html) {
+    if (!html || !html.trim())
+        return '';
+    const doc = new DOMParser().parseFromString(html, 'text/html');
+    const root = doc.querySelector('.tiptap.ProseMirror, .ProseMirror') ?? doc.body;
+    root.querySelectorAll('#document-metadata').forEach((el) => el.remove());
+    root.querySelectorAll(HEAD_ONLY).forEach((el) => el.remove());
+    // prosemirror-model convierte estos br en saltos REALES al re-parsear: fuera todos.
+    root.querySelectorAll('br.ProseMirror-trailingBreak, img.ProseMirror-separator').forEach((el) => el.remove());
+    // V1 serializa por error la decoración de {{ }}.
+    root.querySelectorAll('span.hb-token').forEach(unwrap);
+    Array.from(root.querySelectorAll('*')).forEach(cleanEditingResidue);
+    cleanCellStyles(root);
+    rebuildSplitImages(root);
+    // Tras desenvolver hb-token y quitar breaks quedan textos adyacentes: un token repartido entre ellos no matchearía.
+    root.normalize();
+    tokensToFieldSpans(root);
+    return root.innerHTML;
+}
+function unwrap(el) {
+    el.replaceWith(...Array.from(el.childNodes));
+}
+function cleanEditingResidue(el) {
+    Array.from(el.attributes).forEach((a) => {
+        if (a.name.startsWith('data-v-') || a.name === 'data-node-view-wrapper')
+            el.removeAttribute(a.name);
+    });
+    EDITING_CLASSES.forEach((c) => el.classList.remove(c));
+    if (el.getAttribute('class') === '')
+        el.removeAttribute('class');
+}
+function cleanCellStyles(root) {
+    root.querySelectorAll('td[style], th[style]').forEach((cell) => {
+        const kept = (cell.getAttribute('style') || '')
+            .split(';')
+            .map((d) => d.trim())
+            .filter((d) => {
+            const i = d.indexOf(':');
+            if (i <= 0)
+                return false;
+            const v = d.slice(i + 1).trim().toLowerCase();
+            return v !== '' && v !== 'null' && v !== 'undefined';
+        });
+        if (kept.length)
+            cell.setAttribute('style', kept.join('; '));
+        else
+            cell.removeAttribute('style');
+    });
+}
+const isBlockNode = (n) => n.nodeType === 1 && BLOCK_TAGS.has(n.tagName);
+const isBlankText = (n) => n.nodeType === 3 && !(n.textContent ?? '').trim();
+/**
+ * V1 guarda la imagen como `<div wrapper><div container><img></div></div>`
+ * DENTRO del `<p>`; el parser HTML5 parte el párrafo en `<p>antes</p><div>…</div>después<p></p>`.
+ * Se vuelve a juntar en un solo párrafo, con los estilos del wrapper y del
+ * container copiados al `<img>` (así los lee el nodo image del preset print).
+ */
+function rebuildSplitImages(root) {
+    const doc = root.ownerDocument;
+    Array.from(root.querySelectorAll('img')).forEach((img) => {
+        const container = img.parentElement;
+        // `container !== root`: un <img> suelto al tope del cuerpo no es una imagen partida.
+        if (!container || container === root || container.tagName !== 'DIV' || container.firstElementChild !== img)
+            return;
+        const parent = container.parentElement;
+        const wrapper = parent && parent.tagName === 'DIV' && parent.firstElementChild === container && parent !== root ? parent : null;
+        const containerCss = container.getAttribute('style');
+        if (containerCss && !img.hasAttribute('containerstyle'))
+            img.setAttribute('containerstyle', containerCss);
+        const wrapperCss = wrapper?.getAttribute('style');
+        if (wrapperCss && !img.hasAttribute('wrapperstyle'))
+            img.setAttribute('wrapperstyle', wrapperCss);
+        const outer = wrapper ?? container;
+        // El parser HTML5 solo parte <p>: dentro de un título (o de un <p> que no se
+        // partió) la imagen queda en su lugar, sin recomponer hermanos ni crear <p>.
+        if (outer.parentElement && INLINE_CONTENT_TAGS.has(outer.parentElement.tagName)) {
+            outer.replaceWith(img);
+            return;
+        }
+        const before = [];
+        let prev = outer.previousSibling;
+        while (prev && !isBlockNode(prev)) {
+            before.unshift(prev);
+            prev = prev.previousSibling;
+        }
+        const after = [];
+        let next = outer.nextSibling;
+        while (next && !isBlockNode(next)) {
+            after.push(next);
+            next = next.nextSibling;
+        }
+        // El `</p>` original quedó huérfano: el parser lo convierte en un <p></p> vacío.
+        if (next && next.nodeName === 'P' && !next.hasChildNodes())
+            next.remove();
+        let target;
+        if (before.every(isBlankText) && prev && prev.nodeName === 'P') {
+            before.forEach((n) => n.parentNode?.removeChild(n));
+            target = prev;
+        }
+        else {
+            target = doc.createElement('p');
+            outer.before(target);
+            before.forEach((n) => target.appendChild(n));
+        }
+        target.appendChild(img);
+        after.forEach((n) => target.appendChild(n));
+        outer.remove();
+    });
+}
+function tokensToFieldSpans(root) {
+    const doc = root.ownerDocument;
+    const walker = doc.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const targets = [];
+    let n;
+    while ((n = walker.nextNode())) {
+        const t = n;
+        if (!t.data.includes('[['))
+            continue;
+        if (t.parentElement?.closest('[data-variable], [data-sig-slot], pre, code'))
+            continue;
+        targets.push(t);
+    }
+    targets.forEach((t) => {
+        const text = t.data;
+        const re = fieldTokenRegex();
+        const frag = doc.createDocumentFragment();
+        let last = 0;
+        let any = false;
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const def = parseFieldToken(m[1]);
+            if (!def)
+                continue;
+            any = true;
+            if (m.index > last)
+                frag.appendChild(doc.createTextNode(text.slice(last, m.index)));
+            const span = doc.createElement('span');
+            span.setAttribute('data-variable', def.name);
+            span.setAttribute('data-value', '');
+            span.setAttribute('data-type', def.type);
+            span.setAttribute('data-required', def.required ? 'true' : 'false');
+            if (def.enum)
+                span.setAttribute('data-enum', JSON.stringify(def.enum));
+            span.textContent = `[[${def.name}]]`;
+            frag.appendChild(span);
+            last = m.index + m[0].length;
+        }
+        if (!any)
+            return;
+        if (last < text.length)
+            frag.appendChild(doc.createTextNode(text.slice(last)));
+        t.replaceWith(frag);
+    });
+}
+
+/**
+ * Serializador canónico del preset print (spec contracts-v2-contract-editor §3.4).
+ * Escribe desde el DOCUMENTO (renderHTML del schema), nunca desde el DOM de
+ * pantalla: así no se cuelan NodeViews, decoraciones ni los hacks de
+ * prosemirror-view que V1 guardaba con innerHTML.
+ *
+ * H1: `DOMSerializer` escribe `style` por CSSOM (`dom.style.cssText = …`), que
+ * normaliza el string (`#ff0000` → `rgb(255, 0, 0)`, `top:0` → `top: 0px;`) y
+ * rompe la forma byte a byte de V1 (firma, color, tamaño, imagen). Por eso se
+ * serializa con un `document` sustituto cuyos elementos no exponen `style`:
+ * ProseMirror cae a `setAttribute` y conserva el string crudo. `editor.getHTML()`
+ * NO es la forma canónica.
+ */
+const TRAILING_BREAK_CLASS = 'ProseMirror-trailingBreak';
+const TRAILING_MARKER = 'data-co-trailing-break';
+/**
+ * Como prosemirror-view, el trailingBreak se decide por el NODO: textblock vacío o
+ * cuyo último hijo es un hardBreak (aunque el <br> quede dentro de un mark).
+ */
+function needsTrailingBreak(node) {
+    if (!node.isTextblock)
+        return false;
+    return node.childCount === 0 || node.lastChild.type.name === 'hardBreak';
+}
+/**
+ * Marca el elemento de bloque (spec `[tag, attrs?, 0]`, hueco directo en el
+ * elemento: p/h*) para que el <br> vaya como su ÚLTIMO hijo, fuera de los marks.
+ */
+function withTrailingMarker(spec) {
+    if (!Array.isArray(spec) || spec[spec.length - 1] !== 0)
+        return spec;
+    const attrs = spec[1];
+    if (attrs && typeof attrs === 'object' && !Array.isArray(attrs) && !('nodeType' in attrs)) {
+        return [spec[0], { ...attrs, [TRAILING_MARKER]: '' }, ...spec.slice(2)];
+    }
+    return [spec[0], { [TRAILING_MARKER]: '' }, ...spec.slice(1)];
+}
+function rawStyleDocument(real) {
+    return {
+        createElement: (tag) => {
+            const el = real.createElement(tag);
+            Object.defineProperty(el, 'style', { value: null });
+            return el;
+        },
+        createElementNS: (ns, tag) => {
+            const el = real.createElementNS(ns, tag);
+            Object.defineProperty(el, 'style', { value: null });
+            return el;
+        },
+        createTextNode: real.createTextNode.bind(real),
+        createDocumentFragment: real.createDocumentFragment.bind(real),
+    };
+}
+function printSerializer(schema) {
+    const base = DOMSerializer.fromSchema(schema);
+    const nodes = {};
+    Object.entries(base.nodes).forEach(([name, render]) => {
+        nodes[name] = (node) => {
+            const spec = render(node);
+            return needsTrailingBreak(node) ? withTrailingMarker(spec) : spec;
+        };
+    });
+    return new DOMSerializer(nodes, base.marks);
+}
+function serializePrintHtml(doc) {
+    const container = document.createElement('div');
+    const fragment = printSerializer(doc.type.schema).serializeFragment(doc.content, {
+        document: rawStyleDocument(document),
+    });
+    container.appendChild(fragment);
+    // Sin el trailingBreak la línea vacía o final no ocupa alto en el PDF
+    // (.tiptap p{margin:0}). El lector lo quita al volver.
+    container.querySelectorAll(`[${TRAILING_MARKER}]`).forEach((el) => {
+        el.removeAttribute(TRAILING_MARKER);
+        const br = document.createElement('br');
+        br.className = TRAILING_BREAK_CLASS;
+        el.appendChild(br);
+    });
+    return container.innerHTML;
+}
+
+function isPrintPreset(p) {
+    return p === 'print' || p === 'print-header';
+}
+function schemaExtensions(preset, features) {
+    return getExtensions(preset, { includeUiExtensions: false, features });
+}
+/** HTML de impresión (el de V1 incluido) → JSON: lector tolerante → limpieza del preset → parse. */
+function readPrintHtml(html, preset = 'print', features) {
+    const clean = sanitize(normalizePrintHtml(html ?? ''), preset, features);
+    return generateJSON(clean, schemaExtensions(preset, features));
+}
+/**
+ * Documento → forma canónica (spec §3.4), pasada por la limpieza del preset.
+ * Es la ÚNICA forma canónica: `editor.getHTML()` de Tiptap normaliza los `style`
+ * (H1) y no sirve para guardar.
+ */
+function writePrintHtml(doc, preset = 'print', features) {
+    if (!doc)
+        return '';
+    const node = doc instanceof Node$1
+        ? doc
+        : Node$1.fromJSON(getSchema(schemaExtensions(preset, features)), doc);
+    return sanitize(serializePrintHtml(node), preset, features);
+}
+/** Aplica valores a los campos de un HTML sin montar un editor (encabezado fuera de edición). */
+function setFieldValuesInHtml(html, values, preset = 'print-header', features) {
+    if (!html)
+        return '';
+    const json = readPrintHtml(html, preset, features);
+    const apply = (n) => {
+        if (n.type === 'mergeField' && n.attrs && Object.prototype.hasOwnProperty.call(values, n.attrs.name)) {
+            n.attrs = { ...n.attrs, value: String(values[n.attrs.name] ?? '') };
+        }
+        n.content?.forEach(apply);
+    };
+    apply(json);
+    return writePrintHtml(json, preset, features);
+}
 
 /**
  * ProseMirror editorProps that insert pasted/dropped images optimistically
@@ -35308,6 +36680,11 @@ function autolinkTrailing(editor) {
         editor.view.dispatch(tr);
     return changed;
 }
+/** El autolink al perder foco solo corre si el link del schema lo tiene activo (print lo apaga). */
+function autolinkEnabled(editor) {
+    const link = editor.extensionManager.extensions.find((ext) => ext.name === 'link');
+    return !!(link && link.options.autolink);
+}
 /**
  * Create a configured Tiptap v3 editor for a Cobalt preset.
  *
@@ -35316,9 +36693,9 @@ function autolinkTrailing(editor) {
  * always false — Cobalt owns every style.
  */
 function createEditor(options = {}) {
-    const { preset = 'task', element = null, content = null, editable = true, placeholder, maxLength, features, customExtensions = [], bubbleMenuElement, imageUpload, onUpdate, onSelectionUpdate, onFocus, onBlur, onCreate, onDestroy, onContentError, } = options;
+    const { preset = 'task', element = null, content = null, editable = true, placeholder, maxLength, features, labels, customExtensions = [], bubbleMenuElement, imageUpload, onUpdate, onSelectionUpdate, onFocus, onBlur, onCreate, onDestroy, onContentError, } = options;
     const extensions = [
-        ...getExtensions(preset, { placeholder, maxLength, features }),
+        ...getExtensions(preset, { placeholder, maxLength, features, labels }),
         ...customExtensions,
     ];
     let editor;
@@ -35375,11 +36752,13 @@ function createEditor(options = {}) {
             },
         }));
     }
+    // En print, un string es HTML de impresión (quizá de V1): pasa por el lector tolerante.
+    const initialContent = isPrintPreset(preset) && typeof content === 'string' ? readPrintHtml(content, preset, features) : content;
     editor = new Editor({
         ...(element ? { element } : {}),
         ...(imageUpload ? { editorProps: imageDropPaste(imageUpload) } : {}),
         extensions,
-        content: content ?? '',
+        content: initialContent ?? '',
         editable,
         injectCSS: false,
         // `enableContentCheck: true` makes tiptap THROW on invalid content from
@@ -35394,304 +36773,356 @@ function createEditor(options = {}) {
         onUpdate: ({ editor: e }) => onUpdate?.(e),
         onSelectionUpdate: ({ editor: e }) => onSelectionUpdate?.(e),
         onFocus: ({ editor: e }) => onFocus?.(e),
-        onBlur: ({ editor: e }) => { autolinkTrailing(e); onBlur?.(e); },
+        onBlur: ({ editor: e }) => { if (autolinkEnabled(e))
+            autolinkTrailing(e); onBlur?.(e); },
         onDestroy: () => onDestroy?.(),
     });
     return editor;
 }
 
-// src/generateHTML.ts
-function getHTMLFromFragment(doc, schema, options) {
-  if (typeof window === "undefined") {
-    throw new Error(
-      "getHTMLFromFragment can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
-    );
-  }
-  const wrap = window.document.createElement("div");
-  DOMSerializer.fromSchema(schema).serializeFragment(
-    doc.content,
-    {
-      document: window.document
-    },
-    wrap
-  );
-  return wrap.innerHTML;
-}
-
-// src/generateHTML.ts
-function generateHTML(doc, extensions) {
-  if (typeof window === "undefined") {
-    throw new Error(
-      "generateHTML can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
-    );
-  }
-  const schema = getSchema(extensions);
-  const contentNode = Node$1.fromJSON(schema, doc);
-  return getHTMLFromFragment(contentNode, schema);
-}
-function generateJSON(html, extensions, options) {
-  if (typeof window === "undefined") {
-    throw new Error(
-      "generateJSON can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
-    );
-  }
-  const schema = getSchema(extensions);
-  const doc = new window.DOMParser().parseFromString(html, "text/html");
-  if (!doc) {
-    throw new Error("Failed to parse HTML string");
-  }
-  return DOMParser.fromSchema(schema).parse(doc.body, options).toJSON();
-}
-
-const BASE_INLINE = ['p', 'br', 'strong', 'em', 'a', 'span'];
-const BASE_ATTR = ['href', 'target', 'rel', 'data-mention-id', 'data-mention-label'];
-const SANITIZE_CONFIGS = {
-    // Más ancho que su schema A PROPÓSITO (única excepción al lock-step): el
-    // editor `comment` no puede autorar listas ni headings (STARTERKIT_CONFIG los
-    // apaga y ProseMirror descarta esos nodos al parsear el paste), pero el
-    // VIEWER tiene que pintarlos cuando el HTML entra por API — una nota de
-    // enriquecimiento (Apollo.io) trae <ul>/<li>/<h4> y con KEEP_CONTENT el
-    // texto se hoisteaba al padre: lista corrida, heading fundido en el cuerpo.
-    // Espejo inline en core/co-rich-text-viewer.tsx (ALLOWED_TAGS.comment).
-    comment: {
-        ALLOWED_TAGS: [...BASE_INLINE, 'ul', 'ol', 'li', 'h1', 'h2', 'h3', 'h4'],
-        ALLOWED_ATTR: [...BASE_ATTR],
-        ALLOW_DATA_ATTR: false,
-    },
-    task: {
-        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'input', 'label'],
-        ALLOWED_ATTR: [...BASE_ATTR, 'type', 'checked', 'disabled', 'data-type', 'data-checked', 'data-variant'],
-        ALLOW_DATA_ATTR: false,
-    },
-    // Lock-step con getExtensions('notes'): task sin checklists + TextStyle/Color
-    // (`style` capado a STYLE_ALLOWED_PROPS) + Highlight multicolor (`mark` con
-    // `data-color`).
-    notes: {
-        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'mark'],
-        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-color'],
-        ALLOW_DATA_ATTR: false,
-    },
-    email: {
-        ALLOWED_TAGS: [
-            ...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote',
-            'h2', 'h3', 'div', 'img',
-        ],
-        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'data-transform', 'data-fallback', 'src', 'alt', 'width', 'height', 'data-file-id', 'data-image-layout'],
-        ALLOW_DATA_ATTR: false,
-    },
-    document: {
-        ALLOWED_TAGS: [
-            ...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote',
-            'h1', 'h2', 'h3', 'h4', 'hr', 'div', 'mark', 'img',
-            'table', 'thead', 'tbody', 'tr', 'th', 'td',
-            'input', 'label', 'iframe',
-        ],
-        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'colspan', 'rowspan', 'src', 'alt', 'width', 'height', 'type', 'checked', 'disabled', 'allowfullscreen', 'frameborder', 'allow', 'loading'],
-        ALLOW_DATA_ATTR: true,
-    },
-    'block-email': {
-        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'h2', 'h3', 'div', 'img'],
-        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'data-transform', 'data-fallback', 'src', 'alt', 'width', 'height', 'data-file-id', 'data-image-layout', 'data-type', 'data-label', 'data-href', 'data-bg', 'data-color', 'data-height'],
-        ALLOW_DATA_ATTR: false,
-    },
-};
-/**
- * `<iframe>`s are permitted only with an `https:` source (blocks javascript:,
- * data:, and plain http: embeds). This is what makes allowing iframes safe-ish
- * for a trusted-author document; YouTube embeds satisfy it too.
- */
-const SAFE_IFRAME_SRC_RE = /^https:\/\/[^\s"'<>]+$/i;
-/** Tags forbidden in every preset, regardless of the allow-list. */
-const FORBID_TAGS = ['script', 'object', 'embed', 'form', 'textarea', 'style'];
-/** Attributes forbidden in every preset (event handlers handled by DOMPurify itself). */
-const FORBID_ATTR = ['onerror', 'onload', 'onclick'];
-/**
- * Resolve the effective config for a preset + feature overrides. Features can
- * only ADD capabilities (mirroring `getExtensions`, where they register extra
- * nodes); they never narrow a preset's base whitelist.
- */
-function configFor(preset, features) {
-    const cfg = SANITIZE_CONFIGS[preset] ?? SANITIZE_CONFIGS.task;
-    if (!features)
-        return cfg;
-    const tags = new Set(cfg.ALLOWED_TAGS);
-    const attr = new Set(cfg.ALLOWED_ATTR);
-    if (features.image) {
-        tags.add('img');
-        ['src', 'alt', 'width', 'height'].forEach((a) => attr.add(a));
-    }
-    if (features.variables)
-        attr.add('data-variable');
-    if (features.mentions) {
-        // data-mention-id/label ya están en BASE_ATTR. Los attrs del markup V1
-        // (quill-mention) se suman porque el BACKEND los parsea para notificar —
-        // re-editar una nota no debe destruirlos.
-        // Espejo inline en core/co-rich-text-viewer.tsx (el viewer no importa este módulo para no cargar el engine) — si cambias esta lista, cambia la del viewer.
-        ['data-id', 'data-value', 'data-denotation-char', 'data-index'].forEach((a) => attr.add(a));
+function computePageBreaks(atoms, pageContentHeight) {
+    const breaks = [];
+    if (!atoms.length || !(pageContentHeight > 0))
+        return { breaks, pageCount: 1 };
+    let page = 1;
+    let start = 0;
+    let pageTop = atoms[0].top;
+    let i = 0;
+    while (i < atoms.length) {
+        const atom = atoms[i];
+        const bottom = atom.top + atom.height;
+        if (bottom - pageTop <= pageContentHeight) {
+            i += 1;
+            continue;
+        }
+        if (i === start) {
+            // Más alto que una hoja: ocupa las que necesite; no hay frontera adentro.
+            const extra = Math.ceil((bottom - pageTop) / pageContentHeight) - 1;
+            page += extra;
+            pageTop += extra * pageContentHeight;
+            i += 1;
+            continue;
+        }
+        let b = i;
+        while (b - 1 > start && atoms[b - 1].keepWithNext)
+            b -= 1;
+        page += 1;
+        breaks.push({ pos: atoms[b].pos, page });
+        start = b;
+        pageTop = atoms[b].top;
+        i = b;
     }
-    return { ...cfg, ALLOWED_TAGS: [...tags], ALLOWED_ATTR: [...attr] };
+    return { breaks, pageCount: page };
 }
 /**
- * `style` is only allowed in notes/email/document, and even there we cap it to
- * the properties our extensions actually emit (TextStyle/Color/TextAlign,
- * ListStyleExtension's `list-style-type`). Everything else — position,
- * background-image url(), etc. — is UI-redressing/tracking surface.
+ * Resta a cada átomo la altura de las bandas de salto que ya están dibujadas
+ * por encima (V1 medía con las bandas viejas en el flujo y cortaba antes).
  */
-const STYLE_ALLOWED_PROPS = new Set(['color', 'background-color', 'text-align', 'list-style-type']);
-/**
- * Sanitize an HTML string for the given preset (+ feature overrides — pass the
- * same `features` you gave `getExtensions`/`createEditor` so the whitelist
- * stays in lock-step with the schema). Always strips script/object/embed/style/
- * form/event-handlers and `javascript:` URLs (DOMPurify default). `<iframe>` is
- * allowed ONLY for the document preset and ONLY with an `https:` source
- * (YouTube, Vimeo, Loom, Slides, … survive save/render; unsafe embeds are
- * dropped). `style` is capped to color/background-color/text-align.
- */
-function sanitize(html, preset = 'task', features) {
-    if (!html)
-        return '';
-    const cfg = configFor(preset, features);
-    purify.addHook('uponSanitizeElement', (node, data) => {
-        // Only allow <input type="checkbox"> (task list checkboxes); strip others.
-        if (data.tagName === 'input' && node.type !== 'checkbox') {
-            node.parentNode?.removeChild(node);
-        }
-        // Allow only https iframes (YouTube and other embeds); drop anything else.
-        if (data.tagName === 'iframe') {
-            const src = node.getAttribute('src') || '';
-            if (!SAFE_IFRAME_SRC_RE.test(src))
-                node.parentNode?.removeChild(node);
+function stripBandOffsets(atoms, bands) {
+    if (!bands.length)
+        return atoms;
+    const sorted = [...bands].sort((a, b) => a.top - b.top);
+    return atoms.map((atom) => {
+        let shift = 0;
+        for (const band of sorted) {
+            if (band.top < atom.top)
+                shift += band.height;
+            else
+                break;
         }
+        return shift ? { ...atom, top: atom.top - shift } : atom;
     });
-    // Cap `style` to the properties our extensions actually emit; strip the rest
-    // (position, background-image url(), expression(), …). Drop the attr entirely
-    // when nothing survives.
-    purify.addHook('uponSanitizeAttribute', (_node, data) => {
-        if (data.attrName !== 'style')
-            return;
-        const safe = data.attrValue
-            .split(';')
-            .map((d) => d.trim())
-            .filter((d) => {
-            const colon = d.indexOf(':');
-            if (colon <= 0)
-                return false;
-            const prop = d.slice(0, colon).trim().toLowerCase();
-            return STYLE_ALLOWED_PROPS.has(prop) && !/url\s*\(|expression\s*\(/i.test(d);
-        });
-        data.attrValue = safe.join('; ');
-        if (!data.attrValue)
-            data.keepAttr = false;
+}
+const ATOM_TYPES = new Set(['listItem', 'tableRow']);
+const CONTAINER_TYPES = new Set(['bulletList', 'orderedList', 'table']);
+function classifyPaginationNode(node) {
+    const name = node?.type?.name;
+    if (!name || name === 'doc')
+        return 'skip';
+    if (CONTAINER_TYPES.has(name))
+        return 'container';
+    if (ATOM_TYPES.has(name))
+        return 'atom';
+    if (node?.isBlock)
+        return 'atom';
+    return 'skip';
+}
+function isKeepWithNext(node) {
+    return node.type.name === 'heading' && Number(node.attrs?.level) >= 2;
+}
+/** Columnas de una tabla = suma de colspan de su primera fila (banda-fila que cruza la tabla). */
+function tableColumnCount(tableNode) {
+    const firstRow = tableNode && typeof tableNode.child === 'function' ? tableNode.child(0) : null;
+    if (!firstRow || typeof firstRow.forEach !== 'function')
+        return 1;
+    let cols = 0;
+    firstRow.forEach((cell) => {
+        cols += cell?.attrs?.colspan || 1;
     });
-    try {
-        const clean = purify.sanitize(html, {
-            ALLOWED_TAGS: cfg.ALLOWED_TAGS,
-            ALLOWED_ATTR: cfg.ALLOWED_ATTR,
-            ALLOW_DATA_ATTR: cfg.ALLOW_DATA_ATTR ?? false,
-            FORBID_TAGS,
-            FORBID_ATTR,
-            ADD_ATTR: ['target', 'allowfullscreen', 'frameborder', 'allow'],
-        });
-        return clean;
-    }
-    finally {
-        purify.removeHook('uponSanitizeElement');
-        purify.removeHook('uponSanitizeAttribute');
-    }
+    return cols || 1;
 }
 
-/** Schema-affecting extensions only (no Placeholder/CharacterCount). */
-function schemaExtensions(preset, features) {
-    return getExtensions(preset, { includeUiExtensions: false, features });
-}
-function isEmptyDoc(doc) {
-    if (!doc)
-        return true;
-    const content = doc.content;
-    if (!Array.isArray(content) || content.length === 0)
-        return true;
-    // A single empty paragraph counts as empty.
-    return content.every((n) => n?.type === 'paragraph' && (!n.content || n.content.length === 0));
-}
-/** ProseMirror JSON → sanitized HTML for the given preset (+ feature overrides). */
-function jsonToHtml(doc, preset = 'task', features) {
-    if (isEmptyDoc(doc))
-        return '';
-    const html = generateHTML(doc, schemaExtensions(preset, features));
-    return sanitize(html, preset, features);
-}
-/** HTML string → ProseMirror JSON (tolerant; unknown nodes are dropped by the schema). */
-function htmlToJson(html, preset = 'task', features) {
-    const safe = sanitize(html ?? '', preset, features);
-    return generateJSON(safe, schemaExtensions(preset, features));
+/** px a 96 dpi. */
+const PAGE_SIZES = {
+    letter: { width: 816, height: 1056 },
+    a4: { width: 794, height: 1123 },
+    legal: { width: 816, height: 1344 },
+};
+/** Separación visual entre hojas (no existe en el PDF). */
+const PAGE_GAP_PX = 24;
+const PAGINATION_META = 'coPagination';
+function resolvePageSize(page) {
+    if (!page)
+        return PAGE_SIZES.letter;
+    if (typeof page === 'string')
+        return PAGE_SIZES[page] ?? PAGE_SIZES.letter;
+    return { width: Number(page.width), height: Number(page.height) };
+}
+function pageContentHeight(o) {
+    return o.page.height - o.margins.top - o.margins.bottom - o.header.height - o.footer.height;
 }
 /**
- * ProseMirror JSON → plain text. Walks the document directly (no engine), so
- * it stays cheap and dependency-light. Block nodes are separated by newlines.
+ * Top relativo a `root` sumando `offsetTop` por la cadena de offsetParent.
+ * `root` tiene que ser posicionado (la extensión le pone `position: relative`).
+ * Son px de LAYOUT: un `transform: scale()` de zoom no los altera.
  */
-function jsonToText(doc) {
-    if (!doc)
-        return '';
-    const BLOCK = new Set([
-        'paragraph', 'heading', 'blockquote', 'listItem', 'bulletList',
-        'orderedList', 'codeBlock', 'horizontalRule',
-    ]);
-    const out = [];
-    const walk = (node) => {
-        if (!node)
-            return;
-        if (node.type === 'text' && typeof node.text === 'string') {
-            out.push(node.text);
-            return;
-        }
-        if (node.type === 'variable') {
-            out.push(`{{${node.attrs?.name ?? ''}}}`);
-            return;
-        }
-        if (node.type === 'mention') {
-            out.push(`@${node.attrs?.label ?? ''}`);
-            return;
-        }
-        if (node.type === 'hardBreak') {
-            out.push('\n');
-            return;
-        }
-        if (Array.isArray(node.content))
-            node.content.forEach(walk);
-        if (BLOCK.has(node.type))
-            out.push('\n');
+function layoutBox(el, root) {
+    let top = 0;
+    let node = el;
+    while (node && node !== root) {
+        top += node.offsetTop;
+        node = node.offsetParent;
+    }
+    return { top, height: el.offsetHeight };
+}
+const defaultSchedule = (cb) => {
+    if (typeof requestAnimationFrame === 'function')
+        requestAnimationFrame(() => cb());
+    else
+        setTimeout(cb, 16);
+};
+function toLayoutOptions(o) {
+    return {
+        page: resolvePageSize(o.page),
+        margins: { ...o.margins },
+        header: { height: o.header?.height ?? 0 },
+        footer: { height: o.footer?.height ?? 0 },
+        gap: o.gap ?? PAGE_GAP_PX,
     };
-    walk(doc);
-    return out.join('').replace(/\n{3,}/g, '\n\n').trim();
-}
-
-var RichText = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  COLOR_PALETTE: COLOR_PALETTE,
-  CalloutNode: CalloutNode,
-  CobaltTaskItem: CobaltTaskItem,
-  CobaltTaskList: CobaltTaskList,
-  FontFamilyExtension: FontFamilyExtension,
-  FontSizeExtension: FontSizeExtension,
-  FontWeightExtension: FontWeightExtension,
-  IndentExtension: IndentExtension,
-  LetterSpacingExtension: LetterSpacingExtension,
-  LineHeightExtension: LineHeightExtension,
-  ListStyleExtension: ListStyleExtension,
-  MentionNode: MentionNode,
-  PRESETS: PRESETS,
-  SANITIZE_CONFIGS: SANITIZE_CONFIGS,
-  TABLE_CONTEXT_ITEMS: TABLE_CONTEXT_ITEMS,
-  VariableNode: VariableNode,
-  createEditor: createEditor,
-  defaultToolbarForPreset: defaultToolbarForPreset,
-  getExtensions: getExtensions,
-  htmlToJson: htmlToJson,
-  jsonToHtml: jsonToHtml,
-  jsonToText: jsonToText,
-  maxLengthForPreset: maxLengthForPreset,
-  sanitize: sanitize,
-  toolbarItems: toolbarItems
+}
+/**
+ * Banda de salto: margen inferior (+ pie) de la hoja que termina, separación
+ * entre hojas y margen superior (+ encabezado) de la que empieza. Dentro de una
+ * tabla va envuelta en una fila con el colspan de la tabla (un div entre `tr`
+ * lo expulsaría el navegador).
+ */
+function buildPageGap(page, pageCount, o, header, cols = 0) {
+    const foot = o.margins.bottom + o.footer.height;
+    const head = o.margins.top + o.header.height;
+    const band = document.createElement('div');
+    band.className = 'co-doc-page-gap';
+    band.setAttribute('contenteditable', 'false');
+    band.style.height = `${foot + o.gap + head}px`;
+    const bottom = document.createElement('div');
+    bottom.className = 'co-doc-page-gap__foot';
+    bottom.style.height = `${foot}px`;
+    const between = document.createElement('div');
+    between.className = 'co-doc-page-gap__between';
+    between.style.height = `${o.gap}px`;
+    const top = document.createElement('div');
+    top.className = 'co-doc-page-gap__head';
+    top.style.height = `${head}px`;
+    top.style.paddingTop = `${o.margins.top}px`;
+    top.style.boxSizing = 'border-box';
+    if (header)
+        top.appendChild(header);
+    band.append(bottom, between, top);
+    band.setAttribute('data-page', String(page));
+    band.setAttribute('data-page-count', String(pageCount));
+    if (!cols) {
+        band.setAttribute('data-co-page-gap', String(page));
+        return band;
+    }
+    const tr = document.createElement('tr');
+    tr.className = 'co-doc-page-gap-row';
+    tr.setAttribute('contenteditable', 'false');
+    tr.setAttribute('data-co-page-gap', String(page));
+    const td = document.createElement('td');
+    td.setAttribute('colspan', String(cols));
+    td.appendChild(band);
+    tr.appendChild(td);
+    return tr;
+}
+function measureLayout(view, opts, measure) {
+    const root = view.dom;
+    const atoms = [];
+    view.state.doc.descendants((node, pos) => {
+        const kind = classifyPaginationNode(node);
+        if (kind === 'container')
+            return true;
+        if (kind === 'skip')
+            return false;
+        const dom = view.nodeDOM(pos);
+        if (!(dom instanceof HTMLElement))
+            return false;
+        const box = measure(dom, root);
+        if (box.height > 0)
+            atoms.push({ pos, top: box.top, height: box.height, keepWithNext: isKeepWithNext(node) });
+        return false;
+    });
+    const bands = Array.from(root.querySelectorAll('[data-co-page-gap]')).map((el) => measure(el, root));
+    return computePageBreaks(stripBandOffsets(atoms, bands), pageContentHeight(opts));
+}
+const paginationKey = new PluginKey('coPagination');
+const Pagination = Extension.create({
+    name: 'pagination',
+    addOptions() {
+        return {
+            page: 'letter',
+            margins: { top: 38, right: 38, bottom: 38, left: 38 },
+            header: { height: 0 },
+            footer: { height: 0 },
+            gap: PAGE_GAP_PX,
+            renderHeader: null,
+            onPagesChange: null,
+            measure: layoutBox,
+            schedule: defaultSchedule,
+        };
+    },
+    addStorage() {
+        return { pageCount: 1 };
+    },
+    addCommands() {
+        return {
+            setPaginationOptions: (patch) => ({ tr, dispatch }) => {
+                if (dispatch)
+                    tr.setMeta(PAGINATION_META, { patch });
+                return true;
+            },
+            remeasurePages: () => ({ tr, dispatch }) => {
+                if (dispatch)
+                    tr.setMeta(PAGINATION_META, { remeasure: true });
+                return true;
+            },
+        };
+    },
+    addProseMirrorPlugins() {
+        const options = this.options;
+        const storage = this.storage;
+        let lastEmitted = 0;
+        const decorationsFor = (state, st) => {
+            const decos = [];
+            for (const br of st.layout.breaks) {
+                if (br.pos < 0 || br.pos > state.doc.content.size)
+                    continue;
+                // Nunca un widget de bloque dentro de contenido inline.
+                if (state.doc.resolve(br.pos).parent.inlineContent)
+                    continue;
+                const node = state.doc.nodeAt(br.pos);
+                const cols = node?.type.name === 'tableRow' ? tableColumnCount(state.doc.resolve(br.pos).parent) : 0;
+                decos.push(Decoration.widget(br.pos, () => buildPageGap(br.page, st.layout.pageCount, st.opts, options.renderHeader?.(br.page, st.layout.pageCount) ?? null, cols), { side: -1, key: `co-pg-${br.page}-${st.layout.pageCount}-v${st.version}-c${cols}` }));
+            }
+            return DecorationSet.create(state.doc, decos);
+        };
+        return [
+            new Plugin({
+                key: paginationKey,
+                state: {
+                    init: () => ({ layout: { breaks: [], pageCount: 1 }, opts: toLayoutOptions(options), version: 0, dirty: true }),
+                    apply(tr, prev) {
+                        const meta = tr.getMeta(PAGINATION_META);
+                        let next = prev;
+                        if (tr.docChanged) {
+                            next = {
+                                ...next,
+                                dirty: true,
+                                // Un salto cuya frontera se borró (p. ej. unir párrafos en el borde de una hoja)
+                                // se descarta: mapearlo lo dejaría dentro de un textblock. La medición siguiente
+                                // lo recalcula.
+                                layout: {
+                                    ...next.layout,
+                                    breaks: next.layout.breaks.flatMap((b) => {
+                                        const r = tr.mapping.mapResult(b.pos);
+                                        return r.deleted ? [] : [{ ...b, pos: r.pos }];
+                                    }),
+                                },
+                            };
+                        }
+                        if (meta?.patch) {
+                            const merged = toLayoutOptions({ ...next.opts, ...meta.patch, page: meta.patch.page ?? next.opts.page });
+                            next = { ...next, opts: merged, version: next.version + 1, dirty: true };
+                        }
+                        if (meta?.remeasure)
+                            next = { ...next, dirty: true };
+                        if (meta?.layout)
+                            next = { ...next, layout: meta.layout, dirty: false };
+                        return next;
+                    },
+                },
+                props: {
+                    decorations(state) {
+                        const st = paginationKey.getState(state);
+                        return st ? decorationsFor(state, st) : DecorationSet.empty;
+                    },
+                },
+                view(view) {
+                    const root = view.dom;
+                    if (!root.style.position)
+                        root.style.position = 'relative';
+                    let scheduled = false;
+                    let alive = true;
+                    const run = () => {
+                        scheduled = false;
+                        if (!alive || view.isDestroyed)
+                            return;
+                        const st = paginationKey.getState(view.state);
+                        if (!st)
+                            return;
+                        const layout = measureLayout(view, st.opts, options.measure);
+                        storage.pageCount = layout.pageCount;
+                        view.dispatch(view.state.tr.setMeta(PAGINATION_META, { layout }));
+                        if (layout.pageCount !== lastEmitted) {
+                            lastEmitted = layout.pageCount;
+                            options.onPagesChange?.(layout.pageCount);
+                        }
+                    };
+                    const maybeSchedule = () => {
+                        const st = paginationKey.getState(view.state);
+                        if (!st?.dirty || scheduled)
+                            return;
+                        scheduled = true;
+                        options.schedule(run);
+                    };
+                    const remeasure = () => {
+                        if (alive && !view.isDestroyed) {
+                            view.dispatch(view.state.tr.setMeta(PAGINATION_META, { remeasure: true }));
+                        }
+                    };
+                    // Imágenes que cargan tarde cambian alturas (las de las bandas no: tienen alto fijo).
+                    const onLoad = (e) => {
+                        const t = e.target;
+                        if (!t || t.tagName !== 'IMG' || t.closest('[data-co-page-gap]'))
+                            return;
+                        remeasure();
+                    };
+                    root.addEventListener('load', onLoad, true);
+                    const fonts = document.fonts;
+                    fonts?.ready?.then(remeasure).catch(() => { });
+                    // Fuentes que cargan después (un peso o familia aplicado por primera vez).
+                    fonts?.addEventListener?.('loadingdone', remeasure);
+                    maybeSchedule();
+                    return {
+                        update: () => maybeSchedule(),
+                        destroy: () => {
+                            alive = false;
+                            root.removeEventListener('load', onLoad, true);
+                            fonts?.removeEventListener?.('loadingdone', remeasure);
+                        },
+                    };
+                },
+            }),
+        ];
+    },
 });
 
-export { RichText as R };
+export { defaultToolbarForPreset as A, getImageLayoutMode as B, CalloutNode as C, getPrintExtensions as D, headerImageWidth as E, FIELD_SYNC_META as F, layoutBox as G, maxLengthForPreset as H, IMAGE_LAYOUT_MODES as I, nextFreeSlot as J, normalizePrintHtml as K, LetterSpacingExtension as L, MentionNode as M, pageContentHeight as N, parseFieldToken as O, PAGE_GAP_PX as P, resolvePageSize as Q, sanitizeFieldName as R, SANITIZE_CONFIGS as S, TRAILING_BREAK_CLASS as T, serializePrintHtml as U, VariableNode as V, setFieldValuesInHtml as W, signatureBoxStyle as X, signatureSlotHtml as Y, signatureToken as Z, stripBandOffsets as _, generateJSON as a, getExtensions as b, CobaltTaskItem as c, CobaltTaskList as d, FontFamilyExtension as e, FontSizeExtension as f, generateHTML as g, FontWeightExtension as h, isPrintPreset as i, IndentExtension as j, LineHeightExtension as k, ListStyleExtension as l, MergeField as m, PAGE_SIZES as n, PAGINATION_META as o, PRESETS as p, Pagination as q, readPrintHtml as r, sanitize as s, SIGNATURE_TOKEN_STYLE as t, SignatureSlot as u, applyImageLayoutMode as v, writePrintHtml as w, collectFields as x, computePageBreaks as y, createEditor as z };