smartrte-core 1.0.0-beta.3 → 1.0.0-beta.5

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 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).
+
 ## 1.0.0-beta.3
 
 - Add `href`/`target` (a clickable link), `borderRadius` (corner rounding), and license metadata fields (`licenseDescription`, `licenseSourceUrl`, `licenseType`, `licenseVersion`, `licenseAttribution`) to the image atom schema. `href` is validated the same way as the existing `link` mark; exported HTML wraps a linked image in a real `<a>` for portability outside the editor. Fix a pre-existing renderer gap where clearing an image's `align` back to unset never removed the CSS float/display/margin it had previously applied.

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/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

@@ -17,7 +17,7 @@ const isEditorUiNode = (node) => attr(node, "data-smart-ui") !== undefined || at
  * meaningful block content - most often a <table> - in one or more <div>s
  * (table-wrapper divs, layout divs) that carry no semantic meaning of
  * their own. parseBlock has no case for any of these tags; see
- * parseBlockList below for how they're unwrapped instead of swallowed.
+ * parseMixedBlockContent below for how they're unwrapped instead of swallowed.
  */
 const TRANSPARENT_CONTAINER_TAGS = ["div", "section", "article", "figure"];
 /** Shared by both the inline `image` and block `block_image` parsing branches below - radius/license round-trip identically for both, only href/target's link-mark-fallback behavior deliberately differs between them (see each call site's own comment). */
