smartrte-core 1.0.0-beta.4 → 1.0.0-beta.6

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 1.0.0-beta.6
+
+- Fix pasting a long, list-free document (many short paragraphs, no images) being slow enough to look broken — the Office/Google Docs list normalizers recursed into every paragraph hunting for nested lists a `<p>` can never structurally contain. Pasting a few thousand blocks now completes in well under a second instead of multiple seconds to tens of seconds. See `docs/bugs/clipboard-paste-slow-on-large-list-free-documents.md` for the full investigation, including a known remaining limitation for very large (10,000+ block) pastes.
+
+## 1.0.0-beta.5
+
+- Add a per-block `lineHeight` attribute (paragraph, heading, blockquote, code block) — a unitless multiplier matching CSS `line-height`'s own unitless mode (`1`, `1.5`, `2`, ...), consistent with how `align`/`indentLevel` are represented. Absence means no override (the browser/font's own natural line-height), not a forced `1`. Full HTML round-trip fidelity via a dedicated `data-smart-line-height` marker — deliberately does **not** fall back to reading a bare CSS `line-height` value on import (unlike `align`/`indentLevel`'s own CSS fallbacks): real captured clipboard fixtures show `line-height` is frequently an ambient, whole-document default baked onto every paragraph, not a deliberate per-paragraph choice, and recognizing it would have silently misattributed that default as an explicit override on every pasted document. Real Word line spacing (`w:spacing`/`w:line`/`w:lineRule="auto"`) on DOCX export; declared `lossy` there (confirmed empirically that DOCX reimport via mammoth drops it) and `unsupported` (content preserved) in Markdown. Inherits `full` PDF fidelity for free, since this package's "Save as PDF" prints the same HTML export.
+- Add a `page_break` atom node — a print/export pagination marker, distinct from the existing `divider` (horizontal rule) node. Exports to a real paginating marker in HTML (and this package's own "Save as PDF", which prints that same HTML) and a real native Word page break in DOCX; declared `unsupported` in Markdown (no pagination concept there), preserved as an inert comment rather than silently dropped. Add an `AtomDeclaration` for `divider` so it can be inserted via the standard atom-insertion command, not just recovered from pasted `<hr>`. Fix `divider` silently exporting as an empty paragraph in DOCX (no visible line at all).
+- Fix a real HTML round-trip bug found while building the above: a div-tagged atom's own round-trip marker (`block_formula`, and the new `page_break`) was silently deleted on reimport — treated as a meaningless transparent wrapper div and recursed into (destroying it) before ever reaching the atom-parsing logic. See `docs/bugs/html-import-div-atom-markers-treated-as-transparent-wrapper.md`.
+- Fix formulas rendering as invisible empty placeholders in "Save as PDF" output — the print document never baked real KaTeX HTML (the same gap already fixed once for a different static-HTML consumer) and never loaded KaTeX's own CSS at all (a brand-new, isolated print window shares none of the host page's stylesheets). See `docs/bugs/pdf-export-formula-invisible-and-misleading-label.md`.
+
 ## 1.0.0-beta.4
 
 - Fix HTML import (paste and loading a document's initial value) rendering real content as unreadable `[Unsupported: ...]` placeholders when a bare `<span>`/`<b>`/other inline-formatting element sits directly at the document root, or is interleaved between real blocks (a `<blockquote>`, `<div>`-wrapped lines, images) with no wrapping `<p>` — a common shape from legacy, pre-migration editor exports. Also fixes the same gap in `<blockquote>`/table cells/list items for content interleaved between blocks (previously only content entirely before any block content was recovered correctly).

package/dist/foundation/atom/declarations.js

@@ -14,4 +14,8 @@ export const atomDeclarations = [
     { type: "block_formula", kind: "formula", group: "block", validate: formulaValid },
     { type: "video", kind: "video", group: "block", validate: mediaValid("video") },
     { type: "audio", kind: "audio", group: "block", validate: mediaValid("audio") },
+    // No attrs to validate - a divider/page break carries none (see
+    // atom/schema.ts's own comments on both node types).
+    { type: "divider", kind: "divider", group: "block", validate: () => true },
+    { type: "page_break", kind: "pageBreak", group: "block", validate: () => true },
 ];

package/dist/foundation/atom/formats.d.ts

@@ -4,9 +4,20 @@ export declare const atomToHtml: (node: SmartElementNode, options?: {
     renderFormulaHtml?: boolean;
 }) => string;
 export declare const atomFromHtmlElement: (rawElement: Element) => SmartElementNode | null;
+/**
+ * page_break: Markdown has no pagination concept at all (declared
+ * `unsupported` in formats/fidelity.ts) - emitting nothing would silently
+ * delete the marker with no trace, the same class of bug this project has
+ * hit before for images/formulas (see formats/fidelity.ts's own
+ * images-media/formulas notes on that history). An HTML comment is inert
+ * in every real Markdown renderer (so it never appears as visible garbage
+ * text) but keeps the marker's *position* recorded in the exported file -
+ * genuinely honest `unsupported`, not a round-trippable format: nothing
+ * parses this comment back into a page_break node on import.
+ */
 export declare const atomToMarkdown: (node: SmartElementNode) => string;
 export interface AtomDocxRun {
-    readonly kind: "image" | "text";
+    readonly kind: "image" | "text" | "pageBreak";
     readonly source: string;
     readonly alt?: string;
 }
@@ -16,9 +27,29 @@ export interface AtomDocxRun {
  * <m:oMath> zone, not translated to real OMML and not rendered as an
  * image. Word will show the raw LaTeX string, not typeset math - this is
  * `kind: "text"`, not `"image"`, to describe that honestly.
+ *
+ * page_break returns `kind: "pageBreak"` (`source` unused, kept empty) -
+ * the real docx/export.ts blockXml dispatcher turns this into a genuine
+ * `<w:br w:type="page"/>` run, matching what Word's own Ctrl+Enter inserts,
+ * not a visual-only text marker.
  */
 export declare const atomToDocx: (node: SmartElementNode) => AtomDocxRun;
+/**
+ * IMPORTANT: this function is NOT what actually produces this package's
+ * real "Save as PDF" output today. That feature (react/src/adapters/
+ * pdfPrint.ts's printSmartDocumentAsPdf) opens the browser's native print
+ * dialog against `buildPdfPrintDocument` (formats/pdf/format.ts), which
+ * calls `serializeCanonicalListHtml` - i.e. `atomToHtml` above, not this
+ * function. This function only backs the per-node PDF `FeatureFormatCodec`
+ * fidelity-declaration cell (featureCodecs.ts) and its own unit tests - a
+ * real pagination pipeline built around per-node PDF primitives (a PDF
+ * library call, not a browser print) would consume this `"pageBreak"` kind
+ * to start a new page, but no such pipeline exists in this codebase today.
+ * Real page-break pagination in the actual "Save as PDF" feature comes
+ * entirely from atomToHtml's `break-before: page` marker, verified via
+ * e2e against the real print document, not via this function.
+ */
 export declare const atomToPdf: (node: SmartElementNode) => {
-    kind: "image" | "text";
+    kind: "image" | "text" | "pageBreak";
     value: string;
 };

package/dist/foundation/atom/formats.js

@@ -63,6 +63,16 @@ export const atomToHtml = (node, options) => {
     }
     if (node.type === "divider")
         return `<hr data-smart-id="${escape(node.id)}" data-smart-type="divider">`;
+    // Both `break-before: page` (the current CSS Fragmentation property) and
+    // `page-break-before: always` (its older, still widely-honored alias) are
+    // set directly on the marker so it actually paginates wherever this HTML
+    // is printed - including this package's own "Save as PDF" (a real browser
+    // print of this exact HTML; see react/src/adapters/pdfPrint.ts's own doc
+    // comment). A screen-media renderer (the live editor) ignores both
+    // properties entirely, so this is safe to always emit rather than gating
+    // behind @media print.
+    if (node.type === "page_break")
+        return `<div data-smart-id="${escape(node.id)}" data-smart-type="page_break" style="break-before: page; page-break-before: always;" role="separator" aria-label="Page break"></div>`;
     throw new Error(`Unsupported atom type "${node.type}".`);
 };
 export const atomFromHtmlElement = (rawElement) => {
@@ -108,8 +118,21 @@ export const atomFromHtmlElement = (rawElement) => {
     }
     if (type === "divider" || element.tagName === "HR")
         return { type: "divider", id };
+    if (type === "page_break")
+        return { type: "page_break", id };
     return null;
 };
+/**
+ * page_break: Markdown has no pagination concept at all (declared
+ * `unsupported` in formats/fidelity.ts) - emitting nothing would silently
+ * delete the marker with no trace, the same class of bug this project has
+ * hit before for images/formulas (see formats/fidelity.ts's own
+ * images-media/formulas notes on that history). An HTML comment is inert
+ * in every real Markdown renderer (so it never appears as visible garbage
+ * text) but keeps the marker's *position* recorded in the exported file -
+ * genuinely honest `unsupported`, not a round-trippable format: nothing
+ * parses this comment back into a page_break node on import.
+ */
 export const atomToMarkdown = (node) => {
     if (node.type === "image" || node.type === "block_image")
         return `![${String(node.attrs?.alt || "")}](${String(node.attrs?.src || "")})`;
@@ -120,6 +143,8 @@ export const atomToMarkdown = (node) => {
         return `[${node.type}: ${String(node.attrs?.src || "")}](${String(node.attrs?.src || "")})`;
     if (node.type === "divider")
         return "---";
+    if (node.type === "page_break")
+        return "<!-- page break -->";
     return "";
 };
 /**
@@ -128,6 +153,11 @@ export const atomToMarkdown = (node) => {
  * <m:oMath> zone, not translated to real OMML and not rendered as an
  * image. Word will show the raw LaTeX string, not typeset math - this is
  * `kind: "text"`, not `"image"`, to describe that honestly.
+ *
+ * page_break returns `kind: "pageBreak"` (`source` unused, kept empty) -
+ * the real docx/export.ts blockXml dispatcher turns this into a genuine
+ * `<w:br w:type="page"/>` run, matching what Word's own Ctrl+Enter inserts,
+ * not a visual-only text marker.
  */
 export const atomToDocx = (node) => node.type === "formula" || node.type === "block_formula"
     ? { kind: "text", source: String(node.attrs?.source || "") }
@@ -135,9 +165,27 @@ export const atomToDocx = (node) => node.type === "formula" || node.type === "bl
         ? { kind: "image", source: String(node.attrs?.src || ""), alt: String(node.attrs?.alt || "") }
         : node.type === "divider"
             ? { kind: "text", source: "---" }
-            : { kind: "text", source: `[${node.type}: ${String(node.attrs?.src || "")}]` };
+            : node.type === "page_break"
+                ? { kind: "pageBreak", source: "" }
+                : { kind: "text", source: `[${node.type}: ${String(node.attrs?.src || "")}]` };
+/**
+ * IMPORTANT: this function is NOT what actually produces this package's
+ * real "Save as PDF" output today. That feature (react/src/adapters/
+ * pdfPrint.ts's printSmartDocumentAsPdf) opens the browser's native print
+ * dialog against `buildPdfPrintDocument` (formats/pdf/format.ts), which
+ * calls `serializeCanonicalListHtml` - i.e. `atomToHtml` above, not this
+ * function. This function only backs the per-node PDF `FeatureFormatCodec`
+ * fidelity-declaration cell (featureCodecs.ts) and its own unit tests - a
+ * real pagination pipeline built around per-node PDF primitives (a PDF
+ * library call, not a browser print) would consume this `"pageBreak"` kind
+ * to start a new page, but no such pipeline exists in this codebase today.
+ * Real page-break pagination in the actual "Save as PDF" feature comes
+ * entirely from atomToHtml's `break-before: page` marker, verified via
+ * e2e against the real print document, not via this function.
+ */
 export const atomToPdf = (node) => node.type === "formula" || node.type === "block_formula" ? { kind: "text", value: String(node.attrs?.source || "") }
     : node.type === "video" ? { kind: "image", value: String(node.attrs?.poster || node.attrs?.src || "") }
         : node.type === "image" || node.type === "block_image" ? { kind: "image", value: String(node.attrs?.src || "") }
             : node.type === "divider" ? { kind: "text", value: "---" }
-                : { kind: "text", value: String(node.attrs?.src || "") };
+                : node.type === "page_break" ? { kind: "pageBreak", value: "" }
+                    : { kind: "text", value: String(node.attrs?.src || "") };

package/dist/foundation/atom/schema.js

@@ -55,4 +55,13 @@ export const atomNodeSpecs = [
     // case for "hr"), so every pasted <hr> fell to the generic
     // "unrecognized tag" fallback and rendered as "[Unsupported: hr]".
     { type: "divider", group: "block", atomic: true, selectable: true, marks: "" },
+    // A print/export pagination marker - deliberately its own node type, not
+    // a `divider` variant: a horizontal line is decorative content with no
+    // export-time meaning beyond "draw a line," while a page break's entire
+    // purpose is what happens at export/print time (real PDF pagination, a
+    // DOCX page-break run, `break-before: page` in printed HTML) - see
+    // atom/formats.ts's atomToPdf/atomToDocx and formats/docx/export.ts for
+    // where that distinction actually matters. No content, no attrs, same as
+    // divider.
+    { type: "page_break", group: "block", atomic: true, selectable: true, marks: "" },
 ];

package/dist/foundation/atom/types.d.ts

@@ -1,6 +1,6 @@
 import type { Attrs, SmartDocument, SmartOperation, SmartSchema } from "../types.js";
 import type { PositionLookup, ResolvedScope } from "../scope/types.js";
-export type AtomKind = "image" | "formula" | "video" | "audio";
+export type AtomKind = "image" | "formula" | "video" | "audio" | "divider" | "pageBreak";
 export type AtomStatus = "pending" | "ready" | "error";
 export interface AtomDeclaration {
     readonly type: string;

package/dist/foundation/block/formats.d.ts

@@ -10,6 +10,8 @@ export interface CanonicalDocxBlock {
     readonly alignment?: "left" | "center" | "right" | "justify";
     /** DOCX left indentation in twips (720 twips per canonical indent level). */
     readonly indentTwips?: number;
+    /** Word's native "multiple" line spacing unit: 240ths of a single line (240 = 1.0, 360 = 1.5). See formats/docx/export.ts's lineHeightOf for the same convention in the real exporter. */
+    readonly lineSpacing240ths?: number;
     readonly language?: string;
     readonly quoteDepth?: number;
 }

package/dist/foundation/block/formats.js

@@ -20,6 +20,7 @@ export const blockToDocxEntry = (node, quoteDepth = 0) => {
     const alignment = typeof node.attrs?.align === "string" && ["left", "center", "right", "justify"].includes(node.attrs.align)
         ? node.attrs.align : undefined;
     const indentLevel = Math.max(0, Number(node.attrs?.indentLevel) || 0);
+    const lineHeight = Number(node.attrs?.lineHeight) || 0;
     return {
         nodeId: node.id,
         kind: node.type === "code_block" ? "code" : node.type === "heading" ? "heading" : "paragraph",
@@ -28,6 +29,7 @@ export const blockToDocxEntry = (node, quoteDepth = 0) => {
         ...(level ? { outlineLevel: level - 1 } : {}),
         ...(alignment ? { alignment } : {}),
         ...(indentLevel ? { indentTwips: indentLevel * 720 } : {}),
+        ...(lineHeight ? { lineSpacing240ths: Math.round(lineHeight * 240) } : {}),
         ...(node.type === "code_block" && typeof node.attrs?.language === "string" ? { language: node.attrs.language } : {}),
         ...(quoteDepth ? { quoteDepth } : {}),
     };

package/dist/foundation/block/schema.js

@@ -1,7 +1,19 @@
 const stringAttr = { validate: (value) => typeof value === "string" };
 const alignmentAttr = { validate: (value) => ["left", "center", "right", "justify"].includes(String(value)) };
 const indentLevelAttr = { validate: (value) => Number.isInteger(value) && Number(value) >= 0 && Number(value) <= 10 };
-const blockAttrs = { align: alignmentAttr, indentLevel: indentLevelAttr };
+/**
+ * A unitless multiplier, matching CSS `line-height`'s own unitless mode
+ * (e.g. `1.5` means "1.5x the element's own font size") - deliberately not
+ * a fixed px/pt value, which would stop scaling correctly the moment
+ * `fontSize` changes on the same block. Range is generous but bounded
+ * (Google Docs' own preset list tops out at 2.5; 0.1-10 comfortably covers
+ * every preset plus realistic custom values without accepting nonsense
+ * like a negative multiplier). Absence of this attribute (not "1") means
+ * "no override" - the block renders at the browser/font's own natural
+ * line-height, exactly like `align`/`indentLevel` already work.
+ */
+const lineHeightAttr = { validate: (value) => typeof value === "number" && Number.isFinite(value) && value >= 0.1 && value <= 10 };
+const blockAttrs = { align: alignmentAttr, indentLevel: indentLevelAttr, lineHeight: lineHeightAttr };
 /** Node specs owned by the block family - extracted out of foundation/schema.ts's previously hardcoded foundationSchema literal (Phase 10). */
 export const blockNodeSpecs = [
     { type: "paragraph", group: "block", content: "inline*", attributes: blockAttrs },

package/dist/foundation/clipboard/normalizers.js

@@ -2,6 +2,20 @@ import { parseCanonicalListMarkdown, serializeCanonicalListHtml } from "../list/
 const listTags = new Set(["UL", "OL"]);
 const blockSelector = ":scope > p, :scope > h1, :scope > h2, :scope > h3, :scope > h4, :scope > h5, :scope > h6, :scope > ul, :scope > ol, :scope > blockquote, :scope > pre, :scope > table, :scope > div";
 const msoListPattern = /(?:^|;)\s*mso-list\s*:\s*([^\s;]+)\s+level(\d+)\s+([^\s;]+)/i;
+/**
+ * Elements whose HTML content model is inline-only - a real HTML parser
+ * never lets a <p>/<ul>/<ol>/<div> nest inside one of these (an outer <p>
+ * auto-closes first), so a nested Office mso-list paragraph or a
+ * declared-level <ul>/<ol> can never appear inside one. normalizeMsoLists/
+ * normalizeDeclaredLevelLists below recurse looking for exactly those two
+ * things - recursing into one of these tags is always wasted work. See
+ * docs/bugs/clipboard-paste-normalizer-quadratic-blowup-on-large-documents.md:
+ * on a real document with thousands of top-level paragraphs (the common
+ * case for a long pasted document with no lists at all), skipping this
+ * recursion is what turns an O(n) visit count with an accidentally
+ * document-size-scaled per-call cost back into genuinely linear work.
+ */
+const INLINE_LEAF_TAGS = new Set(["P", "SPAN", "B", "STRONG", "I", "EM", "U", "S", "A", "CODE", "BR", "IMG", "SUP", "SUB"]);
 const unwrap = (element) => element.replaceWith(...Array.from(element.childNodes));
 const normalizeTransparentContainers = (document) => {
     const docsWrapper = document.body.querySelector('[id^="docs-internal-guid-"]');
@@ -71,7 +85,8 @@ const normalizeMsoLists = (document) => {
         for (let index = 0; index < children.length;) {
             const first = msoListEntry(children[index]);
             if (!first) {
-                visit(children[index]);
+                if (!INLINE_LEAF_TAGS.has(children[index].tagName))
+                    visit(children[index]);
                 index += 1;
                 continue;
             }
@@ -167,7 +182,8 @@ const normalizeDeclaredLevelLists = (document) => {
             run[0].replaceWith(...roots);
             run.slice(1).forEach((list) => list.remove());
         }
-        Array.from(parent.children).forEach((child) => visit(child));
+        Array.from(parent.children).forEach((child) => { if (!INLINE_LEAF_TAGS.has(child.tagName))
+            visit(child); });
     };
     visit(document.body);
 };

package/dist/foundation/formats/docx/export.js

@@ -145,9 +145,20 @@ const inlineRun = (node, context) => {
 };
 const alignmentOf = (node) => typeof node.attrs?.align === "string" ? node.attrs.align : undefined;
 const indentLevelOf = (node) => Number(node.attrs?.indentLevel) || 0;
+/**
+ * Word's native "multiple" line spacing: `w:line` is in 240ths of a single
+ * line (240 = single/1.0, 360 = 1.5, 480 = double/2.0 - the same
+ * convention Word's own UI uses), `w:lineRule="auto"` is what makes it a
+ * multiplier rather than an exact fixed height (`"exact"`/`"atLeast"`
+ * would instead be a fixed point size, which is deliberately not what
+ * this feature stores - see schema.ts's lineHeightAttr doc comment on why
+ * a unitless multiplier was chosen over a fixed value).
+ */
+const lineHeightOf = (node) => Number(node.attrs?.lineHeight) || 0;
 const paragraphProperties = (block, extra = "") => [
     alignmentOf(block) ? `<w:jc w:val="${xmlEscape(alignmentOf(block))}"/>` : "",
     indentLevelOf(block) ? `<w:ind w:left="${indentLevelOf(block) * 480}"/>` : "",
+    lineHeightOf(block) ? `<w:spacing w:line="${Math.round(lineHeightOf(block) * 240)}" w:lineRule="auto"/>` : "",
     extra,
 ].join("");
 const paragraphXml = (children, block, context, extraProperties = "") => {
@@ -236,6 +247,20 @@ const blockXml = (block, context, listLevel = 0) => {
         return paragraphXml([{ ...block, type: "image" }], block, context);
     if (block.type === "block_formula")
         return paragraphXml([{ ...block, type: "formula" }], block, context);
+    // Previously fell through to the generic fallback below (an empty
+    // paragraph, since a divider has neither title nor src) - a horizontal
+    // line silently vanished on DOCX export with no visible trace at all.
+    // A bottom-bordered empty paragraph is exactly what Word's own
+    // Insert > Horizontal Line command produces.
+    if (block.type === "divider")
+        return '<w:p><w:pPr><w:pBdr><w:bottom w:val="single" w:sz="6" w:space="1" w:color="auto"/></w:pBdr></w:pPr></w:p>';
+    // A real Word page break (matches Ctrl+Enter) - not a visual-only text
+    // marker. See atom/formats.ts's atomToDocx doc comment: mammoth's HTML
+    // conversion (this package's own DOCX import path) does not preserve
+    // this on re-import, confirmed via a real export/import round-trip test
+    // (format.test.ts) - export fidelity is real, import fidelity is not.
+    if (block.type === "page_break")
+        return '<w:p><w:r><w:br w:type="page"/></w:r></w:p>';
     return paragraphXml([{ type: "text", text: String(block.attrs?.title || block.attrs?.src || "") }], block, context);
 };
 const numberingLevelXml = (level, format, text, font) => `<w:lvl w:ilvl="${level}"><w:start w:val="1"/><w:numFmt w:val="${format}"/><w:lvlText w:val="${text}"/><w:lvlJc w:val="left"/><w:pPr><w:tabs><w:tab w:val="num" w:pos="${720 + level * 360}"/></w:tabs><w:ind w:left="${720 + level * 360}" w:hanging="360"/></w:pPr>${font ? `<w:rPr><w:rFonts w:ascii="${font}" w:hAnsi="${font}"/></w:rPr>` : ""}</w:lvl>`;

package/dist/foundation/formats/featureCodecs.d.ts

@@ -1,18 +1,19 @@
 import type { FeatureFormatCodec } from "./codec.js";
 import { type FidelityFeature } from "./fidelity.js";
 /**
- * The 44 (feature x format) FeatureFormatCodec declarations Phase 9 SS3
- * gate 3 requires. feature/format/fidelity/note are mechanically derived
- * from builtInFormatFidelity (fidelity.ts) - that table is the single
- * source of truth for fidelity claims; this file must never restate a
- * level or note independently of it.
+ * The (feature x format) FeatureFormatCodec declarations Phase 9 SS3 gate 3
+ * requires (44 at that gate's close; "page-break" added later brings the
+ * total to 48). feature/format/fidelity/note are mechanically derived from
+ * builtInFormatFidelity (fidelity.ts) - that table is the single source of
+ * truth for fidelity claims; this file must never restate a level or note
+ * independently of it.
  *
  * parse/serialize are only attached where a genuine single-node function
  * already exists, never a fabricated per-node wrapper around whole-document
  * logic:
  * - atom/formats.ts's atomTo{Html,Markdown,Docx,Pdf} and atomFromHtmlElement
- *   operate on one SmartElementNode at a time, so images-media and formulas
- *   get real wiring for all four formats (Phase 9).
+ *   operate on one SmartElementNode at a time, so images-media, formulas,
+ *   and page-break get real wiring for all four formats.
  * - marks/formats.ts's docxProperties and block/formats.ts's blockToDocxEntry
  *   (Phase 11 Tier 2, per docs/PHASE_9_CODEC_REFACTOR_SCOPE.md's recommended
  *   marks-then-blocks order) were already genuinely single-node - or, for

package/dist/foundation/formats/featureCodecs.js

@@ -4,18 +4,19 @@ import { blockToDocxEntry } from "../block/formats.js";
 import { builtInFormatFidelity } from "./fidelity.js";
 const asAtom = (node) => node;
 /**
- * The 44 (feature x format) FeatureFormatCodec declarations Phase 9 SS3
- * gate 3 requires. feature/format/fidelity/note are mechanically derived
- * from builtInFormatFidelity (fidelity.ts) - that table is the single
- * source of truth for fidelity claims; this file must never restate a
- * level or note independently of it.
+ * The (feature x format) FeatureFormatCodec declarations Phase 9 SS3 gate 3
+ * requires (44 at that gate's close; "page-break" added later brings the
+ * total to 48). feature/format/fidelity/note are mechanically derived from
+ * builtInFormatFidelity (fidelity.ts) - that table is the single source of
+ * truth for fidelity claims; this file must never restate a level or note
+ * independently of it.
  *
  * parse/serialize are only attached where a genuine single-node function
  * already exists, never a fabricated per-node wrapper around whole-document
  * logic:
  * - atom/formats.ts's atomTo{Html,Markdown,Docx,Pdf} and atomFromHtmlElement
- *   operate on one SmartElementNode at a time, so images-media and formulas
- *   get real wiring for all four formats (Phase 9).
+ *   operate on one SmartElementNode at a time, so images-media, formulas,
+ *   and page-break get real wiring for all four formats.
  * - marks/formats.ts's docxProperties and block/formats.ts's blockToDocxEntry
  *   (Phase 11 Tier 2, per docs/PHASE_9_CODEC_REFACTOR_SCOPE.md's recommended
  *   marks-then-blocks order) were already genuinely single-node - or, for
@@ -45,7 +46,7 @@ export const builtInFeatureFormatCodecs = builtInFormatFidelity.flatMap((contrac
         fidelity: capability.level,
         note: capability.note,
     };
-    if (contract.feature === "images-media" || contract.feature === "formulas") {
+    if (contract.feature === "images-media" || contract.feature === "formulas" || contract.feature === "page-break") {
         if (format === "html") {
             return {
                 ...base,
@@ -62,7 +63,7 @@ export const builtInFeatureFormatCodecs = builtInFormatFidelity.flatMap((contrac
     if (format === "docx" && (contract.feature === "inline-marks" || contract.feature === "colors-fonts-sizes")) {
         return { ...base, serialize: (node) => markRunDocxProperties(node) };
     }
-    if (format === "docx" && (contract.feature === "headings-alignment" || contract.feature === "blockquote-code")) {
+    if (format === "docx" && (contract.feature === "headings-alignment" || contract.feature === "blockquote-code" || contract.feature === "line-height")) {
         return { ...base, serialize: (node) => blockToDocxEntry(asAtom(node)) };
     }
     return base;

package/dist/foundation/formats/fidelity.d.ts

@@ -1,7 +1,7 @@
 import type { FormatFidelityLevel, FormatId } from "./codec.js";
 export type FidelityFormat = FormatId;
 export type FidelityLevel = FormatFidelityLevel;
-export type FidelityFeature = "inline-marks" | "colors-fonts-sizes" | "headings-alignment" | "blockquote-code" | "lists" | "checklists" | "tables" | "links" | "images-media" | "formulas" | "special-characters";
+export type FidelityFeature = "inline-marks" | "colors-fonts-sizes" | "headings-alignment" | "blockquote-code" | "lists" | "checklists" | "tables" | "links" | "images-media" | "formulas" | "special-characters" | "page-break" | "line-height";
 export interface FormatFidelityCapability {
     level: FidelityLevel;
     note: string;

package/dist/foundation/formats/fidelity.js

@@ -119,5 +119,23 @@ export const builtInFormatFidelity = [
             pdf: capability("semantic", "Depends on font embedding and extractor Unicode maps."),
         },
     },
+    {
+        feature: "page-break",
+        formats: {
+            html: capability("full", "A marker element with `break-before: page`/`page-break-before: always` round-trips exactly, and genuinely paginates wherever the exported HTML is printed - including this package's own 'Save as PDF' (a real browser print of this HTML, see atom/formats.ts's atomToHtml doc comment)."),
+            markdown: capability("unsupported", "Markdown has no pagination concept. Exported as an inert `<!-- page break -->` HTML comment so the position is not silently dropped (matching this project's own history of atoms disappearing with no trace on markdown export); nothing parses this comment back into a page break on import, so this is genuinely `unsupported`, not merely undeclared."),
+            docx: capability("lossy", "A real native Word page break (`<w:br w:type=\"page\"/>`) is emitted on export - Word paginates correctly when the file is opened. Confirmed empirically (format.test.ts) that mammoth's HTML conversion (this package's own DOCX import path) drops the page break entirely on re-import, with no trace - export fidelity is real, import fidelity is not."),
+            pdf: capability("full", "This package's actual 'Save as PDF' is a real browser print of the same HTML export (react/src/adapters/pdfPrint.ts), so it inherits the html row's real pagination exactly - verified end to end via Playwright's own page.pdf() against the real print document, asserting a real page count increase. The separate atomToPdf per-node function (used only by this fidelity table's own test suite, not the real feature) is not the mechanism that produces this."),
+        },
+    },
+    {
+        feature: "line-height",
+        formats: {
+            html: capability("full", "A unitless multiplier (matching CSS line-height's own unitless mode) round-trips exactly via a data-smart-line-height attribute plus an inline `line-height:` style declaration."),
+            markdown: capability("unsupported", "Markdown has no line-spacing concept at all. The paragraph's own text is preserved in full (line-height is metadata about how it's displayed, not content) - only the spacing value itself is dropped, matching this project's non-destructive-fallback discipline (nothing else about the paragraph is lost)."),
+            docx: capability("lossy", "Word's native \"multiple\" line spacing (`w:spacing w:line=\"...\" w:lineRule=\"auto\"`) is emitted on export - Word itself displays the correct spacing when the file is opened. Confirmed empirically (format.test.ts) that mammoth's HTML conversion (this package's own DOCX import path) drops the spacing value entirely on re-import - export fidelity is real, import fidelity is not, the same asymmetry already documented for page-break."),
+            pdf: capability("full", "This package's actual 'Save as PDF' is a real browser print of the same HTML export, so it inherits the html row's real, correctly-spaced layout exactly - verified against the real print document's computed styles, not assumed."),
+        },
+    },
 ];
 export const getFormatFidelity = (feature, format) => builtInFormatFidelity.find((entry) => entry.feature === feature).formats[format];

package/dist/foundation/formats/pdf/format.js

@@ -160,12 +160,35 @@ export const importPdfDocument = async (arrayBuffer) => {
     return reconstructPdfPages(pages);
 };
 export const buildPdfPrintDocument = (document) => {
-    const html = serializeCanonicalListHtml(document, { clean: true });
+    // Same static-HTML-consumer gap as Sootr's Web Preview (see docs/bugs/
+    // formula-not-rendered-in-static-html-consumers.md): this print window
+    // never runs the live editor's own KaTeX rendering against its DOM, so
+    // without renderFormulaHtml every formula/block_formula serializes as an
+    // empty <span>/<div> - present in the markup, invisible on the printed
+    // page and in the resulting PDF. Bakes real KaTeX HTML+MathML in instead,
+    // exactly like the Web Preview fix.
+    const html = serializeCanonicalListHtml(document, { clean: true, renderFormulaHtml: true });
     return `<!doctype html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <title>Smart RTE PDF Export</title>
+  <!--
+    KaTeX's rendered HTML (baked in above) is a set of unstyled <span>s
+    without this - it is a CSS framework, not self-describing markup. This
+    print window is a brand-new, isolated document (opened via
+    window.open + document.write - see react/src/adapters/pdfPrint.ts) that
+    shares none of the host page's own stylesheets, so it needs its own
+    copy regardless of whether the host has already loaded KaTeX's CSS for
+    the live editor. Matches this package's own documented setup
+    convention (README.md's KaTeX CDN <link>) rather than inventing a
+    second one - pinned to the exact version this package bundles
+    (package.json's "katex" dependency) so the JS that generated the
+    markup and the CSS that styles it never drift apart. Requires network
+    access at export time, the same as the live editor already requires
+    for its own KaTeX CSS.
+  -->
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.18.4/dist/katex.min.css">
   <style>
     @page { margin: 18mm; }
     html, body { background: #fff; }

package/dist/foundation/list/formats.js

@@ -91,14 +91,18 @@ const effectiveStyle = (node, depth) => {
         : undefined;
 };
 const blockAttributes = (node) => {
+    const lineHeight = Number(node.attrs?.lineHeight);
+    const hasLineHeight = Number.isFinite(lineHeight) && lineHeight > 0;
     const declarations = [
         typeof node.attrs?.htmlStyle === "string" ? node.attrs.htmlStyle.replace(/;\s*$/, "") : "",
         typeof node.attrs?.align === "string" ? `text-align:${node.attrs.align}` : "",
         Number(node.attrs?.indentLevel) > 0 ? `margin-inline-start:${Number(node.attrs?.indentLevel) * 2}em` : "",
+        hasLineHeight ? `line-height:${lineHeight}` : "",
     ].filter(Boolean);
     return [
         node.attrs?.align ? ` data-smart-align="${escapeHtml(node.attrs.align)}"` : "",
         Number(node.attrs?.indentLevel) > 0 ? ` data-smart-indent="${escapeHtml(node.attrs?.indentLevel)}"` : "",
+        hasLineHeight ? ` data-smart-line-height="${escapeHtml(lineHeight)}"` : "",
         declarations.length ? ` style="${escapeHtml(declarations.join(";"))}"` : "",
     ].join("");
 };
@@ -109,7 +113,7 @@ const serializeBlock = (node, includeIds, listDepth = 0, tableCellA11y) => {
             return raw.html;
     }
     const id = includeIds ? ` data-smart-id="${escapeHtml(node.id)}"` : "";
-    if (["block_image", "block_formula", "video", "audio", "divider"].includes(node.type))
+    if (["block_image", "block_formula", "video", "audio", "divider", "page_break"].includes(node.type))
         return atomToHtml(node, { renderFormulaHtml: renderFormulaHtmlMode });
     if (node.type === "paragraph" || node.type === "heading") {
         const tag = node.type === "heading" ? `h${String(node.attrs?.level || 1)}` : "p";
@@ -385,6 +389,26 @@ const parsedBlockAttrs = (node) => {
         attrs.align = align;
     if (Number.isInteger(indent) && indent > 0)
         attrs.indentLevel = indent;
+    // Deliberately NOT falling back to a bare CSS `line-height` value the way
+    // align/indent fall back to their own CSS equivalents above - confirmed
+    // directly against two real captured clipboard fixtures
+    // (google-docs-clipboard.clipboard.json, native-smart-rte-clipboard.
+    // clipboard.json) that a real-world `line-height` is very often an
+    // AMBIENT/inherited value (a whole document's own default line spacing,
+    // or - for the native fixture - literally this editor's own global
+    // `line-height: 1.6` from theme.ts, baked onto every element by the
+    // browser's clipboard serialization, not a value the user ever
+    // deliberately set on that one paragraph) rather than a genuine
+    // per-paragraph override. `text-align`/`margin-inline-start` do not have
+    // this problem in practice - browsers do not routinely bake an ambient
+    // default onto every paragraph's inline style the way they do for
+    // line-height. Recognizing the bare CSS value would silently attach a
+    // meaningless "explicit" lineHeight to every pasted paragraph. Only this
+    // app's own explicit `data-smart-line-height` marker (written exclusively
+    // when the user deliberately applied it via the toolbar) is trusted.
+    const lineHeight = Number(attr(node, "data-smart-line-height"));
+    if (Number.isFinite(lineHeight) && lineHeight >= 0.1 && lineHeight <= 10)
+        attrs.lineHeight = lineHeight;
     return attrs;
 };
 const rawText = (node) => node.nodeName === "#text" ? node.value || ""
@@ -426,6 +450,12 @@ const parseBlock = (node) => {
         return { type: "block_formula", id: generatedId(node, "formula"), attrs: { source: attr(node, "data-smart-formula") || rawText(node), notation: attr(node, "data-smart-notation") === "mathml" ? "mathml" : "latex" } };
     if (tag === "hr")
         return { type: "divider", id: generatedId(node, "divider") };
+    // No third-party HTML tag means "page break" the way <hr> means
+    // "horizontal rule" - only this app's own round-tripped export (the
+    // data-smart-type marker) is recognized, same as block_image/
+    // block_formula above.
+    if (declaredAtom === "page_break")
+        return { type: "page_break", id: generatedId(node, "pagebreak") };
     // A third-party <img> sitting directly at block level (not wrapped in a
     // <p>) - the ordinary shape for a standalone content photo on most real
     // websites, e.g. a bare <img> between paragraphs or inside a <figure>
@@ -720,7 +750,18 @@ const parseMixedBlockContent = (nodes, blockTags) => {
             inlineRun.push(node);
             return;
         }
-        if (TRANSPARENT_CONTAINER_TAGS.includes(tag)) {
+        // A bare third-party <div> (no data-smart-type) is genuinely
+        // meaningless wrapping and should be unwrapped - but this app's own
+        // round-tripped div-tagged atoms (block_formula, page_break; see
+        // atomToHtml) carry that marker precisely so they're recognized as
+        // opaque nodes, not content to flatten. Without this check, exporting
+        // and reimporting a block_formula (or page_break) silently deleted it
+        // outright: parseBlock never even saw the node, since this recursion
+        // handed off its (empty) childNodes instead - confirmed directly via
+        // `serializeCanonicalListHtml` -> `parseCanonicalListHtml` on a
+        // document containing nothing but a block_formula, which returned zero
+        // children back.
+        if (TRANSPARENT_CONTAINER_TAGS.includes(tag) && !attr(node, "data-smart-type")) {
             flushInlineRun();
             result.push(...parseMixedBlockContent(node.childNodes || [], blockTags));
             return;
@@ -790,7 +831,7 @@ const markdownList = (list, depth) => (list.children || []).flatMap((child, inde
     return [line, ...continuation, ...nested];
 });
 const markdownBlock = (node) => {
-    if (["block_image", "block_formula", "video", "audio", "divider"].includes(node.type))
+    if (["block_image", "block_formula", "video", "audio", "divider", "page_break"].includes(node.type))
         return [atomToMarkdown(node)];
     if (node.type === "list")
         return markdownList(node, 0);

package/dist/foundation/surface/renderer.js

@@ -27,7 +27,7 @@ const renderFormulaInto = (element, source) => {
         element.textContent = source;
     }
 };
-const atomTypes = new Set(["image", "block_image", "formula", "block_formula", "video", "audio", "divider"]);
+const atomTypes = new Set(["image", "block_image", "formula", "block_formula", "video", "audio", "divider", "page_break"]);
 /**
  * atom/lifecycle.ts writes a specific upload-failure reason to
  * attrs.error (the host MediaProvider's own message, or a generic
@@ -117,6 +117,13 @@ export class FoundationSubtreeRenderer {
             element.style.marginInlineStart = `${Number(node.attrs.indentLevel) * 2}em`;
         else if (element.style.marginInlineStart)
             element.style.removeProperty("margin-inline-start");
+        // Unitless, matching how the value is stored and validated (schema.ts's
+        // lineHeightAttr) - absence means "no override", the browser/font's own
+        // natural line-height, not a forced "1".
+        if (node.attrs?.lineHeight)
+            element.style.lineHeight = String(node.attrs.lineHeight);
+        else if (element.style.lineHeight)
+            element.style.removeProperty("line-height");
         if (node.type === "code_block") {
             const language = typeof node.attrs?.language === "string" && node.attrs.language.trim()
                 ? node.attrs.language.trim()
@@ -527,7 +534,7 @@ export class FoundationSubtreeRenderer {
      * the state through the normal diff path.
      */
     installMediaDiagnostics(element, node) {
-        if (!atomTypes.has(node.type) || node.type === "formula" || node.type === "block_formula" || node.type === "divider")
+        if (!atomTypes.has(node.type) || node.type === "formula" || node.type === "block_formula" || node.type === "divider" || node.type === "page_break")
             return;
         if (element.hasAttribute("data-smart-media-events"))
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smartrte-core",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.6",
   "description": "Framework-agnostic document model and editing primitives for Smart RTE",
   "repository": {
     "type": "git",