@@ -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>
@@ -485,17 +515,10 @@ const parseBlock = (node) => {
     if (tag === "blockquote") {
         // Real-world exports (Sootr among them) put inline content - <span>
         // wrapper runs, bare text, <br> - directly inside <blockquote> with no
-        // wrapping <p>. Without this split, elementChildren+parseBlock alone
-        // sent every such child through the generic "unrecognized tag" fallback
-        // at the bottom of this function, producing an unknown block node per
-        // span (rendered as "[Unsupported: span]") instead of parsed text/marks
-        // - the same directInline pattern td/li already use below.
+        // wrapping <p>. See parseMixedBlockContent's own comment for why this
+        // must be grouped run-by-run rather than collected into one paragraph.
         const blockTags = ["p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "blockquote", "pre", "table"];
-        const isBlockLike = (child) => blockTags.includes(child.tagName || "") || TRANSPARENT_CONTAINER_TAGS.includes(child.tagName || "");
-        const children = parseBlockList(elementChildren(node).filter(isBlockLike));
-        const directInline = (node.childNodes || []).filter((child) => !child.tagName || !isBlockLike(child)).flatMap((child) => textWithMarks(child));
-        if (directInline.length)
-            children.unshift({ type: "paragraph", id: createNodeId(), children: directInline });
+        const children = parseMixedBlockContent(node.childNodes || [], blockTags);
         return {
             type: "blockquote", id: generatedId(node, "quote"),
             ...(Object.keys(parsedBlockAttrs(node)).length ? { attrs: parsedBlockAttrs(node) } : {}),
@@ -584,11 +607,7 @@ const parseBlock = (node) => {
         if (verticalAlign)
             cellAttrs.verticalAlign = verticalAlign;
         const blockTags = ["p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "blockquote", "pre", "table"];
-        const isBlockLike = (child) => blockTags.includes(child.tagName || "") || TRANSPARENT_CONTAINER_TAGS.includes(child.tagName || "");
-        const children = parseBlockList(elementChildren(node).filter(isBlockLike));
-        const directInline = (node.childNodes || []).filter((child) => !child.tagName || !isBlockLike(child)).flatMap((child) => textWithMarks(child));
-        if (directInline.length)
-            children.unshift({ type: "paragraph", id: createNodeId(), children: directInline });
+        const children = parseMixedBlockContent(node.childNodes || [], blockTags);
         if (!children.length)
             children.push({ type: "paragraph", id: createNodeId(), children: [] });
         return { type: "table_cell", id: generatedId(node, "cell"), attrs: cellAttrs, children };
@@ -636,17 +655,8 @@ const parseBlock = (node) => {
             attrs.htmlStyle = htmlStyle;
         if (Number.isInteger(value) && value >= 1)
             attrs.numberOverride = value;
-        const children = [];
-        const blockTags = ["p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "blockquote", "pre", "div", "table", "figure"];
-        const inlineNodes = (node.childNodes || []).filter((child) => !child.tagName || !blockTags.includes(child.tagName));
-        const directText = inlineNodes.flatMap((child) => textWithMarks(child));
-        if (directText.length)
-            children.push({ type: "paragraph", id: createNodeId(), children: directText });
-        // blockTags already lists "div"/"figure" as block-worthy, but parseBlock
-        // itself has no case for either - parseBlockList is what actually
-        // unwraps them (rather than swallowing their content into one opaque
-        // `unknown` node) instead of parsing them directly.
-        children.push(...parseBlockList(elementChildren(node).filter((child) => blockTags.includes(child.tagName || ""))));
+        const blockTags = ["p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "blockquote", "pre", "table"];
+        const children = parseMixedBlockContent(node.childNodes || [], blockTags);
         if (!children.length)
             children.push({ type: "paragraph", id: createNodeId(), children: [] });
         return { type: "list_item", id: generatedId(node, "item"), ...(Object.keys(attrs).length ? { attrs } : {}), children };
@@ -659,24 +669,128 @@ const parseBlock = (node) => {
     return null;
 };
 /**
- * A thin wrapper around parseBlock for "list of block-level children"
- * call sites: a transparent container (TRANSPARENT_CONTAINER_TAGS) is
- * recursed into and its own children spliced in flat, rather than parsed
- * as one opaque node - a div wrapping N real blocks (a table, N
- * paragraphs, or nothing at all) produces exactly those N blocks instead
- * of a single `unknown` placeholder that hides all of them.
+ * Generic inline-formatting tags recognized by textWithMarks. Used by
+ * parseMixedBlockContent to decide when a bare (non-<p>-wrapped) element
+ * sitting at block level should be reinterpreted as inline text instead of
+ * left as parseBlock's own "unknown" round-trip-preserving placeholder.
+ * Deliberately narrow: an arbitrary/custom element (e.g. a host's own safe
+ * custom widget surviving the clipboard security boundary, see
+ * clipboard/pipeline.test.ts's "preserves a sanitized safe custom element
+ * as an unknown node") is NOT in this list, so it keeps going through the
+ * exact same "unknown" fallback as before - only tags that are
+ * unambiguously plain inline formatting ever get reinterpreted as text.
  */
-const parseBlockList = (nodes) => nodes.flatMap((node) => {
-    if (TRANSPARENT_CONTAINER_TAGS.includes(node.tagName || ""))
-        return parseBlockList(elementChildren(node));
-    const parsed = parseBlock(node);
-    return parsed ? [parsed] : [];
-});
+const GENERIC_INLINE_TAGS = ["span", "strong", "b", "em", "i", "u", "s", "strike", "del", "code", "sup", "sub", "a", "br"];
+/**
+ * Parses a mixed sequence of block and inline DOM children in place. A
+ * transparent container (TRANSPARENT_CONTAINER_TAGS) is recursed into and
+ * its own children spliced in flat, rather than parsed as one opaque node -
+ * a div wrapping N real blocks (a table, N paragraphs, or nothing at all)
+ * produces exactly those N blocks instead of a single `unknown` placeholder
+ * that hides all of them.
+ *
+ * Real-world exports (Sootr among them - both the document root and inside
+ * a <blockquote>/<td>/<li>) routinely put inline content - bare <span>
+ * wrapper runs, plain text, stray <br> - directly alongside real block
+ * children, with no wrapping <p>. Each *run* of consecutive non-block-like
+ * children is grouped into its own synthetic paragraph in place, preserving
+ * both the order of the surrounding real blocks and which inline runs were
+ * actually adjacent in the source. An earlier version of this function
+ * collected every inline child across the whole container into ONE
+ * paragraph and prepended it - correct only when inline content never
+ * appears between two blocks. Real legacy content interleaves several bare
+ * <span> lines between a <blockquote>, images, and paragraphs; merging them
+ * all into one paragraph at the front silently reordered content and
+ * mashed together lines that were never adjacent, and any other stray
+ * generic inline tag (e.g. a lone <b>) still fell through to the generic
+ * unrecognized-tag fallback and rendered as "[Unsupported: b]" wherever no
+ * caller-specific inline handling existed for it (previously: the document
+ * root, which had none at all).
+ *
+ * "a" is the one GENERIC_INLINE_TAGS entry with a real block-level meaning
+ * too - parseBlock's own "<a> wrapping only an <img>" case unwraps to a
+ * block image - so it's tried as a block first and only folded into the
+ * inline run if that doesn't apply.
+ */
+const parseMixedBlockContent = (nodes, blockTags) => {
+    const result = [];
+    let inlineRun = [];
+    const flushInlineRun = () => {
+        if (!inlineRun.length)
+            return;
+        const children = inlineRun.flatMap((node) => textWithMarks(node));
+        inlineRun = [];
+        // A whitespace-only text node (a newline/indentation between block-level
+        // tags in pretty-printed source HTML - e.g. Word/Excel's real clipboard
+        // HTML) is insignificant, exactly like a browser's own whitespace
+        // collapsing between block elements - it must not produce its own
+        // spurious empty-looking paragraph. A run with any real text or any
+        // non-text child (an atom, a <br>) is kept in full, including any
+        // whitespace mixed into it (e.g. a genuine word-separating space).
+        const hasContent = children.some((child) => !isTextNode(child) || child.text.trim() !== "");
+        if (hasContent)
+            result.push({ type: "paragraph", id: createNodeId(), children });
+    };
+    const pushBlock = (node) => {
+        flushInlineRun();
+        const parsed = parseBlock(node);
+        if (parsed)
+            result.push(parsed);
+    };
+    nodes.forEach((node) => {
+        // Matches textWithMarks's own first check - a UI-only element (e.g. a
+        // checklist item's check-control <button>) has no tag this function
+        // would otherwise recognize as block-like, and previously reached
+        // parseBlock's generic "unknown" fallback instead of being silently
+        // dropped like every other reparse path already does for these.
+        if (isEditorUiNode(node))
+            return;
+        const tag = node.tagName;
+        if (!tag) {
+            inlineRun.push(node);
+            return;
+        }
+        // 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;
+        }
+        if (blockTags.includes(tag))
+            return pushBlock(node);
+        if (GENERIC_INLINE_TAGS.includes(tag)) {
+            if (tag === "a") {
+                const parsed = parseBlock(node);
+                if (parsed && parsed.type !== "unknown") {
+                    flushInlineRun();
+                    result.push(parsed);
+                    return;
+                }
+            }
+            inlineRun.push(node);
+            return;
+        }
+        pushBlock(node);
+    });
+    flushInlineRun();
+    return result;
+};
 export const parseCanonicalListHtml = (html) => {
     const fragment = parseFragment(html);
     const wrapper = elementChildren(fragment).find((node) => attr(node, "data-smart-document") === "true");
     const source = wrapper || fragment;
-    const children = parseBlockList(elementChildren(source));
+    const rootBlockTags = ["p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "blockquote", "pre", "table", "hr", "img", "video", "audio"];
+    const children = parseMixedBlockContent(source.childNodes || [], rootBlockTags);
     return { type: "doc", id: attr(source, "data-smart-id") || createNodeId(), children: children.length ? children : [{ type: "paragraph", id: createNodeId(), children: [] }] };
 };
 const plainText = (node) => (node.children || []).map((child) => isTextNode(child) ? child.text : child.type === "hard_break" ? "\n" : "").join("");
@@ -717,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.3",
+  "version": "1.0.0-beta.5",
   "description": "Framework-agnostic document model and editing primitives for Smart RTE",
   "repository": {
     "type": "git",