import { tiptapToOdt, type TiptapNode, type TiptapMark, type TextFormatting, type OdtDocument, type ParagraphBuilder, type TableBuilder, type RowBuilder, type CellBuilder, type CellOptions, type HeaderFooterBuilder } from 'odf-kit';
import { unzipSync, zipSync, strFromU8, strToU8 } from 'fflate';
import { DEFAULT_MARGINS, type PageMargins } from '../storage/pageMargins';
import type { Orientation } from '../storage/pageOrientation';
import type { SpacingModel } from '../storage/spacingModel';
import { pageDimsCm, type PageFormat } from '../storage/pageFormat';
import { DEFAULT_TAB_INTERVAL_CM } from '../storage/tabInterval';
import { HF_DISTANCE_CM, hfIsEmpty, type HfDoc, type HfSet } from '../storage/headerFooter';
import { DEFAULT_NOTE_SETTINGS, NOTE_FONT_SIZE_PT, NOTE_INDENT_CM, type NoteKind, type NoteNumFormat, type NoteSettings } from '../storage/noteSettings';
import { EMPTY_DOC_PROPERTIES, keywordList, type DocProperties } from '../storage/docProperties';
import { DEFAULT_PAGE_NUMBERING, type PageNumbering } from '../storage/pageNumbering';
import { EMPTY_PAGE_DECOR, type PageDecor, type Watermark } from '../storage/pageDecor';
import { DEFAULT_LINE_NUMBERING, type LineNumbering } from '../storage/lineNumbering';
import { builtinStyleSheet, DEFAULT_STYLE, resolveStyle, type StyleSheet, type TextProps } from '../styles/styleSheet';
import {
  TABLE_REGIONS, parseTableLook, regionText, type TableLook, type TableRegion,
} from '../styles/tableStyles';

// A table's named style plus the conditional areas it opts into (Word's Table Style
// Options), collected by exportTable in document order.
type TableStyleRef = { name: string; look: TableLook };
import { HEADER_SHADE } from '../editor/extensions/tableHeaderRow';
import { BORDER_SIDES, parseBorderAttr } from '../editor/extensions/tableCellBorders';
import { parseCellPadding, DEFAULT_CELL_PADDING, type CellPadding } from '../editor/extensions/tableCellPadding';
import { TEXTBOX_PADDING_CM } from '../editor/extensions/textBox';
import { numberLocale, parseCellNumber, toWriterFormula, type CellRef, type NumberLocale } from '../utils/tableFormula';
import { SHAPES, arrowHeadCm, isShapeKind, isLineKind, odfEnhancedGeometry, odfEnhancedPath, type ShapeKind } from '../utils/shapes';
import { normalizeLeader, parseTabStops } from '../editor/extensions/tabStops';
import { charStyleProps, listMarkerFormat, type MarkerFormat } from '../editor/extensions/listMarker';
import { orderedTypeDef, effectiveOrderedDef, effectiveOrderedDefAt, childCycle, formatOrdinal, ROOT_ORDERED_CYCLE, type OrderedCycle } from '../utils/orderedListTypes';
import { ODF_SEQ_NAME, seqCategoryOf, type SeqCategory } from '../editor/extensions/caption';
import { indexKindOf, INDEX_TITLES, type IndexKind } from '../editor/extensions/tableOfContents';
import { citationText, isBibType } from '../editor/extensions/bibliographyEntry';
import { isCitationStyle, rowTemplate, type CitationStyle } from '../utils/citationStyle';
import { DEFAULT_BULLET_CYCLE, defaultBulletChar } from '../utils/bulletListTypes';
import { CELL_FORMAT_SPECS, currencyParts, datePattern, isCellFormat, type CellFormat } from '../utils/cellFormat';
import { findFormat, renderFormat, odfNumberStyle, toDateValue, toTimeValue, localeTag, DEFAULT_DATE_FORMAT, DEFAULT_TIME_FORMAT, type DtFormat } from '../utils/dateTime';
import { parseLatex } from '../math/latex';
import { mathmlDocument } from '../math/mathml';

type AlignValue = 'left' | 'center' | 'right' | 'justify';

// tiptapToOdt ignores paragraph/heading node attrs (including lineHeight and
// textAlign). We rename nodes that carry either attr to custom types and
// handle them via unknownNodeHandler, which has access to the full OdtDocument API.

const CUST_P = '__cust_p__';
const CUST_H = '__cust_h__';
// Tables are renamed to this so odf-kit routes them to unknownNodeHandler. Its
// native path emits cells with no border (invisible in LibreOffice/Word), so we
// build the table ourselves with an explicit border.
const CUST_TABLE = '__cust_table__';
// Synthetic first node: routes header/footer emission through unknownNodeHandler,
// which is the only hook with access to the OdtDocument (setHeader/setFooter).
const CUST_HF = '__cust_hf__';

// Table export styling. Values mirror the editor's table CSS (src/styles/editor.css)
// so the .odt matches the on-screen preview.
const TABLE_BORDER = '0.5pt solid #000000';

// odf-kit emits this as the document's default font (Standard style). The editor
// renders the bundled, metric-identical Liberation Serif on screen.
const ODFKIT_DEFAULT_FONT = 'Liberation Serif';
// …but we declare Times New Roman in the .odt: it is metric-identical to
// Liberation Serif, so LibreOffice (substitutes TNR→Liberation Serif) and Word
// (has the real TNR) both render with the same metrics as the editor.
const EXPORT_FONT = 'Times New Roman';
// The body size a run without one of its own renders at (LibreOffice's default).
const DEFAULT_FONT_SIZE_PT = 12;
const DEFAULT_LINE_HEIGHT = 1;  // must match line-height multiplier default in ToolbarExpanded.svelte

// Sentinel between a cell's blocks (and list items) so the single <text:p> odf-kit
// emits per cell can be split back into real blocks in applyCellBlocks. A private-use
// char: never in user text, and passes odf-kit's XML escaper (only & < >) untouched.
const SEG = '';

// Sentinel for hardBreak nodes: replaceHardBreaks turns them into text so every
// odf-kit path (plain paragraphs, list items, cells) carries them; applyInlineSentinels
// swaps the char for <text:line-break/> in content.xml. U+E001 (SEG is U+E000).
const LBR = '';

// Sentinel wrapping page-count digits in header/footer runs; applyHfPostProcess
// rewrites it to <text:page-count> in styles.xml. U+E002 (SEG/LBR are E000/E001).
const PGC = '';

// Sentinel for tab chars: \t collapses to a space in ODF, so replaceTabs swaps
// each tab for this before odf-kit serializes; applyInlineSentinels → <text:tab/>. U+E003.
const TAB = '';

// Sentinel wrapping an image's index (IMG{i}IMG) emitted as plain run text by
// replaceImages, so it rides every odf-kit path (body paragraphs and table cells);
// applyImages rewrites it to a <draw:frame> in content.xml. U+E004.
const IMG = '';

// Sentinel prepended to a top-level paragraph/heading carrying a manual page break
// (breakBefore: 'page'); applyPageBreaks finds the marked block in content.xml, mints a
// fo:break-before="page" paragraph style for it, and strips the sentinel. U+E005.
const PGB = '';

// Sentinel wrapping an empty line's font size (FSZ<size>FSZ), the sole text of a
// top-level empty CUST_P/CUST_H; applyEmptyLineFontSizes turns it into a paragraph
// style fo:font-size (odf-kit has no paragraph font-size option). U+E007.
const FSZ = '\uE007';

// Sentinel wrapping a top-level paragraph's box spec (PBX<bg|bt|br|bb|bl>PBX), emitted
// as the paragraph's first run; applyParagraphBoxes mints a paragraph style with
// fo:background-color/fo:border-* (odf-kit has no such options). U+E00C.
const PBX = '\uE00C';

// Sentinel wrapping a table-of-contents index (TOC{i}TOC), emitted as a marker
// paragraph's run text by replaceTableOfContents so it rides odf-kit's paragraph path;
// applyToc rewrites the whole marker <text:p> to a <text:table-of-content>. U+E006.
const TOC_SENT = '';

// Sentinel bracketing a hoisted text box's blocks (marker paragraphs TBX S{i} TBX …
// TBX E{i} TBX): hoisted to top level, they ride every existing pass; applyTextBoxes
// wraps the region back into a <draw:frame>/<draw:text-box> or custom shape. U+E008.
const TBX = '';

// Sentinel bracketing a hoisted multi-column section's blocks, same mechanism as
// TBX above; applyColumns wraps the region into a <text:section> with a minted
// section style carrying <style:columns>. U+E009.
const COL = '';

// Sentinel wrapping a date/time field's index (DTF{i}DTF), emitted as plain run text
// by replaceDateTimeFields so it rides every odf-kit path; applyDateTimeFields
// rewrites it to <text:date>/<text:time> + a minted number style. U+E00A.
const DTF = '';

// Sentinel wrapping a header/footer image's index (HFIMG{i}HFIMG), emitted as plain
// run text by replaceHfImages so it rides odf-kit's header/footer path (styles.xml);
// applyHfPostProcess rewrites it to an as-char <draw:frame>. U+E00B.
const HFIMG = '';

// Sentinel wrapping the named paragraph style of a block whose style isn't the ODF
// default for its node type (STY<name>STY), emitted as plain run text so it rides the
// odf-kit path; applyParagraphStyles points the block at that style. U+E00D.
const STY = '';

// Sentinel prefixed to a run that carries a named character style (CST<name>CST);
// applyCharacterStyles points the run's span at that style. U+E00E.
const CST = '\uE00E';

// Sentinel prefixed to a run carrying character effects odf-kit's run formatting has no
// field for (TEF<odf attrs>TEF); applyTextEffects folds them into the run's own
// automatic text style. U+E00F.
const TEF = '\uE00F';

// Sentinel wrapping the index of the section a block opens (SEC{i}SEC), emitted as the
// block's first run; applySectionMasterPages points it at that section's master page,
// which is what carries the section's own header/footer. U+E010.
const SEC = '\uE010';

// Separates a tab stop's alignment from its leader character inside style:type,
// which odf-kit writes verbatim. U+E011.
const LEAD = '\uE011';

// Sentinel wrapping a formula's index (MTH{i}MTH), emitted as plain run text by
// replaceFormulas so it rides every odf-kit path; applyFormulas rewrites it to a
// <draw:frame>/<draw:object> and writes the embedded formula object. U+E012.
const MTH = '\uE012';

// Sentinels bracketing a bookmark's text (BMS<name>BMS \u2026 BME<name>BME), spliced into
// the run text by replaceBookmarks so they ride every odf-kit path; applyBookmarks
// rewrites them to <text:bookmark-start/>/<text:bookmark-end/>. U+E013/U+E014.
const BMS = '\uE013';
const BME = '\uE014';

// Sentinel wrapping a cross-reference's index and its display text
// (XRF{i}XRF<text>XRF); applyBookmarks rewrites it to <text:bookmark-ref>. U+E015.
const XRF = '\uE015';

// Sentinel wrapping a header/footer chapter field (CHP<level>CHP<name>CHP);
// applyHfPostProcess rewrites it to <text:chapter> in styles.xml. U+E016.
const CHP = '\uE016';

// Sentinels bracketing a comment's text (CMS{i}CMS \u2026 CME{i}CME), spliced into the run
// text like the bookmark pair; applyComments rewrites them to <office:annotation> and
// <office:annotation-end/>. U+E018/U+E019.
const CMS = '\uE018';
const CME = '\uE019';

// Sentinels for footnotes/endnotes (notes.ts): FNT A{i} FNT marks the anchor in the
// running text, FNT B{i} FNT opens the note's own hoisted paragraph. applyNotes cuts
// the body out and splices it into a <text:note> at the anchor. U+E017.
const FNT = '\uE017';

// Sentinel wrapping a caption's sequence-field index (SEQ{i}SEQ); applySequenceFields
// rewrites it to <text:sequence>. U+E01A.
const SEQ = '\uE01A';
// Sentinel wrapping an index entry's index (IXE{i}IXE); applyIndexEntries resolves it.
const IXE = '\uE01E';
// Sentinel wrapping a citation's index (BIB{i}BIB); applyBibEntries resolves it.
const BIB = '\uE01F';
// Sentinel wrapping a ruby annotation's index (RBY{i}RBY); applyRuby rewrites it to
// <text:ruby>. U+E021.
const RBY = '\uE021';

// Sentinels for recorded revisions (trackChanges.ts): TCI{i}TCI brackets an insertion's
// runs, TCD{i}TCD stands where a deletion's text was cut out. applyRevisions rewrites
// both and builds the <text:tracked-changes> registry. U+E01B/U+E01C.
const TCI = '\uE01B';
const TCD = '\uE01C';

const EXT_BY_MIME: Record<string, string> = {
  'image/png': 'png',
  'image/jpeg': 'jpg',
  'image/jpg': 'jpg',
  'image/gif': 'gif',
  'image/svg+xml': 'svg',
  'image/webp': 'webp',
  'image/bmp': 'bmp',
};

// Automatic list styles minted for in-cell lists (see applyCellBlocks). odf-kit's
// CellBuilder is run-based, so a list inside a cell can't reference a list style it
// generates for top-level lists — we inject our own, mirroring its buildListStyle.
const CELL_LIST_BULLET_STYLE = 'TblListBullet';
const CELL_LIST_NUMBER_STYLE = 'TblListNumber';

// LibreOffice's heading defaults, shown in the editor (editor.css) and written over
// odf-kit's Heading_20_N styles on export: its sizes plus the Heading style's margins.
// The importers use them as the fallback yardstick when a file declares no style.
// Levels 4 and 6 are italic, as they are in LibreOffice (probed against its style pool).
export const HEADING_STYLE_OVERRIDES: { name: string; fontSize: string; marginTop: string; marginBottom: string; italic?: true }[] = [
  { name: 'Heading_20_1', fontSize: '18pt', marginTop: '0.423cm', marginBottom: '0.212cm' },
  { name: 'Heading_20_2', fontSize: '16pt', marginTop: '0.423cm', marginBottom: '0.212cm' },
  { name: 'Heading_20_3', fontSize: '14pt', marginTop: '0.423cm', marginBottom: '0.212cm' },
  { name: 'Heading_20_4', fontSize: '13pt', marginTop: '0.423cm', marginBottom: '0.212cm', italic: true },
  { name: 'Heading_20_5', fontSize: '12pt', marginTop: '0.423cm', marginBottom: '0.212cm' },
  { name: 'Heading_20_6', fontSize: '12pt', marginTop: '0.423cm', marginBottom: '0.212cm', italic: true },
  // 7–10 continue level 6 rather than adding a step of our own: probed, LibreOffice
  // writes these styles with no properties at all and resolves them from its own pool.
  { name: 'Heading_20_7', fontSize: '12pt', marginTop: '0.423cm', marginBottom: '0.212cm' },
  { name: 'Heading_20_8', fontSize: '12pt', marginTop: '0.423cm', marginBottom: '0.212cm', italic: true },
  { name: 'Heading_20_9', fontSize: '12pt', marginTop: '0.423cm', marginBottom: '0.212cm' },
  { name: 'Heading_20_10', fontSize: '12pt', marginTop: '0.423cm', marginBottom: '0.212cm', italic: true },
];

// Headings are sans (LibreOffice's Heading style). On screen the bundled 'Arial'
// @font-face maps to Liberation Sans, so the declared name is metric-identical —
// the same trick as EXPORT_FONT for the serif body font.
export const HEADING_FONT = 'Arial';

// What both formats name as the producing application (ODF meta:generator).
export const GENERATOR = 'EdenText';

// Highest heading level the editor offers (extensions.ts, both importers, TOC).
export const MAX_HEADING_LEVEL = HEADING_STYLE_OVERRIDES.length;
export const HEADING_LEVELS = HEADING_STYLE_OVERRIDES.map((_, i) => i + 1);

// The bundled screen font → the metric-identical name declared in files, so
// LibreOffice and Word render with the editor's metrics.
export function twinFontName(family: string): string {
  if (family === ODFKIT_DEFAULT_FONT) return EXPORT_FONT;
  if (family === 'Liberation Sans') return HEADING_FONT;
  return family;
}

// ODF encodes spaces in style names as _20_ ("Heading 1" → "Heading_20_1").
export function odfStyleName(name: string): string {
  return name.replace(/ /g, '_20_');
}

// The style name a block carries: its own, else the node type's default. Mirrors
// blockStyleName in editor/extensions/paragraphStyle.ts (kept local: this module is
// framework-free).
function styleOf(node: TiptapNode): string {
  const own = node.attrs?.styleName;
  if (typeof own === 'string' && own) return own;
  return isHeadingNode(node) ? `Heading ${(node.attrs?.level as number) ?? 1}` : DEFAULT_STYLE;
}

// Headings reach the handler renamed to CUST_H (injectCustomTypes).
function isHeadingNode(node: TiptapNode): boolean {
  return node.type === 'heading' || node.type === CUST_H;
}

// Styles to define in the file: every built-in (Word/LibreOffice always define their
// standard styles) plus the user styles the document actually references, with their
// parent chains.
function usedStyleNames(doc: TiptapNode, sheet: StyleSheet): Set<string> {
  const used = new Set<string>();
  const addChain = (name: string) => {
    let cur: string | null | undefined = name;
    while (cur && sheet.paragraph[cur] && !used.has(cur)) {
      used.add(cur);
      cur = sheet.paragraph[cur].parent;
    }
  };
  for (const style of Object.values(sheet.paragraph)) if (style.builtin) addChain(style.name);
  const walk = (node: TiptapNode) => {
    if (node.type === 'paragraph' || node.type === 'heading') addChain(styleOf(node));
    node.content?.forEach(walk);
  };
  walk(doc);
  return used;
}

// What odf-kit itself puts on the block, so only a differing style needs a sentinel.
function odfDefaultStyleOf(node: TiptapNode): string {
  return isHeadingNode(node) ? `Heading ${(node.attrs?.level as number) ?? 1}` : DEFAULT_STYLE;
}

function hasCustomAttrs(attrs: TiptapNode['attrs']): boolean {
  if (!attrs) return false;
  // A named style is emitted via the STY sentinel, which needs the applyRuns path.
  if (typeof attrs.styleName === 'string' && attrs.styleName) return true;
  if (attrs.lineHeight) return true;
  if (attrs.spaceBefore != null) return true;
  if (attrs.spaceAfter != null) return true;
  if (typeof attrs.fontSize === 'string' && attrs.fontSize) return true;
  if (typeof attrs.fontFamily === 'string' && attrs.fontFamily) return true;
  if (typeof attrs.indent === 'number' && attrs.indent > 0) return true;
  if (typeof attrs.indentFirst === 'number' && attrs.indentFirst !== 0) return true;
  if (typeof attrs.indentRight === 'number' && attrs.indentRight > 0) return true;
  if (typeof attrs.tabStops === 'string' && attrs.tabStops) return true;
  if (typeof attrs.backgroundColor === 'string' && attrs.backgroundColor) return true;
  if (attrs.widowControl === false) return true;
  if (attrs.keepNext === true) return true;
  if (attrs.keepLines === true) return true;
  if (attrs.noHyphenation === true) return true;
  if (attrs.dir === 'rtl' || attrs.dir === 'ltr') return true;
  for (const s of ['borderTop', 'borderRight', 'borderBottom', 'borderLeft'])
    if (typeof attrs[s] === 'string' && attrs[s] && attrs[s] !== 'none') return true;
  const ta = attrs.textAlign;
  return ta === 'left' || ta === 'center' || ta === 'right' || ta === 'justify';
}

// odf-kit's native run handling ignores the fontWeight textStyle attr (used to
// un-bold heading text), so such blocks must go through applyRuns via CUST_P/_H.
function hasFontWeightRun(content: TiptapNode['content']): boolean {
  return !!content?.some(c =>
    c.type === 'text' && c.marks?.some(m => m.type === 'textStyle' && m.attrs?.fontWeight),
  );
}

// Same for a named character style: only applyRuns emits its CST sentinel.
function hasCharStyleRun(content: TiptapNode['content']): boolean {
  return !!content?.some(c => c.type === 'text' && !!charStyleOf(c.marks));
}

function injectCustomTypes(node: TiptapNode, inContainer = false): TiptapNode {
  // Rename tables so odf-kit routes them to our unknownNodeHandler (see
  // CUST_TABLE). Recurse with inContainer=true so the cell paragraphs are NOT
  // renamed — our table handler walks them by type === "paragraph".
  if (node.type === 'table') {
    return {
      ...node,
      type: CUST_TABLE,
      content: node.content?.map(c => injectCustomTypes(c, true)),
    };
  }
  // Don't rename paragraphs inside list items or table cells — tiptapToOdt's list
  // builder (and our table handler) walk them by type === "paragraph"; renaming
  // breaks that.
  if (!inContainer && (hasCustomAttrs(node.attrs) || hasFontWeightRun(node.content) || hasCharStyleRun(node.content))) {
    if (node.type === 'paragraph') return { ...node, type: CUST_P };
    if (node.type === 'heading')   return { ...node, type: CUST_H };
  }
  if (node.content?.length) {
    const childInContainer = inContainer
      || node.type === 'bulletList'
      || node.type === 'orderedList'
      || node.type === 'listItem';
    return { ...node, content: node.content.map(c => injectCustomTypes(c, childInContainer)) };
  }
  return node;
}

// Turn hardBreak nodes into LBR-sentinel text nodes so they ride through every
// odf-kit serialization path as plain run text; applyInlineSentinels rewrites the char
// to <text:line-break/> in content.xml afterwards.
function replaceHardBreaks(node: TiptapNode): TiptapNode {
  if (!node.content?.length) return node;
  return {
    ...node,
    content: node.content.map(c =>
      c.type === 'hardBreak'
        ? { type: 'text', text: LBR, ...(c.marks ? { marks: c.marks } : {}) }
        : replaceHardBreaks(c),
    ),
  };
}

// Swap each tab character in run text for the TAB sentinel so it survives odf-kit
// serialization (a literal \t would collapse to a space); applyInlineSentinels
// rewrites it to <text:tab/> in content.xml afterwards.
function replaceTabs(node: TiptapNode): TiptapNode {
  if (node.type === 'text' && node.text?.includes('\t')) {
    return { ...node, text: node.text.split('\t').join(TAB) };
  }
  if (!node.content?.length) return node;
  return { ...node, content: node.content.map(replaceTabs) };
}

// Prepend a PGB sentinel run to each top-level paragraph/heading with breakBefore so it
// rides every odf-kit path; applyPageBreaks resolves it. Top-level only: a sentinel in a
// cell/list paragraph would corrupt the SEG-based cell/list rebuild (applyCellBlocks).
function replacePageBreaks(doc: TiptapNode): TiptapNode {
  if (!doc.content?.length) return doc;
  return {
    ...doc,
    content: doc.content.map(child => {
      if ((child.type === 'paragraph' || child.type === 'heading') && child.attrs?.breakBefore === 'page') {
        return { ...child, content: [{ type: 'text', text: PGB }, ...(child.content ?? [])] };
      }
      return child;
    }),
  };
}

// Mark the first block of each section after the first, so applySectionMasterPages can
// point it at that section's master page. Runs after the column hoist, so a section
// starting inside one is top-level by now; the PGB marker keeps its place at the front.
function replaceSectionBreaks(doc: TiptapNode): TiptapNode {
  if (!doc.content?.length) return doc;
  let index = 0;
  return {
    ...doc,
    content: doc.content.map(child => {
      if (!(child.type === 'paragraph' || child.type === 'heading') || child.attrs?.sectionBreak !== true) return child;
      const inner = child.content ?? [];
      const at = inner[0]?.type === 'text' && inner[0].text === PGB ? 1 : 0;
      const mark: TiptapNode = { type: 'text', text: `${SEC}${++index}${SEC}` };
      return { ...child, content: [...inner.slice(0, at), mark, ...inner.slice(at)] };
    }),
  };
}

// One embedded picture, collected by replaceImages and emitted by applyImages.
// bytes is ArrayBuffer-backed to match fflate's zip entry map. rotationDeg is CW;
// wrap floats the frame at its anchor paragraph (left/right/top-bottom).
type WrapMode = 'inline' | 'left' | 'right' | 'topBottom';
type ImageExport = { path: string; bytes: Uint8Array<ArrayBuffer>; mimeType: string; widthCm: number; heightCm: number; alt: string; rotationDeg: number; wrap: WrapMode; wrapOffsetCm: number | null; wrapOffsetYCm: number | null; wrapDistCm: number | null; wrapAlign: string | null; anchorPage: number | null; vAlign: string | null; inFront: boolean };

function base64ToBytes(b64: string): Uint8Array<ArrayBuffer> {
  const bin = atob(b64);
  const bytes = new Uint8Array(bin.length);
  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
  return bytes;
}

// Decode an `image` node's data-URI src into bytes + geometry. width/height are
// px @96dpi → cm via round3 (sub-pixel, matches table column widths), so an
// integer-px image round-trips exactly. Returns null for a non-data/empty src.
function imageDescriptor(node: TiptapNode, index: number, namePrefix = 'image'): ImageExport | null {
  const src = node.attrs?.src;
  if (typeof src !== 'string' || !src.startsWith('data:')) return null;
  const m = /^data:([^;,]+)(;[^,]*)?,([\s\S]*)$/.exec(src);
  if (!m) return null;
  const mimeType = m[1] || 'image/png';
  const isB64 = (m[2] ?? '').includes('base64');
  let bytes: Uint8Array<ArrayBuffer>;
  try {
    bytes = isB64 ? base64ToBytes(m[3]) : new Uint8Array(new TextEncoder().encode(decodeURIComponent(m[3])));
  } catch {
    return null;
  }
  if (!bytes.length) return null;
  const round3 = (v: number) => Math.round(v * 1000) / 1000;
  const pxToCm = (px: number) => round3((px * 2.54) / 96);
  const w = typeof node.attrs?.width === 'number' ? node.attrs.width : 0;
  const h = typeof node.attrs?.height === 'number' ? node.attrs.height : 0;
  const wrapAttr = node.attrs?.wrap;
  const wrap: WrapMode = wrapAttr === 'left' || wrapAttr === 'right' || wrapAttr === 'topBottom' ? wrapAttr : 'inline';
  return {
    path: `Pictures/${namePrefix}${index + 1}.${EXT_BY_MIME[mimeType] ?? 'png'}`,
    bytes,
    mimeType,
    widthCm: w > 0 ? pxToCm(w) : 0,
    heightCm: h > 0 ? pxToCm(h) : 0,
    alt: typeof node.attrs?.alt === 'string' ? node.attrs.alt : '',
    rotationDeg: typeof node.attrs?.rotation === 'number' ? node.attrs.rotation : 0,
    wrap,
    wrapOffsetCm: typeof node.attrs?.wrapOffset === 'number' ? round3(node.attrs.wrapOffset) : null,
    wrapOffsetYCm: typeof node.attrs?.wrapOffsetY === 'number' ? round3(node.attrs.wrapOffsetY) : null,
    wrapDistCm: typeof node.attrs?.wrapDist === 'number' ? round3(node.attrs.wrapDist) : null,
    wrapAlign: node.attrs?.wrapAlign === 'left' || node.attrs?.wrapAlign === 'right' ? node.attrs.wrapAlign : null,
    anchorPage: typeof node.attrs?.anchorPage === 'number' && node.attrs.anchorPage > 0 ? node.attrs.anchorPage : null,
    vAlign: typeof node.attrs?.vAlign === 'string' ? node.attrs.vAlign : null,
    inFront: node.attrs?.inFront === true,
  };
}

// Replace every inline `image` node with an IMG-sentinel text node and collect its
// bytes/geometry. Runs before odf-kit serialization so the sentinel rides through
// both the native paragraph path and our cell path; applyImages resolves it later.
function replaceImages(node: TiptapNode, images: ImageExport[]): TiptapNode {
  if (!node.content?.length) return node;
  const content: TiptapNode[] = [];
  for (const child of node.content) {
    if (child.type === 'image') {
      const desc = imageDescriptor(child, images.length);
      if (desc) {
        images.push(desc);
        content.push({ type: 'text', text: `${IMG}${images.length - 1}${IMG}` });
      }
      continue; // invalid image → dropped
    }
    content.push(replaceImages(child, images));
  }
  return { ...node, content };
}

// A header/footer paragraph's inline images → HFIMG-sentinel text runs (forced
// as-character), collected into `images` under a distinct Pictures/hfImage* name so
// applyHfRuns/hfFirstZoneXml carry the sentinel and applyHfPostProcess resolves it.
function replaceHfImages(para: TiptapNode | null, images: ImageExport[]): TiptapNode | null {
  if (!para?.content?.length) return para;
  const content: TiptapNode[] = [];
  for (const child of para.content) {
    if (child.type === 'image') {
      const desc = imageDescriptor(child, images.length, 'hfImage');
      if (desc) {
        images.push(desc);
        content.push({ type: 'text', text: `${HFIMG}${images.length - 1}${HFIMG}` });
      }
      continue; // invalid image → dropped
    }
    content.push(child);
  }
  return { ...para, content };
}

// One formula, collected by replaceFormulas and emitted by applyFormulas as an
// embedded ODF formula object (Formula{n}/content.xml) plus the frame referencing it.
type FormulaExport = { latex: string; display: boolean };

// Replace every inline `formula` node with an MTH-sentinel text run (carrying the
// node's marks) and collect its source; mirrors replaceImages so the sentinel rides
// every odf-kit path. applyFormulas resolves it after serialization.
function replaceFormulas(node: TiptapNode, formulas: FormulaExport[]): TiptapNode {
  if (!node.content?.length) return node;
  const content: TiptapNode[] = [];
  for (const child of node.content) {
    if (child.type === 'formula') {
      const a = child.attrs ?? {};
      const latex = typeof a.latex === 'string' ? a.latex : '';
      if (!latex) continue;
      formulas.push({ latex, display: a.display === true });
      content.push({ type: 'text', text: `${MTH}${formulas.length - 1}${MTH}`, marks: child.marks });
      continue;
    }
    content.push(replaceFormulas(child, formulas));
  }
  return { ...node, content };
}

// One inserted date/time field, collected by replaceDateTimeFields and emitted by
// applyDateTimeFields. `value` is the field's stored moment (ISO local datetime).
type DateTimeFieldExport = { kind: 'date' | 'time'; format: string; fixed: boolean; value: string };

// Replace every inline `dateTimeField` node with a DTF-sentinel text run (carrying
// the node's marks) and collect its attrs; mirrors replaceImages so the sentinel
// rides every odf-kit path. applyDateTimeFields resolves it after serialization.
function replaceDateTimeFields(node: TiptapNode, fields: DateTimeFieldExport[]): TiptapNode {
  if (!node.content?.length) return node;
  const content: TiptapNode[] = [];
  for (const child of node.content) {
    if (child.type === 'dateTimeField') {
      const a = child.attrs ?? {};
      fields.push({
        kind: a.kind === 'time' ? 'time' : 'date',
        format: typeof a.format === 'string' ? a.format : '',
        fixed: a.fixed === true,
        value: typeof a.value === 'string' ? a.value : '',
      });
      content.push({ type: 'text', text: `${DTF}${fields.length - 1}${DTF}`, marks: child.marks });
      continue;
    }
    content.push(replaceDateTimeFields(child, fields));
  }
  return { ...node, content };
}

// One recorded revision. Runs of the same change share an id, so the registry holds one
// entry per id and a deletion's text is the concatenation of its runs.
type RevisionExport = { kind: 'insertion' | 'deletion'; id: string; author: string; date: string; text: string; nodes: TiptapNode[] };

// Bracket every insertion run with TCI sentinels and cut every deletion run out, leaving
// a TCD sentinel where it was — ODF keeps a deletion's text in the registry, not inline.
// The deleted runs are hoisted into a marker paragraph at document end so they ride every
// serialization pass (styles, tabs, effects); applyRevisions splices them into the
// registry, which is how the deleted text keeps its formatting (LibreOffice does the same).
function replaceRevisions(node: TiptapNode, out: Map<string, RevisionExport>): TiptapNode {
  if (!node.content?.length) return node;
  const content: TiptapNode[] = [];
  for (const child of node.content) {
    const mark = child.type === 'text'
      ? child.marks?.find((m) => m.type === 'insertion' || m.type === 'deletion')
      : undefined;
    if (!mark) { content.push(replaceRevisions(child, out)); continue; }
    const a = mark.attrs ?? {};
    const id = String(a.id ?? '');
    const kind = mark.type as 'insertion' | 'deletion';
    const known = out.has(id);
    const entry = out.get(id) ?? {
      kind, id,
      author: String(a.author ?? '') || GENERATOR,
      date: typeof a.date === 'string' && a.date ? a.date : new Date().toISOString(),
      text: '', nodes: [],
    };
    entry.text += child.text ?? '';
    out.set(id, entry);
    // The marks stay off the sentinel runs: a change is not formatting, and odf-kit
    // would otherwise split the paragraph's runs around it.
    const rest = child.marks?.filter((m) => m !== mark);
    if (kind === 'deletion') {
      entry.nodes.push({ ...child, ...(rest?.length ? { marks: rest } : { marks: undefined }) });
      // One point marker per change: its registry region holds every fragment.
      if (!known) content.push({ type: 'text', text: `${TCD}${id}${TCD}` });
      continue;
    }
    content.push({ type: 'text', text: `${TCI}${id}${TCI}` });
    content.push({ ...child, ...(rest?.length ? { marks: rest } : { marks: undefined }) });
    content.push({ type: 'text', text: `${TCI}${id}${TCI}` });
  }
  if (node.type === 'doc') {
    for (const entry of out.values()) {
      if (entry.kind !== 'deletion' || !entry.nodes.length) continue;
      content.push({ type: 'paragraph',
        content: [{ type: 'text', text: `${TCD}#${entry.id}${TCD}` }, ...entry.nodes] });
    }
  }
  return { ...node, content };
}

// Resolve the revision sentinels and prepend the registry the body points into. The
// registry also carries whether the document goes on recording — LibreOffice writes it
// with no changes in it for exactly that (probed).
function applyRevisions(odtBytes: Uint8Array, list: Map<string, RevisionExport>, recording: boolean): Uint8Array {
  if (!list.size && !recording) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  // ODF ids are per document; the editor's are opaque strings.
  const odfId = new Map([...list.keys()].map((id, i) => [id, `ct${i + 1}`]));
  // Cut the hoisted deletion paragraphs (before the point-marker pass, whose regex would
  // eat their markers) and keep their serialized runs for the registry.
  const hoisted = new Map<string, string>();
  content = content.replace(
    new RegExp(`<text:p\\b[^>]*>\\s*${TCD}#([^${TCD}]*)${TCD}([\\s\\S]*?)</text:p>`, 'g'),
    (_m, id: string, inner: string) => { hoisted.set(id, inner); return ''; },
  );
  let open = new Map<string, boolean>();
  content = content
    .replace(new RegExp(`${TCI}([^${TCI}]*)${TCI}`, 'g'), (_m, id: string) => {
      const ct = odfId.get(id);
      if (!ct) return '';
      const isEnd = open.get(id) === true;
      open.set(id, !isEnd);
      return isEnd
        ? `<text:change-end text:change-id="${ct}"/>`
        : `<text:change-start text:change-id="${ct}"/>`;
    })
    .replace(new RegExp(`${TCD}([^${TCD}]*)${TCD}`, 'g'), (_m, id: string) => {
      const ct = odfId.get(id);
      return ct ? `<text:change text:change-id="${ct}"/>` : '';
    });

  const regions = [...list.values()].map((r) => {
    const ct = odfId.get(r.id)!;
    const info = `<office:change-info><dc:creator>${escapeXml(r.author)}</dc:creator>`
      + `<dc:date>${escapeXml(r.date.replace(/\.\d+Z?$/, ''))}</dc:date></office:change-info>`;
    const runs = hoisted.get(r.id) ?? escapeXml(r.text);
    const body = r.kind === 'deletion'
      ? `<text:deletion>${info}<text:p text:style-name="Standard">${runs}</text:p></text:deletion>`
      : `<text:insertion>${info}</text:insertion>`;
    return `<text:changed-region xml:id="${ct}" text:id="${ct}">${body}</text:changed-region>`;
  }).join('');
  content = content.replace(
    /(<office:text\b[^>]*>)/,
    `$1<text:tracked-changes text:track-changes="${recording}">${regions}</text:tracked-changes>`,
  );
  content = ensureDcNamespace(content);

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// The change registry names its author with dc:creator; odf-kit declares no dc: prefix
// in content.xml, and an undeclared one loses the whole element.
function ensureDcNamespace(content: string): string {
  if (content.includes('xmlns:dc=')) return content;
  return content.replace(/<office:document-content\b/, '<office:document-content xmlns:dc="http://purl.org/dc/elements/1.1/"');
}

// One caption sequence field, collected by replaceSequenceFields and emitted by
// applySequenceFields. `number` is the rank the editor resolved; both formats cache it.
type SequenceExport = { category: SeqCategory; format: string; number: number };

// Replace every inline `sequenceField` node with a SEQ-sentinel text run, as
// replaceDateTimeFields does, so it rides every odf-kit path.
function replaceSequenceFields(node: TiptapNode, fields: SequenceExport[]): TiptapNode {
  if (!node.content?.length) return node;
  const content: TiptapNode[] = [];
  for (const child of node.content) {
    if (child.type === 'sequenceField') {
      const a = child.attrs ?? {};
      fields.push({
        category: seqCategoryOf(a.category as string),
        format: typeof a.format === 'string' && a.format ? a.format : '1',
        number: typeof a.number === 'number' && a.number > 0 ? a.number : 1,
      });
      content.push({ type: 'text', text: `${SEQ}${fields.length - 1}${SEQ}`, marks: child.marks });
      continue;
    }
    content.push(replaceSequenceFields(child, fields));
  }
  return { ...node, content };
}

// Resolve SEQ sentinels into <text:sequence>. The formula is LibreOffice's own
// "ooow:<name>+1", which is what makes its reader recount the captions on load; the
// element text is the cached number, and text:ref-name is the anchor an index links to.
function applySequenceFields(odtBytes: Uint8Array, fields: SequenceExport[]): Uint8Array {
  if (!fields.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  content = content.replace(new RegExp(`${SEQ}(\\d+)${SEQ}`, 'g'), (_m, idx: string) => {
    const f = fields[Number(idx)];
    if (!f) return '';
    const name = ODF_SEQ_NAME[f.category];
    const display = escapeXml(formatOrdinal(f.number, f.format as NoteNumFormat));
    return `<text:sequence text:ref-name="ref${name}${idx}" text:name="${name}"`
      + ` text:formula="ooow:${name}+1" style:num-format="${f.format}">${display}</text:sequence>`;
  });

  // Every sequence needs its variable declared, as LibreOffice writes them.
  const used = [...new Set(fields.map((f) => ODF_SEQ_NAME[f.category]))];
  const decls = used.map((n) => `<text:sequence-decl text:display-outline-level="0" text:name="${n}"/>`).join('');
  content = /<text:sequence-decls>/.test(content)
    ? content.replace('<text:sequence-decls>', `<text:sequence-decls>${decls}`)
    : content.replace('<office:text>', `<office:text><text:sequence-decls>${decls}</text:sequence-decls>`);

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// One alphabetical-index entry, collected by replaceIndexEntries.
type IndexEntryExport = { term: string; key1: string };

function replaceIndexEntries(node: TiptapNode, marks: IndexEntryExport[]): TiptapNode {
  if (!node.content?.length) return node;
  const content: TiptapNode[] = [];
  for (const child of node.content) {
    if (child.type === 'indexEntry') {
      const a = child.attrs ?? {};
      marks.push({ term: String(a.term ?? ''), key1: String(a.key1 ?? '') });
      content.push({ type: 'text', text: `${IXE}${marks.length - 1}${IXE}`, marks: child.marks });
      continue;
    }
    content.push(replaceIndexEntries(child, marks));
  }
  return { ...node, content };
}

// Resolve IXE sentinels into the point mark LibreOffice writes for an index entry.
function applyIndexEntries(odtBytes: Uint8Array, marks: IndexEntryExport[]): Uint8Array {
  if (!marks.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;
  let content = strFromU8(contentBytes);
  content = content.replace(new RegExp(`${IXE}(\\d+)${IXE}`, 'g'), (_m, idx: string) => {
    const m = marks[Number(idx)];
    if (!m) return '';
    return `<text:alphabetical-index-mark text:string-value="${escapeXml(m.term)}"`
      + (m.key1 ? ` text:key1="${escapeXml(m.key1)}"` : '') + '/>';
  });
  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// One citation, collected by replaceBibEntries. ODF keeps the whole source record on
// the mark, so nothing else has to travel with the document.
type BibExport = { identifier: string; type: string; fields: Record<string, string>; text: string };

function replaceBibEntries(node: TiptapNode, marks: BibExport[]): TiptapNode {
  if (!node.content?.length) return node;
  const content: TiptapNode[] = [];
  for (const child of node.content) {
    if (child.type === 'bibliographyEntry') {
      const a = child.attrs ?? {};
      const identifier = String(a.identifier ?? '');
      marks.push({
        identifier,
        type: isBibType(a.type) ? String(a.type) : 'misc',
        fields: (a.fields ?? {}) as Record<string, string>,
        text: String(a.text || citationText(identifier)),
      });
      content.push({ type: 'text', text: `${BIB}${marks.length - 1}${BIB}`, marks: child.marks });
      continue;
    }
    content.push(replaceBibEntries(child, marks));
  }
  return { ...node, content };
}

// BIB sentinels → <text:bibliography-mark>, which unlike an index mark wraps the text
// the citation shows. Every field is an attribute of its own, LibreOffice's own form.
function applyBibEntries(odtBytes: Uint8Array, marks: BibExport[]): Uint8Array {
  if (!marks.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;
  let content = strFromU8(contentBytes);
  content = content.replace(new RegExp(`${BIB}(\\d+)${BIB}`, 'g'), (_m, idx: string) => {
    const m = marks[Number(idx)];
    if (!m) return '';
    const fields = Object.entries(m.fields)
      .filter(([, v]) => String(v ?? '').trim())
      .map(([k, v]) => ` text:${k}="${escapeXml(String(v))}"`)
      .join('');
    return `<text:bibliography-mark text:identifier="${escapeXml(m.identifier)}"`
      + ` text:bibliography-type="${m.type}"${fields}>${escapeXml(m.text)}</text:bibliography-mark>`;
  });
  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// One ruby annotation, collected by replaceRuby: the base text and the reading over it.
type RubyExport = { base: string; text: string };

function replaceRuby(node: TiptapNode, rubies: RubyExport[]): TiptapNode {
  if (!node.content?.length) return node;
  const content: TiptapNode[] = [];
  for (const child of node.content) {
    if (child.type === 'ruby') {
      const a = child.attrs ?? {};
      rubies.push({ base: String(a.base ?? ''), text: String(a.text ?? '') });
      content.push({ type: 'text', text: `${RBY}${rubies.length - 1}${RBY}`, marks: child.marks });
      continue;
    }
    content.push(replaceRuby(child, rubies));
  }
  return { ...node, content };
}

// RBY sentinels → <text:ruby>. The alignment and the position ride a ruby-family
// automatic style, which is where LibreOffice keeps them (probed: it writes the style
// out again unchanged, adding only its own loext: mirror of the position).
function applyRuby(odtBytes: Uint8Array, rubies: RubyExport[]): Uint8Array {
  if (!rubies.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;
  let content = strFromU8(contentBytes);
  content = content.replace(new RegExp(`${RBY}(\\d+)${RBY}`, 'g'), (_m, idx: string) => {
    const r = rubies[Number(idx)];
    if (!r) return '';
    return `<text:ruby text:style-name="${RUBY_STYLE}"><text:ruby-base>${escapeXml(r.base)}</text:ruby-base>`
      + `<text:ruby-text>${escapeXml(r.text)}</text:ruby-text></text:ruby>`;
  });
  content = injectAutomaticStyles(
    content,
    `<style:style style:name="${RUBY_STYLE}" style:family="ruby">`
      + '<style:ruby-properties style:ruby-align="center" style:ruby-position="above"/></style:style>',
  );
  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

const RUBY_STYLE = 'Ru1';

// One cross-reference, collected by replaceCrossRefs and emitted by applyBookmarks.
type CrossRefExport = { name: string; format: 'text' | 'page' };

const bookmarkNameOf = (node: TiptapNode): string =>
  String(node.marks?.find((m) => m.type === 'bookmark')?.attrs?.name ?? '');

// One comment, collected by replaceComments and emitted by applyComments.
type CommentExport = { name: string; author: string; date: string; text: string; resolved: boolean };

// Bracket each comment's text with the CMS/CME sentinels, the same shape as the bookmark
// pair — spliced into the run text, so a comment inside a cell or a list rides along too.
function replaceComments(node: TiptapNode, out: CommentExport[]): TiptapNode {
  if (!node.content?.length) return node;
  const content: TiptapNode[] = [];
  let openId = '';
  let openIndex = -1;
  let lastOfRange = -1;
  const closeRange = () => {
    if (!openId) return;
    const run = content[lastOfRange];
    content[lastOfRange] = { ...run, text: `${run.text ?? ''}${CME}${openIndex}${CME}` };
    openId = '';
  };
  for (const child of node.content) {
    const mark = child.type === 'text' ? child.marks?.find(m => m.type === 'comment') : undefined;
    const id = mark ? String(mark.attrs?.id ?? '') : '';
    if (id !== openId) closeRange();
    if (id && !openId) {
      openId = id;
      openIndex = out.length;
      out.push({
        name: id,
        author: String(mark!.attrs?.author ?? ''),
        date: String(mark!.attrs?.date ?? ''),
        text: String(mark!.attrs?.text ?? ''),
        resolved: mark!.attrs?.resolved === true,
      });
      content.push({ ...child, text: `${CMS}${openIndex}${CMS}${child.text ?? ''}` });
      lastOfRange = content.length - 1;
      continue;
    }
    content.push(id ? child : replaceComments(child, out));
    if (id) lastOfRange = content.length - 1;
  }
  closeRange();
  return { ...node, content };
}

// Bracket each bookmark's text with the BMS/BME sentinels and every `crossRef` node with
// an XRF-sentinel run; applyBookmarks resolves them after serialization. Spliced into the
// run text, not a run emitter, so both ride every odf-kit path (cells included).
function replaceBookmarks(node: TiptapNode, refs: CrossRefExport[]): TiptapNode {
  if (!node.content?.length) return node;
  const content: TiptapNode[] = [];
  // Index of the run the open bookmark started on, so its end sentinel lands on the
  // last run of the range.
  let open = '';
  let lastOfRange = -1;
  const closeRange = () => {
    if (!open) return;
    const run = content[lastOfRange];
    content[lastOfRange] = { ...run, text: `${run.text ?? ''}${BME}${open}${BME}` };
    open = '';
  };
  for (const child of node.content) {
    if (child.type === 'crossRef') {
      closeRange();
      const a = child.attrs ?? {};
      refs.push({ name: String(a.name ?? ''), format: a.format === 'page' ? 'page' : 'text' });
      content.push({ type: 'text', text: `${XRF}${refs.length - 1}${XRF}${String(a.text ?? '')}${XRF}`, marks: child.marks });
      continue;
    }
    const name = child.type === 'text' ? bookmarkNameOf(child) : '';
    if (name !== open) closeRange();
    if (name && !open) {
      open = name;
      content.push({ ...child, text: `${BMS}${name}${BMS}${child.text ?? ''}` });
      lastOfRange = content.length - 1;
      continue;
    }
    content.push(name ? child : replaceBookmarks(child, refs));
    if (name) lastOfRange = content.length - 1;
  }
  closeRange();
  return { ...node, content };
}

// One text box / shape, collected by replaceTextBoxes and emitted by applyTextBoxes.
type TextBoxExport = {
  widthCm: number;
  heightCm: number;
  rotationDeg: number;
  wrap: WrapMode;
  wrapOffsetCm: number | null;
  wrapOffsetYCm: number | null;
  wrapDistCm: number | null;
  wrapAlign: string | null;
  paddingCm: number;
  shapeKind: ShapeKind;
  shapePath: string | null;
  flipV: boolean;
  textVertical: boolean;
  fill: string | null;
  stroke: string | null;
  strokeWidthPt: number;
  // The anchor paragraph's own spacing in pt, which the box stands in for.
  spaceBeforePt: number;
  spaceAfterPt: number;
};

function textBoxDescriptor(node: TiptapNode): TextBoxExport {
  const round3 = (v: number) => Math.round(v * 1000) / 1000;
  const pxToCm = (px: number) => round3((px * 2.54) / 96);
  const a = node.attrs ?? {};
  const wrapAttr = a.wrap;
  return {
    widthCm: pxToCm(typeof a.width === 'number' && a.width > 0 ? a.width : 280),
    heightCm: pxToCm(typeof a.height === 'number' && a.height > 0 ? a.height : 96),
    rotationDeg: typeof a.rotation === 'number' ? a.rotation : 0,
    wrap: wrapAttr === 'left' || wrapAttr === 'right' || wrapAttr === 'topBottom' ? wrapAttr : 'inline',
    wrapOffsetCm: typeof a.wrapOffset === 'number' ? round3(a.wrapOffset) : null,
    wrapOffsetYCm: typeof a.wrapOffsetY === 'number' ? round3(a.wrapOffsetY) : null,
    wrapDistCm: typeof a.wrapDist === 'number' ? round3(a.wrapDist) : null,
    wrapAlign: a.wrapAlign === 'center' || a.wrapAlign === 'right' ? a.wrapAlign : null,
    paddingCm: typeof a.paddingCm === 'number' ? round3(a.paddingCm) : TEXTBOX_PADDING_CM,
    shapeKind: isShapeKind(a.shapeKind) ? a.shapeKind : 'textbox',
    shapePath: typeof a.shapePath === 'string' && a.shapePath ? a.shapePath : null,
    flipV: a.flipV === true,
    textVertical: a.textVertical === true,
    fill: typeof a.fillColor === 'string' && a.fillColor ? a.fillColor : null,
    stroke: typeof a.strokeColor === 'string' && a.strokeColor ? a.strokeColor : null,
    strokeWidthPt: typeof a.strokeWidthPt === 'number' && a.strokeWidthPt > 0 ? a.strokeWidthPt : 1,
    spaceBeforePt: typeof a.spaceBefore === 'number' ? round3(a.spaceBefore) : 0,
    spaceAfterPt: typeof a.spaceAfter === 'number' ? round3(a.spaceAfter) : 0,
  };
}

// Swap each top-level textBox for a pair of marker paragraphs bracketing its child blocks,
// hoisted to top level so they ride every existing export pass unchanged (custom attrs,
// list styles, inline sentinels, images); applyTextBoxes re-wraps the serialized region.
function replaceTextBoxes(doc: TiptapNode, boxes: TextBoxExport[]): TiptapNode {
  if (!doc.content?.length) return doc;
  const content: TiptapNode[] = [];
  for (const child of doc.content) {
    if (child.type === 'textBox') {
      const i = boxes.length;
      boxes.push(textBoxDescriptor(child));
      content.push({ type: 'paragraph', content: [{ type: 'text', text: `${TBX}S${i}${TBX}` }] });
      content.push(...(child.content ?? []));
      content.push({ type: 'paragraph', content: [{ type: 'text', text: `${TBX}E${i}${TBX}` }] });
      continue;
    }
    content.push(child);
  }
  return { ...doc, content };
}

// One footnote/endnote, collected by replaceNotes and emitted by applyNotes.
type NoteExport = { kind: 'footnote' | 'endnote'; citation: string; label: string | null; styleName: string | null };

// Anchors become an FNT A{i} sentinel run in the running text; the note section is
// dissolved and each note re-emitted as its own top-level paragraph opening with an
// FNT B{i} sentinel. Hoisted like a text box, so the note text rides every existing
// pass — marks, character styles, links, bookmarks, fields and formulas all included.
function replaceNotes(doc: TiptapNode, notes: NoteExport[]): TiptapNode {
  const bodies = new Map<string, { content: TiptapNode[]; label: string | null; styleName: string | null }>();
  const body: TiptapNode[] = [];
  for (const child of doc.content ?? []) {
    if (child.type !== 'noteSection') { body.push(child); continue; }
    for (const note of child.content ?? []) {
      const a = note.attrs ?? {};
      bodies.set(String(a.id ?? ''), {
        content: note.content ?? [],
        label: typeof a.label === 'string' && a.label ? a.label : null,
        styleName: typeof a.styleName === 'string' && a.styleName ? a.styleName : null,
      });
    }
  }

  // Anchor order is the numbering order, so it is also the index order.
  const order: string[] = [];
  const swapRefs = (node: TiptapNode): TiptapNode => {
    if (!node.content?.length) return node;
    return {
      ...node,
      content: node.content.map((child) => {
        if (child.type !== 'noteRef') return swapRefs(child);
        const a = child.attrs ?? {};
        const id = String(a.id ?? '');
        const i = notes.length;
        order.push(id);
        notes.push({
          kind: a.kind === 'endnote' ? 'endnote' : 'footnote',
          citation: String(a.text ?? ''),
          label: bodies.get(id)?.label ?? null,
          styleName: bodies.get(id)?.styleName ?? null,
        });
        return { type: 'text', text: `${FNT}A${i}${FNT}` };
      }),
    };
  };

  const hoisted = body.map(swapRefs);
  order.forEach((id, i) => {
    hoisted.push({
      type: 'paragraph',
      content: [{ type: 'text', text: `${FNT}B${i}${FNT}` }, ...(bodies.get(id)?.content ?? [])],
    });
  });
  return { ...doc, content: hoisted };
}

// A multi-column section's geometry, collected by replaceColumns.
type ColumnsExport = { count: number; gapCm: number };

function columnsDescriptor(node: TiptapNode): ColumnsExport {
  const a = node.attrs ?? {};
  const count = typeof a.count === 'number' ? Math.min(3, Math.max(2, Math.round(a.count))) : 2;
  const gapRaw = typeof a.gapCm === 'number' && Number.isFinite(a.gapCm) ? a.gapCm : 0.5;
  const clamped = Math.min(5, Math.max(0, gapRaw));
  return { count, gapCm: Math.round(clamped * 1000) / 1000 };
}

// Re-merge paragraphs split by columnsFlow at a page boundary (the second part
// carries the layout-internal joinPrev attr) — the file must hold ONE paragraph.
// Also used by the DOCX exporter.
export function mergeJoinedParagraphsJson(blocks: TiptapNode[]): TiptapNode[] {
  const out: TiptapNode[] = [];
  for (const b of blocks) {
    const prev = out[out.length - 1];
    if (b.type === 'paragraph' && b.attrs?.joinPrev && prev?.type === 'paragraph') {
      out[out.length - 1] = { ...prev, content: [...(prev.content ?? []), ...(b.content ?? [])] };
    } else {
      out.push(b);
    }
  }
  return out;
}

// Swap each top-level columns section for marker paragraphs (same mechanism as
// replaceTextBoxes). Adjacent equal-attr fragments are a columnsFlow.ts page-split
// chain — one section, so they coalesce here.
function replaceColumns(doc: TiptapNode, cols: ColumnsExport[]): TiptapNode {
  if (!doc.content?.length) return doc;
  const content: TiptapNode[] = [];
  const children = doc.content;
  for (let c = 0; c < children.length; c++) {
    const child = children[c];
    if (child.type === 'columns') {
      const i = cols.length;
      const desc = columnsDescriptor(child);
      cols.push(desc);
      const inner: TiptapNode[] = [...(child.content ?? [])];
      while (c + 1 < children.length && children[c + 1].type === 'columns') {
        const next = columnsDescriptor(children[c + 1]);
        if (next.count !== desc.count || next.gapCm !== desc.gapCm) break;
        inner.push(...(children[c + 1].content ?? []));
        c++;
      }
      content.push({ type: 'paragraph', content: [{ type: 'text', text: `${COL}S${i}${COL}` }] });
      content.push(...mergeJoinedParagraphsJson(inner));
      content.push({ type: 'paragraph', content: [{ type: 'text', text: `${COL}E${i}${COL}` }] });
      continue;
    }
    content.push(child);
  }
  return { ...doc, content };
}

// One generated table of contents, collected by replaceTableOfContents and emitted by
// applyToc. Entries are the cached heading→page rows (the node view keeps them current).
type TocEntry = { text: string; level: number; page: number; pages?: number[] };
type TocExport = { kind: IndexKind; entries: TocEntry[]; title: string | null; maxLevel: number; leader: string | null; tabPosCm: number | null; levelStyles: (string | null)[] | null; citationStyle: CitationStyle };

// Swap each top-level tableOfContents node for a marker paragraph carrying the TOC
// sentinel and collect its cached entries. Top-level only (like replacePageBreaks): a
// sentinel in a cell/list paragraph would corrupt the SEG-based cell rebuild.
function replaceTableOfContents(doc: TiptapNode, tocs: TocExport[]): TiptapNode {
  if (!doc.content?.length) return doc;
  const content: TiptapNode[] = [];
  for (const child of doc.content) {
    if (child.type === 'tableOfContents') {
      const raw = Array.isArray(child.attrs?.entries) ? (child.attrs!.entries as TocEntry[]) : [];
      const entries = raw
        .filter(e => e && typeof e.text === 'string')
        .map(e => ({
          text: String(e.text),
          level: Math.min(MAX_HEADING_LEVEL, Math.max(1, Number(e.level) || 1)),
          page: Math.max(1, Number(e.page) || 1),
          // An alphabetical row lists every page its term appears on.
          ...(Array.isArray(e.pages) && e.pages.length ? { pages: e.pages.map((n: unknown) => Math.max(1, Number(n) || 1)) } : {}),
        }));
      const rawTitle = child.attrs?.title;
      const depth = Number(child.attrs?.maxLevel);
      tocs.push({
        kind: indexKindOf(child.attrs?.index),
        entries,
        title: typeof rawTitle === 'string' ? rawTitle : null,
        maxLevel: depth >= 1 ? Math.min(MAX_HEADING_LEVEL, depth) : MAX_HEADING_LEVEL,
        leader: normalizeLeader(child.attrs?.leader),
        tabPosCm: typeof child.attrs?.tabPosCm === 'number' ? child.attrs.tabPosCm : null,
        levelStyles: Array.isArray(child.attrs?.levelStyles) ? (child.attrs!.levelStyles as (string | null)[]) : null,
        citationStyle: isCitationStyle(child.attrs?.citationStyle) ? child.attrs!.citationStyle : 'key',
      });
      content.push({ type: 'paragraph', content: [{ type: 'text', text: `${TOC_SENT}${tocs.length - 1}${TOC_SENT}` }] });
      continue;
    }
    content.push(child);
  }
  return { ...doc, content };
}

function escapeXml(s: string): string {
  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
}

// Mirror odf-kit's normalizeLineHeight (content.js): a number is a multiplier
// (1.5 → "150%"); a string with a unit passes through ("18pt" → "18pt").
function normalizeLineHeight(lh: number | string): string {
  return typeof lh === 'number' ? `${Math.round(lh * 100)}%` : lh;
}

// Paragraph property overrides for the exported .odt, for both list-item and
// table-cell paragraphs (odf-kit's List/TableBuilder support no per-paragraph
// alignment/spacing/line-height), injected as automatic styles in post-processing.
type ParaStyle = {
  align: AlignValue | null;
  spaceBefore: number | null;
  spaceAfter: number | null;
  lineHeight: number | string | null;
  // Paragraph background ("colored field") + per-side border ("rule line"). The border
  // attr value ('<W>pt solid #RRGGBB') is already a valid ODF fo:border value.
  background: string | null;
  borderTop: string | null;
  borderRight: string | null;
  borderBottom: string | null;
  borderLeft: string | null;
  // The block's own base direction (textDirection.ts); null inherits the page's.
  dir: 'ltr' | 'rtl' | null;
  // Left/first-line/right indents in cm — cell blocks only: a list item's indent
  // lives in its list style, and the importer skips paraProps indents there.
  indent: number | null;
  indentFirst: number | null;
  indentRight: number | null;
};

function paraStyleIsEmpty(s: ParaStyle): boolean {
  return s.align === null && s.spaceBefore === null && s.spaceAfter === null && s.lineHeight === null
    && s.background === null && s.borderTop === null && s.borderRight === null
    && s.borderBottom === null && s.borderLeft === null && s.dir === null
    && s.indent === null && s.indentFirst === null && s.indentRight === null;
}

// ODF writes a direction as a writing mode; the vertical ones are not ours to emit.
export function writingModeOf(dir: 'ltr' | 'rtl' | null | undefined): string | null {
  return dir === 'rtl' ? 'rl-tb' : dir === 'ltr' ? 'lr-tb' : null;
}

// Extract the overridable paragraph properties from a node's attrs. Left
// alignment yields null (it's the Standard-style default, so no override needed).
function paraStyleFromAttrs(attrs: TiptapNode['attrs'], withIndents = true): ParaStyle {
  const ta = attrs?.textAlign as AlignValue | undefined;
  const cm = (v: unknown) => (withIndents && typeof v === 'number' && v !== 0 ? v : null);
  const sb = attrs?.spaceBefore;
  const sa = attrs?.spaceAfter;
  const lh = attrs?.lineHeight;
  let lineHeight: number | string | null = null;
  if (lh != null) {
    const lhNum = parseFloat(String(lh));
    lineHeight = isNaN(lhNum) ? String(lh) : lhNum;
  }
  const border = (v: unknown) => (typeof v === 'string' && v && v !== 'none' ? v : null);
  return {
    align: ta === 'center' || ta === 'right' || ta === 'justify' ? ta : null,
    spaceBefore: typeof sb === 'number' ? sb : null,
    spaceAfter: typeof sa === 'number' ? sa : null,
    lineHeight,
    background: typeof attrs?.backgroundColor === 'string' && attrs.backgroundColor ? attrs.backgroundColor : null,
    borderTop: border(attrs?.borderTop),
    borderRight: border(attrs?.borderRight),
    borderBottom: border(attrs?.borderBottom),
    borderLeft: border(attrs?.borderLeft),
    dir: attrs?.dir === 'rtl' || attrs?.dir === 'ltr' ? attrs.dir : null,
    indent: cm(attrs?.indent),
    indentFirst: cm(attrs?.indentFirst),
    indentRight: cm(attrs?.indentRight),
  };
}

// fo:* paragraph-properties attribute strings for a ParaStyle override.
function paraStyleProps(style: ParaStyle): string[] {
  const props: string[] = [];
  if (style.align) props.push(`fo:text-align="${style.align}"`);
  if (style.spaceBefore != null) props.push(`fo:margin-top="${style.spaceBefore}pt"`);
  if (style.spaceAfter != null) props.push(`fo:margin-bottom="${style.spaceAfter}pt"`);
  if (style.lineHeight != null) props.push(`fo:line-height="${normalizeLineHeight(style.lineHeight)}"`);
  if (style.indent != null) props.push(`fo:margin-left="${style.indent}cm"`);
  if (style.indentFirst != null) props.push(`fo:text-indent="${style.indentFirst}cm"`);
  if (style.indentRight != null) props.push(`fo:margin-right="${style.indentRight}cm"`);
  if (style.background) props.push(`fo:background-color="${style.background}"`);
  // The canonical border attr ('<W>pt solid #RRGGBB') is itself a valid fo:border value.
  for (const [attr, side] of [
    ['borderTop', 'top'], ['borderRight', 'right'], ['borderBottom', 'bottom'], ['borderLeft', 'left'],
  ] as const) {
    const v = style[attr];
    if (v) props.push(`fo:border-${side}="${v}"`);
  }
  const wm = writingModeOf(style.dir);
  if (wm) props.push(`style:writing-mode="${wm}"`);
  return props;
}

// Per-cell block descriptors, built in exportTable and consumed in document order by
// applyCellBlocks to rebuild real <text:h>/<text:p>/<text:list> from the SEG-segmented
// <text:p> odf-kit emits. Each paragraph/heading/list item is one segment, in DFS order.
type CellListItem = { style: ParaStyle; nested: CellListBlock | null };
// listStyleType is the ordered list's raw attr (null = depth default / inherited
// multilevel chain); bulletChar the bullet list's marker attr (null = default cycle).
type CellListBlock = { kind: 'list'; ordered: boolean; start: number | null; listStyleType: string | null; bulletChar: string | null; items: CellListItem[] };
type CellBlock =
  | { kind: 'paragraph'; style: ParaStyle }
  | { kind: 'heading'; level: number; style: ParaStyle }
  | CellListBlock;
// A table's own margins in cm (0/0 tables are recorded as null).
type TableProps = { ml: number; mr: number; mt: number; mb: number; keepRows: boolean; repeatHeader: boolean };

// Collect the alignment + paragraph spacing of each listItem's first paragraph,
// in DFS order — matching the order that odf-kit emits <text:list-item> elements
// into content.xml. Items without overrides yield an all-null descriptor.
function collectListItemStyles(node: TiptapNode, result: ParaStyle[]): void {
  if (node.type === 'listItem') {
    const firstPara = node.content?.find(c => c.type === 'paragraph');
    result.push(paraStyleFromAttrs(firstPara?.attrs, false));
    // Recurse into nested lists only (their listItems extend the DFS sequence).
    for (const child of node.content ?? []) {
      if (child.type === 'bulletList' || child.type === 'orderedList') {
        collectListItemStyles(child, result);
      }
    }
    return;
  }
  for (const child of node.content ?? []) {
    collectListItemStyles(child, result);
  }
}

// Collect each table row's explicit height (px → cm), in DFS order matching odf-kit's
// <table:table-row> emission. rowHeight is unscaled px @96dpi (tableRow.ts), converted
// to cm (px × 2.54 / 96). Rows without an explicit height yield null.
function collectTableRowHeights(node: TiptapNode, result: (string | null)[]): void {
  if (node.type === 'table') {
    for (const row of node.content ?? []) {
      if (row.type !== 'tableRow') continue;
      const h = row.attrs?.rowHeight;
      if (typeof h === 'number' && h > 0) {
        const cm = Math.round(((h * 2.54) / 96) * 1000) / 1000;
        result.push(`${cm}cm`);
      } else {
        result.push(null);
      }
    }
    return;
  }
  for (const child of node.content ?? []) {
    collectTableRowHeights(child, result);
  }
}

// odf-kit's TableBuilder has no row-height option, so post-process content.xml: each
// <table:table-row> with a height gets an automatic style with style:min-row-height
// (a minimum) + use-optimal-row-height="false". One heights[] entry per row, in order.
function applyTableRowHeights(odtBytes: Uint8Array, heights: (string | null)[]): Uint8Array {
  if (heights.every(h => h === null)) return odtBytes;

  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  const styleDefs: { name: string; height: string }[] = [];
  const nameByHeight = new Map<string, string>();
  let counter = 0;
  let idx = 0;

  content = content.replace(/<table:table-row\b([^>]*)>/g, (match, attrs: string) => {
    const height = heights[idx++];
    if (!height) return match;
    if (/\btable:style-name=/.test(attrs)) return match;
    let name = nameByHeight.get(height);
    if (!name) {
      counter++;
      name = `TRH${counter}`;
      nameByHeight.set(height, name);
      styleDefs.push({ name, height });
    }
    return `<table:table-row table:style-name="${name}"${attrs}>`;
  });

  if (styleDefs.length === 0) return odtBytes;

  const newStyles = styleDefs.map(({ name, height }) =>
    `<style:style style:name="${name}" style:family="table-row"><style:table-row-properties style:min-row-height="${height}" style:use-optimal-row-height="false"/></style:style>`,
  ).join('\n');

  content = injectAutomaticStyles(content, `${newStyles}\n`);

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// odf-kit only writes the fo:padding shorthand, which ODF defines as one length —
// LibreOffice drops a multi-value form. The cells carry their table's margins as a
// CSS-style TRBL shorthand, which this expands per side (scoped to cell properties).
function expandCellPadding(odtBytes: Uint8Array): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  const content = strFromU8(contentBytes).replace(
    /(<style:table-cell-properties\b[^>]*?)fo:padding="([^"]*)"/g,
    (_m, head: string, value: string) => {
      const [top, right, bottom, left] = value.trim().split(/\s+/);
      if (!left) return head + `fo:padding="${value}"`;
      return head + `fo:padding-top="${top}" fo:padding-right="${right}"`
        + ` fo:padding-bottom="${bottom}" fo:padding-left="${left}"`;
    },
  );

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// A dragged table edge → the style's fo:margin-left/-right + style:width (with odf-kit's
// table:align="margins" the table fills what's left); keep-rows → may-break-between-rows.
// odf-kit names table styles Table1, Table2, … in document order, as the descriptors are.
function applyTableProps(odtBytes: Uint8Array, margins: (TableProps | null)[], contentWidthCm: number): Uint8Array {
  if (margins.every(m => m === null)) return odtBytes;

  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  margins.forEach((m, i) => {
    if (!m) return;
    const width = Math.round((contentWidthCm - m.ml - m.mr) * 1000) / 1000;
    const horiz = m.ml || m.mr
      ? ` style:width="${width}cm" fo:margin-left="${m.ml}cm" fo:margin-right="${m.mr}cm"` : '';
    const vert = `${m.mt ? ` fo:margin-top="${m.mt}cm"` : ''}${m.mb ? ` fo:margin-bottom="${m.mb}cm"` : ''}`;
    const keep = m.keepRows ? ' style:may-break-between-rows="false"' : '';
    content = content.replace(
      new RegExp(`(<style:style[^>]*style:name="Table${i + 1}"[^>]*>\\s*<style:table-properties)`),
      `$1${horiz}${vert}${keep}`,
    );
  });

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// <table:table-header-rows> around a table's first row, which is what makes both word
// processors repeat it at the top of every page the table continues on. The tables come
// out in document order, the same order applyTableProps walks.
function applyTableHeaderRows(odtBytes: Uint8Array, tables: (TableProps | null)[]): Uint8Array {
  if (!tables.some(t => t?.repeatHeader)) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  let index = -1;
  content = content.replace(/<table:table\b[\s\S]*?<\/table:table>/g, (table) => {
    index++;
    if (!tables[index]?.repeatHeader) return table;
    const open = table.indexOf('<table:table-row');
    if (open < 0) return table;
    const close = table.indexOf('</table:table-row>', open);
    if (close < 0) return table;
    const end = close + '</table:table-row>'.length;
    return table.slice(0, open)
      + `<table:table-header-rows>${table.slice(open, end)}</table:table-header-rows>`
      + table.slice(end);
  });

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// A table's named style: odf-kit's automatic Table{n} style gets it as its parent, and
// applyNamedStyles defines it in styles.xml. ODF has no banding, so only the name
// travels — the look rides on the cell attrs the style painted.
function applyTableStyleNames(odtBytes: Uint8Array, tables: (TableStyleRef | null)[]): Uint8Array {
  if (tables.every(t => t === null)) return odtBytes;

  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  let nth = 0;
  tables.forEach((ref, i) => {
    if (!ref) return;
    content = content.replace(
      new RegExp(`(<style:style[^>]*style:name="Table${i + 1}")`),
      `$1 style:parent-style-name="${odfStyleName(ref.name)}"`,
    );
  });
  // Which conditional areas the table opts into (ODF's own table:use-*-styles), so the
  // toggles survive a round trip. Lookahead, not \b: a hyphen is a word boundary, so \b
  // would also match <table:table-cell/-row/-column and consume the counter.
  content = content.replace(/<table:table(?=[\s>])[^>]*/g, (tag) => {
    const ref = tables[nth++];
    return ref ? `${tag} ${odfLookAttrs(ref.look)}` : tag;
  });

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// ODF names these per conditional area on <table:table> (§ table template attributes).
export const ODF_LOOK_ATTRS: Record<TableRegion, string> = {
  headerRow: 'table:use-first-row-styles',
  lastRow: 'table:use-last-row-styles',
  firstColumn: 'table:use-first-column-styles',
  lastColumn: 'table:use-last-column-styles',
  bandedRow: 'table:use-banding-rows-styles',
  bandedColumn: 'table:use-banding-columns-styles',
};

function odfLookAttrs(look: TableLook): string {
  return TABLE_REGIONS.map(r => `${ODF_LOOK_ATTRS[r]}="${look[r]}"`).join(' ');
}

// odf-kit's ListBuilder has no per-item paragraph options, so list-item paragraphs all
// emit as List_20_Bullet/Number. Rewrite content.xml to point those at automatic styles
// that inherit the list style and add fo:text-align / fo:margin-top / fo:margin-bottom.
function applyListItemStyles(odtBytes: Uint8Array, styles: ParaStyle[]): Uint8Array {
  if (styles.every(paraStyleIsEmpty)) return odtBytes;

  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  const styleDefs: { name: string; parent: string; style: ParaStyle }[] = [];
  const nameByKey = new Map<string, string>();
  let counter = 0;
  let idx = 0;

  // Each text:list-item directly contains the item's paragraph as its first child;
  // the item tag may carry attributes (applyListStartValues adds text:start-value).
  content = content.replace(
    /(<text:list-item[^>]*>\s*<text:p text:style-name=")(List_20_Bullet|List_20_Number)(")/g,
    (_match, pre, parentStyle, post) => {
      const style = styles[idx++];
      if (!style || paraStyleIsEmpty(style)) return `${pre}${parentStyle}${post}`;
      // Key on the emitted properties, so the key can never lag behind ParaStyle's fields.
      const key = `${parentStyle}|${paraStyleProps(style).join('|')}`;
      let name = nameByKey.get(key);
      if (!name) {
        counter++;
        name = `LP${counter}`;
        nameByKey.set(key, name);
        styleDefs.push({ name, parent: parentStyle, style });
      }
      return `${pre}${name}${post}`;
    },
  );

  if (styleDefs.length === 0) return odtBytes;

  const newStyles = styleDefs.map(({ name, parent, style }) =>
    `<style:style style:name="${name}" style:family="paragraph" style:parent-style-name="${parent}"><style:paragraph-properties ${paraStyleProps(style).join(' ')}/></style:style>`,
  ).join('\n');

  content = injectAutomaticStyles(content, `${newStyles}\n`);

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// The whole <style:style …>…</style:style> (or self-closing) for an automatic style by
// name from content.xml. null when the name is a common/named style (defined in
// styles.xml), so applyPageBreaks mints a child of it instead of cloning.
function findAutoStyle(content: string, name: string): string | null {
  const open = content.indexOf(`<style:style style:name="${name}"`);
  if (open < 0) return null;
  const gt = content.indexOf('>', open);
  if (gt < 0) return null;
  if (content[gt - 1] === '/') return content.slice(open, gt + 1);
  const closeTag = '</style:style>';
  const close = content.indexOf(closeTag, gt);
  if (close < 0) return null;
  return content.slice(open, close + closeTag.length);
}

// Clone a <style:style> definition under newName, ensuring its paragraph-properties
// carry fo:break-before="page" (paragraph-properties precedes text-properties in ODF, so
// a freshly inserted one stays first child).
function cloneStyleWithBreak(def: string, newName: string): string {
  const s = def.replace(/style:name="[^"]*"/, `style:name="${newName}"`);
  if (/fo:break-before=/.test(s)) return s;
  const pp = '<style:paragraph-properties fo:break-before="page"/>';
  if (/^<style:style\b[^>]*\/>\s*$/.test(s)) {
    return s.replace(/\/>\s*$/, `>${pp}</style:style>`);
  }
  if (/<style:paragraph-properties\b[^>]*\/>/.test(s)) {
    return s.replace(/<style:paragraph-properties\b([^>]*?)\s*\/>/, '<style:paragraph-properties$1 fo:break-before="page"/>');
  }
  if (/<style:paragraph-properties\b/.test(s)) {
    return s.replace(/<style:paragraph-properties\b([^>]*)>/, '<style:paragraph-properties$1 fo:break-before="page">');
  }
  return s.replace(/(<style:style\b[^>]*[^/]>)/, `$1${pp}`);
}

// Resolve PGB sentinels: per source style, mint a fo:break-before="page" paragraph style
// (cloning its props so blocks sharing the style aren't affected, reused across blocks),
// reassign each marked block's style-name, and strip the sentinel.
function applyPageBreaks(odtBytes: Uint8Array): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  if (!content.includes(PGB)) return odtBytes;

  const minted: string[] = [];
  const nameBySource = new Map<string, string>();
  let counter = 0;

  const breakStyleFor = (source: string): string => {
    const existing = nameBySource.get(source);
    if (existing) return existing;
    // PBK, not PB: applyParagraphBoxes mints PB names, and a duplicate style:name
    // makes the importer resolve both paragraphs to whichever definition it finds.
    const name = `PBK${++counter}`;
    nameBySource.set(source, name);
    const def = source ? findAutoStyle(content, source) : null;
    minted.push(def
      ? cloneStyleWithBreak(def, name)
      : `<style:style style:name="${name}" style:family="paragraph" style:parent-style-name="${source || 'Standard'}"><style:paragraph-properties fo:break-before="page"/></style:style>`,
    );
    return name;
  };

  // The sentinel sits anywhere in the block: a custom paragraph's serialized text
  // starts with the FSZ/STY/PBX payloads (their passes run later), then the PGB.
  content = content.replace(
    new RegExp(`<text:(p|h)\\b((?:[^>]*[^/>])?)>([\\s\\S]*?)</text:\\1>`, 'g'),
    (m, tag: string, attrs: string, inner: string) => {
      if (!inner.includes(PGB)) return m;
      const sm = /text:style-name="([^"]*)"/.exec(attrs);
      const name = breakStyleFor(sm ? sm[1] : '');
      const newAttrs = sm
        ? attrs.replace(/text:style-name="[^"]*"/, `text:style-name="${name}"`)
        : ` text:style-name="${name}"${attrs}`;
      return `<text:${tag}${newAttrs}>${inner.split(PGB).join('')}</text:${tag}>`;
    },
  );
  // Drop any sentinels not consumed above (defensive — never legitimate text).
  content = content.split(PGB).join('');

  if (minted.length) {
    content = injectAutomaticStyles(content, minted.join(''));
  }

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// The paragraph mark's font as an FSZ payload ("<size>|<family>", either half empty).
function markFontPayload(attrs: TiptapNode['attrs']): string {
  const size = typeof attrs?.fontSize === 'string' ? attrs.fontSize : '';
  const family = typeof attrs?.fontFamily === 'string' ? attrs.fontFamily : '';
  return size || family ? `${size}|${family}` : '';
}

// The paragraph style's own text properties for that payload (+ asian/complex aliases).
function fontSizeProps(payload: string): string {
  const [size, family] = payload.split('|');
  const font = family ? twinFontName(family) : '';
  return [
    size ? `fo:font-size="${size}" style:font-size-asian="${size}" style:font-size-complex="${size}"` : '',
    font ? `style:font-name="${font}" style:font-name-asian="${font}" style:font-name-complex="${font}"` : '',
  ].filter(Boolean).join(' ');
}

// Clone a <style:style> def under newName, adding fo:font-size to its text-properties.
function cloneStyleWithFontSize(def: string, newName: string, size: string): string {
  const s = def.replace(/style:name="[^"]*"/, `style:name="${newName}"`);
  const props = fontSizeProps(size);
  if (/<style:text-properties\b[^>]*\/>/.test(s)) {
    return s.replace(/<style:text-properties\b([^>]*?)\s*\/>/, `<style:text-properties$1 ${props}/>`);
  }
  if (/<style:text-properties\b/.test(s)) {
    return s.replace(/<style:text-properties\b([^>]*)>/, `<style:text-properties$1 ${props}>`);
  }
  if (/^<style:style\b[^>]*\/>\s*$/.test(s)) {
    return s.replace(/\s*\/>\s*$/, `><style:text-properties ${props}/></style:style>`);
  }
  return s.replace('</style:style>', `<style:text-properties ${props}/></style:style>`);
}

// Resolve FSZ sentinels (empty-line font size): per (source style, size) mint a style
// cloning the source's props plus that fo:font-size, reassign the block's style-name,
// and strip the sentinel. Mirrors applyPageBreaks.
function applyEmptyLineFontSizes(odtBytes: Uint8Array): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  if (!content.includes(FSZ)) return odtBytes;

  const minted: string[] = [];
  const nameByKey = new Map<string, string>();
  let counter = 0;

  const sizeStyleFor = (source: string, size: string): string => {
    const key = `${source}|${size}`;
    const existing = nameByKey.get(key);
    if (existing) return existing;
    const name = `EF${++counter}`;
    nameByKey.set(key, name);
    const def = source ? findAutoStyle(content, source) : null;
    minted.push(def
      ? cloneStyleWithFontSize(def, name, size)
      : `<style:style style:name="${name}" style:family="paragraph" style:parent-style-name="${source || 'Standard'}"><style:text-properties ${fontSizeProps(size)}/></style:style>`,
    );
    return name;
  };

  content = content.replace(
    new RegExp(`<text:(p|h)\\b([^>]*)>${FSZ}([^${FSZ}]*)${FSZ}`, 'g'),
    (_m, tag: string, attrs: string, size: string) => {
      const sm = /text:style-name="([^"]*)"/.exec(attrs);
      const name = sizeStyleFor(sm ? sm[1] : '', size);
      const newAttrs = sm
        ? attrs.replace(/text:style-name="[^"]*"/, `text:style-name="${name}"`)
        : ` text:style-name="${name}"${attrs}`;
      return `<text:${tag}${newAttrs}>`;
    },
  );
  // Drop any sentinels not consumed above (defensive — never legitimate text).
  content = content.replace(new RegExp(`${FSZ}[^${FSZ}]*${FSZ}`, 'g'), '');

  if (minted.length) {
    content = injectAutomaticStyles(content, minted.join(''));
  }

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// A top-level paragraph's box spec for the PBX sentinel: bg|borderTop|Right|Bottom|Left,
// each the raw value (canonical border '<W>pt solid #RRGGBB' is a valid fo:border) or '',
// then a widow flag, the right indent, a keep-with-next flag, the writing mode and a
// no-hyphenation flag. '' when it needs none.
function paraBoxSpec(attrs: TiptapNode['attrs']): string {
  const s = paraStyleFromAttrs(attrs);
  const noWidow = attrs?.widowControl === false;
  const keepNext = attrs?.keepNext === true;
  const keepLines = attrs?.keepLines === true;
  const noHyphen = attrs?.noHyphenation === true;
  // odf-kit has a paragraph option for the left indent but none for the right one.
  const right = typeof attrs?.indentRight === 'number' && attrs.indentRight > 0 ? attrs.indentRight : 0;
  const wm = writingModeOf(s.dir);
  if (!s.background && !s.borderTop && !s.borderRight && !s.borderBottom && !s.borderLeft && !noWidow && !right && !keepNext && !keepLines && !wm && !noHyphen) return '';
  return [s.background, s.borderTop, s.borderRight, s.borderBottom, s.borderLeft]
    .map((v) => v ?? '')
    .concat(noWidow ? 'w0' : '', right ? `${right}cm` : '', keepNext ? 'k1' : '', keepLines ? 'g1' : '', wm ?? '', noHyphen ? 'h0' : '').join('|');
}

function boxSpecToProps(spec: string): string {
  const [bg, bt, br, bb, bl, widow, marginRight, keepNext, keepLines, writingMode] = spec.split('|');
  const props: string[] = [];
  if (bg) props.push(`fo:background-color="${bg}"`);
  if (bt) props.push(`fo:border-top="${bt}"`);
  if (br) props.push(`fo:border-right="${br}"`);
  if (bb) props.push(`fo:border-bottom="${bb}"`);
  if (bl) props.push(`fo:border-left="${bl}"`);
  // LibreOffice writes 0/0 for "off"; absent means the XSL-FO default of 2.
  if (widow === 'w0') props.push('fo:orphans="0"', 'fo:widows="0"');
  if (marginRight) props.push(`fo:margin-right="${marginRight}"`);
  if (keepNext === 'k1') props.push('fo:keep-with-next="always"');
  if (keepLines === 'g1') props.push('fo:keep-together="always"');
  if (writingMode) props.push(`style:writing-mode="${writingMode}"`);
  return props.join(' ');
}

// Add fo:* into a cloned style's <style:paragraph-properties> (which precedes text-props
// in ODF). Mirrors cloneStyleWithFontSize but for paragraph-properties.
function cloneStyleWithParaProps(def: string, newName: string, props: string): string {
  const s = def.replace(/style:name="[^"]*"/, `style:name="${newName}"`);
  if (!props) return s;
  if (/<style:paragraph-properties\b[^>]*\/>/.test(s))
    return s.replace(/<style:paragraph-properties\b([^>]*?)\s*\/>/, `<style:paragraph-properties$1 ${props}/>`);
  if (/<style:paragraph-properties\b/.test(s))
    return s.replace(/<style:paragraph-properties\b([^>]*)>/, `<style:paragraph-properties$1 ${props}>`);
  if (/^<style:style\b[^>]*\/>\s*$/.test(s))
    return s.replace(/\s*\/>\s*$/, `><style:paragraph-properties ${props}/></style:style>`);
  if (/<style:text-properties\b/.test(s))
    return s.replace(/<style:text-properties\b/, `<style:paragraph-properties ${props}/><style:text-properties`);
  return s.replace('</style:style>', `<style:paragraph-properties ${props}/></style:style>`);
}

// ---- named paragraph styles (styles/styleSheet.ts) --------------------------------

// Set or replace attributes on an element's opening tag.
function setTagAttrs(tag: string, attrs: Record<string, string>): string {
  let out = tag;
  for (const [name, value] of Object.entries(attrs)) {
    const re = new RegExp(`\\s${name}="[^"]*"`);
    out = re.test(out)
      ? out.replace(re, ` ${name}="${value}"`)
      : out.replace(/(\/?>)$/, ` ${name}="${value}"$1`);
  }
  return out;
}

// Merge attributes into a style's <style:paragraph-properties>/<style:text-properties>,
// keeping whatever the producer already put there (language, keep-with-next, …).
function upsertProps(block: string, kind: 'paragraph' | 'text', attrs: Record<string, string>): string {
  if (!Object.keys(attrs).length) return block;
  const el = `style:${kind}-properties`;
  const open = new RegExp(`<${el}\\b[^>]*>`);
  const m = open.exec(block);
  if (m) return block.replace(open, setTagAttrs(m[0], attrs));
  const props = setTagAttrs(`<${el}/>`, attrs);
  // paragraph-properties precedes text-properties in ODF.
  if (kind === 'paragraph' && block.includes('<style:text-properties'))
    return block.replace('<style:text-properties', `${props}<style:text-properties`);
  if (/^<style:style\b[^>]*\/>$/.test(block.trim()))
    return block.trim().replace(/\/>$/, `>${props}</style:style>`);
  return block.replace('</style:style>', `${props}</style:style>`);
}

// A style's OWN properties as ODF attributes — the chain stays a chain in the file,
// so only what the style itself declares is written.
function ownStyleAttrs(style: { para: Record<string, unknown>; text: Record<string, unknown> }) {
  const p = style.para as Record<string, string | number | undefined>;
  const t = style.text as Record<string, string | number | boolean | undefined>;
  const para: Record<string, string> = {};
  if (p.textAlign) para['fo:text-align'] = String(p.textAlign);
  if (p.lineHeight != null) para['fo:line-height'] = normalizeLineHeight(p.lineHeight as string | number);
  if (p.spaceBefore != null) para['fo:margin-top'] = `${p.spaceBefore}pt`;
  if (p.spaceAfter != null) para['fo:margin-bottom'] = `${p.spaceAfter}pt`;
  if (p.indent != null) para['fo:margin-left'] = `${p.indent}cm`;
  if (p.backgroundColor) para['fo:background-color'] = String(p.backgroundColor);
  for (const [key, side] of [['borderTop', 'top'], ['borderRight', 'right'], ['borderBottom', 'bottom'], ['borderLeft', 'left']] as const) {
    const v = p[key];
    if (!v || v === 'none') continue;
    para[`fo:border-${side}`] = String(v);
    // The gap to the rule, on the ruled sides only — fo:padding would ring the block.
    if (p.borderPadding != null) para[`fo:padding-${side}`] = `${p.borderPadding}pt`;
  }
  const text: Record<string, string> = {};
  if (t.fontFamily) {
    // The registry holds the on-screen family; the file declares its metric twin.
    const font = twinFontName(String(t.fontFamily));
    text['style:font-name'] = font;
    text['style:font-name-asian'] = font;
    text['style:font-name-complex'] = font;
  }
  if (t.fontSizePt != null) {
    const size = `${t.fontSizePt}pt`;
    text['fo:font-size'] = size;
    text['style:font-size-asian'] = size;
    text['style:font-size-complex'] = size;
  }
  if (t.letterSpacingPt) text['fo:letter-spacing'] = `${t.letterSpacingPt}pt`;
  if (t.kerning != null) text['style:letter-kerning'] = String(t.kerning);
  if (t.bold != null) text['fo:font-weight'] = t.bold ? 'bold' : 'normal';
  if (t.italic != null) text['fo:font-style'] = t.italic ? 'italic' : 'normal';
  if (t.underline) text['style:text-underline-style'] = 'solid';
  if (t.strike) text['style:text-line-through-style'] = 'solid';
  if (t.color) text['fo:color'] = String(t.color);
  if (t.caps === 'smallCaps') text['fo:font-variant'] = 'small-caps';
  else if (t.caps) text['fo:text-transform'] = String(t.caps);
  return { para, text };
}

// Attributes the style model owns: dropped from a producer's block before the style's
// own values go in, so anything the style leaves open really comes from its parent.
const MANAGED_STYLE_ATTRS = [
  'fo:margin-top', 'fo:margin-bottom', 'fo:margin-left', 'fo:text-align', 'fo:line-height',
  'fo:background-color', 'fo:border-top', 'fo:border-right', 'fo:border-bottom', 'fo:border-left',
  'fo:font-size', 'style:font-size-asian', 'style:font-size-complex',
  'fo:font-weight', 'style:font-weight-asian', 'style:font-weight-complex',
  'fo:font-style', 'style:font-style-asian', 'style:font-style-complex',
  'style:text-underline-style', 'style:text-line-through-style', 'fo:color',
  'style:font-name', 'style:font-name-asian', 'style:font-name-complex',
];

function stripManagedProps(block: string): string {
  let out = block;
  for (const attr of MANAGED_STYLE_ATTRS) out = out.replace(new RegExp(`\\s${attr}="[^"]*"`, 'g'), '');
  return out;
}

// Write the document's named paragraph styles into styles.xml: merge into the blocks
// odf-kit already emits (Standard, Heading, Heading_20_N), append the rest. The parent
// chain is preserved, so LibreOffice/Word show them as real, inheriting styles.
function applyNamedStyles(styles: string, sheet: StyleSheet, used: Set<string>, usedTables: Set<string> = new Set()): string {
  const added: string[] = [];
  // Table styles: ODF's table family carries no banding, so the name is all that travels
  // (the look is baked into the cells). An empty style block is enough to make it real.
  for (const name of usedTables) {
    const odfName = odfStyleName(name);
    if (findAutoStyle(styles, odfName)) continue;
    added.push(setTagAttrs('<style:style/>', {
      'style:name': odfName, 'style:family': 'table', 'style:display-name': name,
    }));
  }
  // Character styles are the same shape, family "text" and text props only.
  for (const style of Object.values(sheet.character ?? {})) {
    const { text } = ownStyleAttrs(style);
    if (!Object.keys(text).length) continue;
    const odfName = odfStyleName(style.name);
    if (findAutoStyle(styles, odfName)) continue;
    const attrs: Record<string, string> = {
      'style:name': odfName, 'style:family': 'text', 'style:display-name': style.name,
    };
    added.push(upsertProps(`${setTagAttrs('<style:style/>', attrs).replace('/>', '>')}</style:style>`, 'text', text));
  }
  for (const style of Object.values(sheet.paragraph)) {
    if (!used.has(style.name)) continue;
    const odfName = odfStyleName(style.name);
    const { para, text } = ownStyleAttrs(style);
    const existing = findAutoStyle(styles, odfName);
    if (existing) {
      let block = stripManagedProps(existing);
      if (style.parent) block = block.replace(/^<style:style\b[^>]*?(\/?)>/, (tag) =>
        setTagAttrs(tag, { 'style:parent-style-name': odfStyleName(style.parent!) }));
      block = upsertProps(upsertProps(block, 'paragraph', para), 'text', text);
      styles = styles.replace(existing, block);
      continue;
    }
    const attrs: Record<string, string> = {
      'style:name': odfName, 'style:family': 'paragraph', 'style:display-name': style.name,
    };
    if (style.parent) attrs['style:parent-style-name'] = odfStyleName(style.parent);
    if (style.next) attrs['style:next-style-name'] = odfStyleName(style.next);
    let block = `${setTagAttrs('<style:style/>', attrs).replace('/>', '>')}</style:style>`;
    block = upsertProps(upsertProps(block, 'paragraph', para), 'text', text);
    added.push(block);
  }
  return added.length ? styles.replace('</office:styles>', `${added.join('')}</office:styles>`) : styles;
}

// Resolve STY sentinels: point each marked block at its named style — directly when it
// carries no direct formatting, else via a clone of its automatic style whose parent
// becomes the named one (so hard formatting keeps overriding the style, as in LO).
function applyParagraphStyles(odtBytes: Uint8Array): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  if (!content.includes(STY)) return odtBytes;

  const minted: string[] = [];
  const nameByKey = new Map<string, string>();
  let counter = 0;

  const styleFor = (source: string, styleName: string): string => {
    const odfName = odfStyleName(styleName);
    const auto = source ? findAutoStyle(content, source) : null;
    if (!auto) return odfName; // no direct formatting: reference the style itself
    const key = `${source}|${odfName}`;
    const existing = nameByKey.get(key);
    if (existing) return existing;
    const name = `PS${++counter}`;
    nameByKey.set(key, name);
    minted.push(
      auto
        .replace(/style:name="[^"]*"/, `style:name="${name}"`)
        .replace(/^<style:style\b[^>]*?(\/?)>/, (tag) =>
          setTagAttrs(tag, { 'style:parent-style-name': odfName })),
    );
    return name;
  };

  // Anchored right after the opening tag (where the sentinel is emitted): a scan to the
  // closing tag would start at a text box's anchor paragraph and steal the first box
  // child's sentinel — nested <text:p> (box children, note bodies) make spans unsafe.
  content = content.replace(
    new RegExp(`<text:(p|h)\\b((?:[^>]*[^/>])?)>${STY}([^${STY}]*)${STY}`, 'g'),
    (_m, tag: string, attrs: string, styleName: string) => {
      const srcM = /text:style-name="([^"]*)"/.exec(attrs);
      const name = styleFor(srcM ? srcM[1] : '', styleName);
      const newAttrs = srcM
        ? attrs.replace(/text:style-name="[^"]*"/, `text:style-name="${name}"`)
        : ` text:style-name="${name}"${attrs}`;
      return `<text:${tag}${newAttrs}>`;
    },
  );
  content = content.replace(new RegExp(`${STY}[^${STY}]*${STY}`, 'g'), '');

  if (minted.length) {
    content = injectAutomaticStyles(content, minted.join(''));
  }

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Resolve PBX sentinels: per (source style, box spec) mint a paragraph style cloning the
// source plus fo:background-color/fo:border-*, reassign the block, and strip the sentinel.
// Mirrors applyEmptyLineFontSizes; runs after it so an empty line's FSZ is already resolved.
function applyParagraphBoxes(odtBytes: Uint8Array): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  if (!content.includes(PBX)) return odtBytes;

  const minted: string[] = [];
  const nameByKey = new Map<string, string>();
  let counter = 0;

  const boxStyleFor = (source: string, spec: string): string => {
    const key = `${source}|${spec}`;
    const existing = nameByKey.get(key);
    if (existing) return existing;
    const name = `PB${++counter}`;
    nameByKey.set(key, name);
    const props = boxSpecToProps(spec);
    const def = source ? findAutoStyle(content, source) : null;
    let style = def
      ? cloneStyleWithParaProps(def, name, props)
      : `<style:style style:name="${name}" style:family="paragraph" style:parent-style-name="${source || 'Standard'}">${props ? `<style:paragraph-properties ${props}/>` : ''}</style:style>`;
    // ODF counts fo:hyphenate as a *text* property — in paragraph-properties LibreOffice
    // ignores it and drops it on the next save.
    if (spec.split('|')[10] === 'h0') style = upsertProps(style, 'text', { 'fo:hyphenate': 'false' });
    minted.push(style);
    return name;
  };

  // Anchored right after the opening tag, over an optional STY run (its pass runs later;
  // emission order is FSZ STY PBX). A scan to the closing tag would start at a text box's
  // anchor paragraph and steal the first box child's sentinel.
  content = content.replace(
    new RegExp(`<text:(p|h)\\b((?:[^>]*[^/>])?)>((?:${STY}[^${STY}]*${STY})?)${PBX}([^${PBX}]*)${PBX}`, 'g'),
    (_m, tag: string, attrs: string, sty: string, spec: string) => {
      const srcM = /text:style-name="([^"]*)"/.exec(attrs);
      const name = boxStyleFor(srcM ? srcM[1] : '', spec);
      const newAttrs = srcM
        ? attrs.replace(/text:style-name="[^"]*"/, `text:style-name="${name}"`)
        : ` text:style-name="${name}"${attrs}`;
      return `<text:${tag}${newAttrs}>${sty}`;
    },
  );
  // Drop any sentinels not consumed above (defensive — never legitimate text).
  content = content.replace(new RegExp(`${PBX}[^${PBX}]*${PBX}`, 'g'), '');

  if (minted.length) {
    content = injectAutomaticStyles(content, minted.join(''));
  }

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// odf-kit always emits ordered lists as "1." at every level. This rewrites the
// matching L# list style per level: the depth-default cycle (1. → a. → i.), explicit
// listStyleType attrs, or the multilevel chain (decimal + text:display-levels).
type OrderedFmt = { numFormat: string; numSuffix: string };
type OlStyleFix = { fmts: OrderedFmt[]; multilevel: boolean };

const DEFAULT_ORDERED_FMTS: OrderedFmt[] = Array.from({ length: 6 }, (_, i) => {
  const d = effectiveOrderedDef(null, i);
  return { numFormat: d.numFormat, numSuffix: d.numSuffix };
});
const MULTILEVEL_FMTS: OrderedFmt[] = Array.from({ length: 6 }, () => ({ numFormat: '1', numSuffix: '.' }));

// Effective numbering of an ordered list at a cycle position: its attr, else the
// cycle default (re-anchoring slot + suffix at explicit styles; 'multilevel' handled
// by the callers).
function effOrderedFmt(list: TiptapNode, cycle: OrderedCycle): OrderedFmt {
  const key = list.attrs?.listStyleType as string | null | undefined;
  const def = effectiveOrderedDefAt(key === 'multilevel' ? 'decimal' : key, cycle);
  return { numFormat: def.numFormat, numSuffix: def.numSuffix };
}

// Per-level numbering for a list subtree — same DFS-first model as bulletCharVector,
// threading each list's cycle position down so nested defaults advance past their parent.
function orderedFmtVector(list: TiptapNode, startDepth: number, base: OrderedFmt[], startCycle: OrderedCycle): OrderedFmt[] {
  const vec = [...base];
  const seen = new Set<number>();
  const walk = (node: TiptapNode, depth: number, cycle: OrderedCycle) => {
    if (depth > vec.length) return;
    if (node.type === 'orderedList' && !seen.has(depth)) {
      seen.add(depth);
      vec[depth - 1] = effOrderedFmt(node, cycle);
    }
    const cChild = childCycle(cycle, node.attrs?.listStyleType as string | null | undefined, node.type === 'orderedList');
    for (const item of node.content ?? []) {
      if (item.type !== 'listItem') continue;
      for (const child of item.content ?? []) {
        if (child.type === 'bulletList' || child.type === 'orderedList') walk(child, depth + 1, cChild);
      }
    }
  };
  walk(list, startDepth, startCycle);
  return vec;
}

function collectOrderedListFormats(node: TiptapNode, result: (OlStyleFix | null)[]): void {
  for (const child of node.content ?? []) {
    if (child.type === 'bulletList') {
      result.push(null);
    } else if (child.type === 'orderedList') {
      if (child.attrs?.listStyleType === 'multilevel') {
        result.push({ fmts: MULTILEVEL_FMTS, multilevel: true });
      } else {
        const vec = orderedFmtVector(child, 1, DEFAULT_ORDERED_FMTS, ROOT_ORDERED_CYCLE);
        // odf-kit's own output is all-decimal; only an all-"1." vector needs no rewrite.
        result.push(vec.every(f => f.numFormat === '1' && f.numSuffix === '.') ? null : { fmts: vec, multilevel: false });
      }
    }
  }
}

function applyOrderedListFormats(odtBytes: Uint8Array, formats: (OlStyleFix | null)[]): Uint8Array {
  if (formats.every(f => f === null)) return odtBytes;

  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  formats.forEach((fix, i) => {
    if (!fix) return;
    // Rewrite only inside this list's own <text:list-style> block, level by level.
    const re = new RegExp(`(<text:list-style style:name="L${i + 1}">)([\\s\\S]*?)(</text:list-style>)`);
    content = content.replace(re, (_m, open: string, body: string, close: string) =>
      open +
      body.replace(
        /(<text:list-level-style-number text:level=")(\d)(" style:num-format=")[^"]*(" style:num-suffix=")[^"]*(")/g,
        (_mm, a: string, lvl: string, b: string, c: string, d: string) => {
          const f = fix.fmts[+lvl - 1] ?? DEFAULT_ORDERED_FMTS[+lvl - 1];
          const disp = fix.multilevel && +lvl > 1 ? ` text:display-levels="${lvl}"` : '';
          return a + lvl + b + f.numFormat + c + f.numSuffix + d + disp;
        },
      ) +
      close,
    );
  });

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// One slot per top-level list (matching odf-kit's L# order): an ordered list's
// start value when >1 (a continued Word list), else null.
function collectListStartValues(node: TiptapNode, result: (number | null)[]): void {
  for (const child of node.content ?? []) {
    if (child.type === 'bulletList') {
      result.push(null);
    } else if (child.type === 'orderedList') {
      const s = child.attrs?.start;
      result.push(typeof s === 'number' && s > 1 ? s : null);
    }
  }
}

// odf-kit drops the ordered-list `start` attr, so a list continued across an intervening
// paragraph would restart at 1. Add text:start-value to each such list's first item.
function applyListStartValues(odtBytes: Uint8Array, starts: (number | null)[]): Uint8Array {
  if (starts.every(s => s === null)) return odtBytes;

  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  starts.forEach((start, i) => {
    if (start == null) return;
    const re = new RegExp(`(<text:list text:style-name="L${i + 1}"[^>]*>\\s*<text:list-item)>`);
    content = content.replace(re, `$1 text:start-value="${start}">`);
  });

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Effective marker char of a bullet list at a 1-based depth: its bulletChar attr,
// else the default cycle.
function effBulletChar(list: TiptapNode, depth: number): string {
  const ch = list.attrs?.bulletChar;
  return typeof ch === 'string' && ch ? ch : defaultBulletChar(depth - 1);
}

// Per-level marker chars for a list subtree: slot d-1 = the DFS-first bullet list
// at depth d (one list style governs the whole tree, so the first list met at a depth
// defines that level; differing siblings get NL mints; unvisited depths keep `base`).
function bulletCharVector(list: TiptapNode, startDepth: number, base: string[]): string[] {
  const vec = [...base];
  const seen = new Set<number>();
  const walk = (node: TiptapNode, depth: number) => {
    if (depth > vec.length) return;
    if (node.type === 'bulletList' && !seen.has(depth)) {
      seen.add(depth);
      vec[depth - 1] = effBulletChar(node, depth);
    }
    for (const item of node.content ?? []) {
      if (item.type !== 'listItem') continue;
      for (const child of item.content ?? []) {
        if (child.type === 'bulletList' || child.type === 'orderedList') walk(child, depth + 1);
      }
    }
  };
  walk(list, startDepth);
  return vec;
}

// odf-kit emits every bullet level with the default cycle char. This rewrites the
// matching L# list style to the per-level chars of the user's bulletChar attrs;
// chars[] has one entry per top-level list (null = ordered or all-default).
function collectBulletListChars(node: TiptapNode, result: (string[] | null)[]): void {
  for (const child of node.content ?? []) {
    if (child.type === 'orderedList') {
      result.push(null);
    } else if (child.type === 'bulletList') {
      const vec = bulletCharVector(child, 1, DEFAULT_BULLET_CYCLE);
      result.push(vec.every((c, i) => c === DEFAULT_BULLET_CYCLE[i]) ? null : vec);
    }
  }
}

function applyBulletListChars(odtBytes: Uint8Array, chars: (string[] | null)[]): Uint8Array {
  if (chars.every(c => c === null)) return odtBytes;

  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  chars.forEach((vec, i) => {
    if (!vec) return;
    // Rewrite only inside this list's own <text:list-style> block (all 6 levels).
    const re = new RegExp(`(<text:list-style style:name="L${i + 1}">)([\\s\\S]*?)(</text:list-style>)`);
    content = content.replace(re, (_m, open: string, body: string, close: string) =>
      open +
      body.replace(
        /(<text:list-level-style-bullet text:level=")(\d)(" text:bullet-char=")[^"]*(")/g,
        (_mm, a: string, lvl: string, b: string, c: string) => a + lvl + b + (vec[+lvl - 1] ?? defaultBulletChar(+lvl - 1)) + c,
      ) +
      close,
    );
  });

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Per-level indent (cm) and label alignment of each top-level list, from the first list
// at that level. odf-kit uses label-alignment mode (which ignores the paragraph margin),
// so both go onto the L# list-style's own level definitions.
type ListLevelProps = { indent: number; right: boolean };

function collectListLevelProps(node: TiptapNode, result: ListLevelProps[][]): void {
  for (const child of node.content ?? []) {
    if (child.type !== 'bulletList' && child.type !== 'orderedList') continue;
    const levels: ListLevelProps[] = [];
    const visit = (list: TiptapNode, depth: number) => {
      const ind = list.attrs?.indent;
      if (levels[depth - 1] === undefined) {
        levels[depth - 1] = { indent: typeof ind === 'number' ? ind : 0, right: list.attrs?.markerAlign === 'right' };
      }
      for (const item of list.content ?? []) {
        for (const block of item.content ?? []) {
          if (block.type === 'bulletList' || block.type === 'orderedList') visit(block, depth + 1);
        }
      }
    };
    visit(child, 1);
    result.push(levels);
  }
}

function applyListLevelProps(odtBytes: Uint8Array, props: ListLevelProps[][]): Uint8Array {
  const plain = (l: ListLevelProps) => !l?.indent && !l?.right;
  if (props.every(levels => levels.every(plain))) return odtBytes;

  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  const bump = (cm: number) => (_m: string, attr: string, v: string) =>
    `${attr}="${(parseFloat(v) + cm).toFixed(3)}cm"`;
  // The editor nests the levels, so a level's margin grows by every indent above it too.
  const rewriteLevels = (body: string, levels: ListLevelProps[]) =>
    body.replace(/<text:list-level-style-[a-z]+[\s\S]*?(?=<text:list-level-style-|$)/g, (lvl) => {
      const n = parseInt(/text:level="(\d+)"/.exec(lvl)?.[1] ?? '', 10);
      if (!Number.isFinite(n)) return lvl;
      const cm = levels.slice(0, n).reduce((a, b) => a + (b?.indent || 0), 0);
      const shifted = cm
        ? lvl.replace(/(fo:margin-left)="([\d.]+)cm"/g, bump(cm))
             .replace(/(text:list-tab-stop-position)="([\d.]+)cm"/g, bump(cm))
        : lvl;
      return levels[n - 1]?.right
        ? shifted.replace('<style:list-level-properties ', '<style:list-level-properties fo:text-align="end" ')
        : shifted;
    });

  props.forEach((levels, i) => {
    if (levels.every(plain)) return;
    const re = new RegExp(`(<text:list-style style:name="L${i + 1}">)([\\s\\S]*?)(</text:list-style>)`);
    content = content.replace(re, (_m, open: string, body: string, close: string) =>
      open + rewriteLevels(body, levels) + close);
  });

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Marker formatting per nesting level of each top-level list, from the first list at
// that level (null unless its items agree — see listMarkerFormat). Nested lists that
// odf-kit restyles keep their plain marker.
function collectListMarkerFormats(doc: TiptapNode, result: (MarkerFormat | null)[][]): void {
  for (const child of doc.content ?? []) {
    if (child.type !== 'bulletList' && child.type !== 'orderedList') continue;
    const levels: (MarkerFormat | null)[] = [];
    const visit = (list: TiptapNode, depth: number) => {
      if (levels[depth - 1] === undefined) levels[depth - 1] = listMarkerFormat(list, charStyleProps(exportSheet));
      for (const item of list.content ?? []) {
        for (const block of item.content ?? []) {
          if (block.type === 'bulletList' || block.type === 'orderedList') visit(block, depth + 1);
        }
      }
    };
    visit(child, 1);
    result.push(levels);
  }
}

// text:style-name on the level definition points at a style:family="text" style — how
// ODF formats a number/bullet. It has to be a **named** style in styles.xml:
// LibreOffice ignores the reference when it resolves to an automatic one (probed).
function applyListMarkerFormats(odtBytes: Uint8Array, formats: (MarkerFormat | null)[][]): Uint8Array {
  if (!formats.some((levels) => levels.some(Boolean))) return odtBytes;

  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  const stylesBytes = files['styles.xml'];
  if (!contentBytes || !stylesBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  const minted: string[] = [];
  const nameByProps = new Map<string, string>();
  const styleFor = (format: MarkerFormat): string => {
    const color = format.color ? normalizeColor(format.color) : undefined;
    const props = (format.fontFamily ? ` fo:font-family="${twinFontName(format.fontFamily)}"` : '')
      + (format.fontWeight ? ` fo:font-weight="${format.fontWeight}"` : '')
      + (format.fontStyle ? ` fo:font-style="${format.fontStyle}"` : '')
      + (format.fontSize ? ` fo:font-size="${format.fontSize}"` : '')
      + (color ? ` fo:color="${color}"` : '');
    let name = nameByProps.get(props);
    if (!name) {
      name = `MK${nameByProps.size + 1}`;
      nameByProps.set(props, name);
      minted.push(`<style:style style:name="${name}" style:family="text"><style:text-properties${props}/></style:style>`);
    }
    return name;
  };

  formats.forEach((levels, i) => {
    if (!levels.some(Boolean)) return;
    const re = new RegExp(`(<text:list-style style:name="L${i + 1}">)([\\s\\S]*?)(</text:list-style>)`);
    content = content.replace(re, (_m, open: string, body: string, close: string) =>
      open +
      body.replace(/<text:list-level-style-(number|bullet) text:level="(\d)"/g, (match, kind: string, level: string) => {
        const format = levels[Number(level) - 1];
        return format ? `<text:list-level-style-${kind} text:level="${level}" text:style-name="${styleFor(format)}"` : match;
      }) +
      close,
    );
  });

  if (minted.length) {
    files['styles.xml'] = strToU8(
      strFromU8(stylesBytes).replace('</office:styles>', `${minted.join('\n')}\n</office:styles>`),
    );
  }
  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// odf-kit emits nested lists as bare <text:list> sharing the top-level L# style, so a
// nested list of a different kind/format/marker loses its look. Mint it its own
// 6-level list style (same pattern applyCellBlocks uses for cell lists).
type ListDef = { ordered: boolean; multilevel: boolean; fmts: OrderedFmt[]; bulletChars: string[] };

function listDefOf(node: TiptapNode, depth: number, cycle: OrderedCycle, baseChars: string[], baseFmts: OrderedFmt[]): ListDef {
  const multilevel = node.attrs?.listStyleType === 'multilevel';
  return {
    ordered: node.type === 'orderedList',
    multilevel,
    fmts: multilevel ? MULTILEVEL_FMTS : orderedFmtVector(node, depth, baseFmts, cycle),
    bulletChars: bulletCharVector(node, depth, baseChars),
  };
}

// One entry per nested <text:list> in DFS order (null = inherits its governing
// style correctly). Only walks top-level lists — cell lists never emit bare tags.
function collectNestedListFixes(doc: TiptapNode, result: (ListDef | null)[]): void {
  const walkList = (list: TiptapNode, governing: ListDef, isTop: boolean, depth: number, cycle: OrderedCycle) => {
    let gov = governing;
    if (!isTop) {
      const ordered = list.type === 'orderedList';
      let differs: boolean;
      if (ordered !== governing.ordered) {
        differs = true;
      } else if (!ordered) {
        differs = effBulletChar(list, depth) !== governing.bulletChars[(depth - 1) % governing.bulletChars.length];
      } else if (governing.multilevel) {
        // Attr-less lists inherit the chain; only an explicit style breaks out.
        const attr = list.attrs?.listStyleType;
        differs = !!attr && attr !== 'multilevel';
      } else {
        const f = effOrderedFmt(list, cycle);
        const g = governing.fmts[(depth - 1) % governing.fmts.length];
        differs = f.numFormat !== g.numFormat || f.numSuffix !== g.numSuffix;
      }
      const def = differs ? listDefOf(list, depth, cycle, governing.bulletChars, governing.fmts) : null;
      result.push(def);
      if (def) gov = def; // restyled list governs its own descendants
    }
    const cChild = childCycle(cycle, list.attrs?.listStyleType as string | null | undefined, list.type === 'orderedList');
    for (const item of list.content ?? []) {
      if (item.type !== 'listItem') continue;
      for (const child of item.content ?? []) {
        if (child.type === 'bulletList' || child.type === 'orderedList') walkList(child, gov, false, depth + 1, cChild);
      }
    }
  };
  for (const child of doc.content ?? []) {
    if (child.type === 'bulletList' || child.type === 'orderedList') {
      walkList(child, listDefOf(child, 1, ROOT_ORDERED_CYCLE, DEFAULT_BULLET_CYCLE, DEFAULT_ORDERED_FMTS), true, 1, ROOT_ORDERED_CYCLE);
    }
  }
}

function applyNestedListTypes(odtBytes: Uint8Array, fixes: (ListDef | null)[]): Uint8Array {
  if (fixes.every(f => f === null)) return odtBytes;

  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  const minted: string[] = [];
  const nameByKey = new Map<string, string>();
  const styleFor = (fix: ListDef): string => {
    const key = fix.ordered
      ? `o|${fix.multilevel ? 'M' : ''}|${fix.fmts.map(f => f.numFormat + f.numSuffix).join('')}`
      : `b|${fix.bulletChars.join('')}`;
    let name = nameByKey.get(key);
    if (!name) {
      name = `NL${nameByKey.size + 1}`;
      nameByKey.set(key, name);
      minted.push(buildCellListStyle(name, fix.ordered, { fmts: fix.fmts, multilevel: fix.multilevel, bulletChars: fix.bulletChars }));
    }
    return name;
  };

  // Bare <text:list> tags are exactly odf-kit's nested lists, in DFS order.
  let idx = 0;
  content = content.replace(/<text:list>/g, (match) => {
    const fix = fixes[idx++];
    return fix ? `<text:list text:style-name="${styleFor(fix)}">` : match;
  });

  if (minted.length) {
    content = injectAutomaticStyles(content, `${minted.join('\n')}\n`);
  }
  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Mirror odf-kit's buildListStyle (content.js) for the automatic list style our
// in-cell lists reference. Six nesting levels with the given bullet chars /
// indents / numbering, so cell lists match the editor's top-level lists.
function buildCellListStyle(
  styleName: string,
  ordered: boolean,
  opts: { fmts?: OrderedFmt[]; multilevel?: boolean; bulletChars?: string[] } = {},
): string {
  const fmts = opts.multilevel ? MULTILEVEL_FMTS : opts.fmts ?? MULTILEVEL_FMTS;
  const bulletChars = opts.bulletChars ?? DEFAULT_BULLET_CYCLE;
  let levels = '';
  for (let level = 1; level <= 6; level++) {
    const indent = level * 0.635;
    const marginLeft = `${(indent * 2).toFixed(3)}cm`;
    const textIndent = `-${indent.toFixed(3)}cm`;
    const labelAlign = `<style:list-level-properties text:list-level-position-and-space-mode="label-alignment"><style:list-level-label-alignment text:label-followed-by="listtab" text:list-tab-stop-position="${marginLeft}" fo:text-indent="${textIndent}" fo:margin-left="${marginLeft}"/></style:list-level-properties>`;
    if (ordered) {
      const f = fmts[(level - 1) % fmts.length];
      const disp = opts.multilevel && level > 1 ? ` text:display-levels="${level}"` : '';
      levels += `<text:list-level-style-number text:level="${level}" style:num-format="${f.numFormat}" style:num-suffix="${f.numSuffix}"${disp}>${labelAlign}</text:list-level-style-number>`;
    } else {
      const ch = bulletChars[(level - 1) % bulletChars.length];
      levels += `<text:list-level-style-bullet text:level="${level}" text:bullet-char="${ch}">${labelAlign}</text:list-level-style-bullet>`;
    }
  }
  return `<text:list-style style:name="${styleName}">${levels}</text:list-style>`;
}

// odf-kit serializes every cell to a single <text:p> of runs (no API for headings,
// lists, or multiple paragraphs). exportTable emits a cell's content into that paragraph
// SEG-separated; this pass splits on SEG and rebuilds real <text:h>/<text:p>/<text:list>.

// Ordering: after applyListItemStyles (so it sees only top-level list items, not cell
// lists) and before collapseRunWhitespace (so new in-cell paragraphs get newlines stripped).
function applyCellBlocks(odtBytes: Uint8Array, cellBlocks: CellBlock[][]): Uint8Array {
  const needsWork = (blocks: CellBlock[]): boolean => {
    if (blocks.length !== 1) return true;
    const b = blocks[0];
    return b.kind !== 'paragraph' || !paraStyleIsEmpty(b.style);
  };
  if (!cellBlocks.some(needsWork)) return odtBytes;

  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);

  // Minted paragraph automatic styles (parent = Standard / Heading_20_N /
  // List_20_*), deduped by parent + properties. An empty ParaStyle reuses the
  // parent directly (no minted style).
  const styleDefs: { name: string; parent: string; style: ParaStyle }[] = [];
  const nameByKey = new Map<string, string>();
  let styleCounter = 0;
  const styleNameFor = (parent: string, style: ParaStyle): string => {
    if (paraStyleIsEmpty(style)) return parent;
    // Key on the emitted properties, so the key can never lag behind ParaStyle's fields.
    const key = `${parent}|${paraStyleProps(style).join('|')}`;
    let name = nameByKey.get(key);
    if (!name) {
      styleCounter++;
      name = `CB${styleCounter}`;
      nameByKey.set(key, name);
      styleDefs.push({ name, parent, style });
    }
    return name;
  };

  let usedBulletList = false;
  // Bullet cell lists with a custom marker char get their own style carrying that
  // char at the list's own nesting depth (each <text:list> references its style
  // directly, so only the level it sits at matters).
  const bulletStyles: { name: string; chars: string[] }[] = [];
  const bulletStyleByKey = new Map<string, string>();
  const bulletStyleFor = (bulletChar: string | null, depth: number): string => {
    const ch = bulletChar ?? defaultBulletChar(depth - 1);
    if (ch === defaultBulletChar(depth - 1)) {
      usedBulletList = true;
      return CELL_LIST_BULLET_STYLE;
    }
    const key = `${ch}|${depth}`;
    let name = bulletStyleByKey.get(key);
    if (!name) {
      name = `${CELL_LIST_BULLET_STYLE}${bulletStyleByKey.size + 1}`;
      bulletStyleByKey.set(key, name);
      const chars = [...DEFAULT_BULLET_CYCLE];
      chars[(depth - 1) % chars.length] = ch;
      bulletStyles.push({ name, chars });
    }
    return name;
  };
  // One minted style per distinct numbering format (first = CELL_LIST_NUMBER_STYLE,
  // further ones counter-suffixed). The multilevel chain shares one style: nested lists
  // reference the same name, and their nesting depth selects the display-levels def.
  const numberStyles: { name: string; numFormat: string; numSuffix: string; multilevel?: boolean }[] = [];
  const numberStyleByKey = new Map<string, string>();
  const numberStyleFor = (numFormat: string, numSuffix: string, multilevel = false): string => {
    const key = multilevel ? 'ML' : `${numFormat}|${numSuffix}`;
    let name = numberStyleByKey.get(key);
    if (!name) {
      name = numberStyleByKey.size === 0 ? CELL_LIST_NUMBER_STYLE : `${CELL_LIST_NUMBER_STYLE}${numberStyleByKey.size}`;
      numberStyleByKey.set(key, name);
      numberStyles.push({ name, numFormat, numSuffix, multilevel });
    }
    return name;
  };

  // Each <text:list> (root or nested) carries its own type-based style-name, so mixed
  // bullet/number nesting renders correctly; indent comes from nesting depth. One
  // segment consumed per list item, DFS order (matching buildCellContent).
  const buildList = (list: CellListBlock, segments: string[], cur: { i: number }, depth = 1, mlGov = false, cycle: OrderedCycle = ROOT_ORDERED_CYCLE): string => {
    const isBullet = !list.ordered;
    const ml = !isBullet && (list.listStyleType === 'multilevel' || (mlGov && !list.listStyleType));
    let listStyle: string;
    if (isBullet) {
      listStyle = bulletStyleFor(list.bulletChar, depth);
    } else if (ml) {
      listStyle = numberStyleFor('1', '.', true);
    } else {
      const def = effectiveOrderedDefAt(list.listStyleType, cycle);
      listStyle = numberStyleFor(def.numFormat, def.numSuffix);
    }
    const cChild = childCycle(cycle, list.listStyleType, list.ordered);
    const paraParent = isBullet ? 'List_20_Bullet' : 'List_20_Number';
    let out = `<text:list text:style-name="${listStyle}">`;
    list.items.forEach((item, idx) => {
      const startAttr = !isBullet && idx === 0 && list.start != null ? ` text:start-value="${list.start}"` : '';
      const seg = segments[cur.i++] ?? '';
      out += `<text:list-item${startAttr}><text:p text:style-name="${styleNameFor(paraParent, item.style)}">${seg}</text:p>`;
      if (item.nested) out += buildList(item.nested, segments, cur, depth + 1, ml, cChild);
      out += '</text:list-item>';
    });
    return out + '</text:list>';
  };

  const buildBlocks = (blocks: CellBlock[], inner: string): string => {
    const segments = inner.split(SEG);
    const cur = { i: 0 };
    let out = '';
    for (const block of blocks) {
      if (block.kind === 'list') {
        out += buildList(block, segments, cur);
      } else if (block.kind === 'heading') {
        const seg = segments[cur.i++] ?? '';
        const name = styleNameFor(`Heading_20_${block.level}`, block.style);
        out += `<text:h text:style-name="${name}" text:outline-level="${block.level}">${seg}</text:h>`;
      } else {
        const seg = segments[cur.i++] ?? '';
        out += `<text:p text:style-name="${styleNameFor('Standard', block.style)}">${seg}</text:p>`;
      }
    }
    return out;
  };

  // Match each real cell's single paragraph (filled or empty) in document order.
  // Covered cells use <table:covered-table-cell> and never match; a cell holds exactly
  // one <text:p> with no nesting here, so the non-greedy inner capture is safe.
  let idx = 0;
  content = content.replace(
    /(<table:table-cell\b[^>]*>\s*)<text:p\b[^>]*?(?:\/>|>([\s\S]*?)<\/text:p>)/g,
    (match, pre: string, innerRaw: string | undefined) => {
      const blocks = cellBlocks[idx++];
      if (!blocks || !needsWork(blocks)) return match;
      const inner = innerRaw ?? '';
      // Trivial single paragraph that only needs a style override: keep one
      // <text:p>, just point it at the minted style.
      if (blocks.length === 1 && blocks[0].kind === 'paragraph') {
        const name = styleNameFor('Standard', blocks[0].style);
        return innerRaw === undefined
          ? `${pre}<text:p text:style-name="${name}"/>`
          : `${pre}<text:p text:style-name="${name}">${inner}</text:p>`;
      }
      return `${pre}${buildBlocks(blocks, inner)}`;
    },
  );

  const additions: string[] = styleDefs.map(({ name, parent, style }) =>
    `<style:style style:name="${name}" style:family="paragraph" style:parent-style-name="${parent}"><style:paragraph-properties ${paraStyleProps(style).join(' ')}/></style:style>`,
  );
  if (usedBulletList) additions.push(buildCellListStyle(CELL_LIST_BULLET_STYLE, false));
  for (const { name, chars } of bulletStyles) {
    additions.push(buildCellListStyle(name, false, { bulletChars: chars }));
  }
  for (const { name, numFormat, numSuffix, multilevel } of numberStyles) {
    additions.push(buildCellListStyle(name, true, { fmts: Array.from({ length: 6 }, () => ({ numFormat, numSuffix })), multilevel }));
  }

  if (additions.length) {
    content = injectAutomaticStyles(content, `${additions.join('\n')}\n`);
  }

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Re-zip an unpacked ODF, preserving the mimetype-first uncompressed requirement.
// Intermediate archive between two passes: stored, the next unzipSync is the only
// reader — deflating every entry (images included) once per pass dominated buildOdt.
function rezipOdt(files: Record<string, Uint8Array>): Uint8Array {
  const out: Record<string, [Uint8Array, { level: 0 }]> = {};
  for (const [path, data] of Object.entries(files)) out[path] = [data, { level: 0 }];
  return zipSync(out);
}

// The returned .odt: mimetype first and stored (ODF requirement), already-compressed
// picture formats stored (svg/bmp still deflate well), everything else deflated once.
function zipFinal(odtBytes: Uint8Array): Uint8Array {
  const files = unzipSync(odtBytes);
  const out: Record<string, [Uint8Array, { level: 0 | 6 }]> = {};
  const mimetype = files['mimetype'];
  if (mimetype) out['mimetype'] = [mimetype, { level: 0 }];
  for (const [path, data] of Object.entries(files)) {
    if (path === 'mimetype') continue;
    const stored = /^Pictures\/.*\.(png|jpg|gif|webp)$/.test(path);
    out[path] = [data, { level: stored ? 0 : 6 }];
  }
  return zipSync(out);
}

// Rewrite styles.xml to match the editor's preview: default font Liberation Serif →
// Times New Roman (metric-identical; see EXPORT_FONT), and Heading_20_1/2/3 sizes &
// margins → the editor's values (odf-kit's defaults are larger; HEADING_STYLE_OVERRIDES).
// LibreOffice's watermark is a fontwork shape in the master page's header, and the
// enhanced geometry below is the "fontwork-plain-text" preset it writes verbatim.
const WATERMARK_GEOMETRY =
  '<draw:enhanced-geometry svg:viewBox="0 0 21600 21600" draw:text-areas="0 0 21600 21600"' +
  ' draw:text-path="true" draw:type="fontwork-plain-text" draw:modifiers="10800"' +
  ' draw:enhanced-path="M ?f3 0 L ?f5 0 N M ?f6 21600 L ?f7 21600 N">' +
  '<draw:equation draw:name="f0" draw:formula="$0 -10800"/>' +
  '<draw:equation draw:name="f1" draw:formula="?f0 *2"/>' +
  '<draw:equation draw:name="f2" draw:formula="abs(?f1 )"/>' +
  '<draw:equation draw:name="f3" draw:formula="if(?f1 ,0,?f2 )"/>' +
  '<draw:equation draw:name="f4" draw:formula="21600-?f2 "/>' +
  '<draw:equation draw:name="f5" draw:formula="if(?f1 ,?f4 ,21600)"/>' +
  '<draw:equation draw:name="f6" draw:formula="if(?f1 ,?f2 ,0)"/>' +
  '<draw:equation draw:name="f7" draw:formula="if(?f1 ,21600,?f4 )"/>' +
  '</draw:enhanced-geometry>';

// LibreOffice's own shape name; Word looks for exactly this one, so a round trip
// through either keeps recognising the shape as a watermark rather than a drawing.
const WATERMARK_NAME = 'PowerPlusWaterMarkObject';
// The shape's aspect ratio, measured off LibreOffice's own output (17cm × 3.789cm).
const WATERMARK_RATIO = 4.487;

// The watermark shape plus its two automatic styles, spliced into the master page's
// header — where both word processors keep it. A document without a header gets an
// explicit zero-height header band, so the body's geometry is unchanged.
function applyWatermarkOdf(odtBytes: Uint8Array, wm: Watermark | null): Uint8Array {
  if (!wm?.text) return odtBytes;
  const files = unzipSync(odtBytes);
  const stylesBytes = files['styles.xml'];
  if (!stylesBytes) return odtBytes;
  const styles = strFromU8(stylesBytes);
  const round3 = (v: number) => Math.round(v * 1000) / 1000;
  const widthCm = Math.max(1, lengthOfPageLayout(styles) );
  const heightCm = round3(widthCm / WATERMARK_RATIO);
  const opacity = `${round3(100 - wm.transparency)}%`;
  const minted =
    `<style:style style:name="Wmk1" style:family="graphic"><style:graphic-properties` +
    ` draw:stroke="none" draw:fill="solid" draw:fill-color="${wm.color}" draw:opacity="${opacity}"` +
    ` draw:auto-grow-height="false" draw:auto-grow-width="false"` +
    ` fo:min-height="${heightCm}cm" fo:min-width="${round3(widthCm)}cm"` +
    ` style:run-through="background" style:wrap="run-through" style:number-wrapped-paragraphs="no-limit"` +
    ` style:vertical-pos="middle" style:vertical-rel="page-content"` +
    ` style:horizontal-pos="center" style:horizontal-rel="page-content" style:flow-with-text="false"/></style:style>` +
    `<style:style style:name="WmkP1" style:family="paragraph"><style:text-properties` +
    ` fo:font-family="${escapeXml(`'${wm.font}'`)}" fo:font-size="1pt"/></style:style>`;
  const shape =
    `<draw:custom-shape text:anchor-type="char" draw:z-index="0" draw:name="${WATERMARK_NAME}"` +
    ` draw:style-name="Wmk1" draw:text-style-name="WmkP1"` +
    ` svg:width="${round3(widthCm)}cm" svg:height="${heightCm}cm"` +
    ` draw:transform="rotate (${(wm.angle * Math.PI) / 180})">` +
    `<text:p>${escapeXml(wm.text)}</text:p>${WATERMARK_GEOMETRY}</draw:custom-shape>`;

  // odf-kit declares no draw: prefix in styles.xml, and an undeclared one makes
  // LibreOffice drop the whole shape without a word.
  let out = styles.includes('xmlns:draw=')
    ? styles
    : styles.replace(/<office:document-styles\b/, '<office:document-styles xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0"');
  out = injectAutomaticStyles(out, minted);
  // Into the header the document already has — the shape is out of flow, so it changes
  // neither the band nor the zone's text.
  if (out.includes('<style:header>')) {
    out = out.replace(/<style:header>(\s*<text:p[^>]*>)?/, (m) =>
      m.includes('<text:p') ? `${m}${shape}` : `${m}<text:p text:style-name="Header">${shape}</text:p>`);
  } else {
    // No header: give the master page one that reserves no band of its own. LibreOffice
    // still floors the band at 0.499cm, so the body shifts by that much — its own
    // watermark does the same.
    const zone = `<style:header><text:p text:style-name="Header">${shape}</text:p></style:header>`;
    out = out.replace(/<style:header-style\s*\/>/, '<style:header-style><style:header-footer-properties fo:min-height="0cm" fo:margin-bottom="0cm"/></style:header-style>');
    out = /<style:master-page\b[^>]*\/>/.test(out)
      ? out.replace(/(<style:master-page\b[^>]*)\/>/, `$1>${zone}</style:master-page>`)
      : out.replace(/(<style:master-page\b[^>]*>)/, `$1${zone}`);
  }
  files['styles.xml'] = strToU8(out);
  return rezipOdt(files);
}

// The text width the page layout declares, in cm — the watermark spans it, as
// LibreOffice's does.
function lengthOfPageLayout(styles: string): number {
  const num = (attr: string) => {
    const m = new RegExp(`${attr}="([\\d.]+)cm"`).exec(styles);
    return m ? parseFloat(m[1]) : 0;
  };
  const width = num('fo:page-width');
  return width ? width - num('fo:margin-left') - num('fo:margin-right') : 17;
}

function rewriteStylesXml(odtBytes: Uint8Array, lang: { language: string; country: string } | null, pageFormat: PageFormat, orientation: Orientation, sheet: StyleSheet, used: Set<string>, usedTables: Set<string> = new Set(), tabIntervalCm: number = DEFAULT_TAB_INTERVAL_CM, mirrored = false, rtl = false, notes: NoteSettings = DEFAULT_NOTE_SETTINGS, hyphenate = false, pageNumbering: PageNumbering = DEFAULT_PAGE_NUMBERING, decor: PageDecor = EMPTY_PAGE_DECOR, lineNumbering: LineNumbering = DEFAULT_LINE_NUMBERING): Uint8Array {
  const files = unzipSync(odtBytes);
  const stylesBytes = files['styles.xml'];
  if (!stylesBytes) return odtBytes;

  let styles = strFromU8(stylesBytes);

  // Exact page box for the chosen format; odf-kit only emits its 5 presets, so
  // override the single fo:page-width/height in the page layout (round to 3 dp).
  const round3 = (v: number) => Math.round(v * 1000) / 1000;
  const dims = pageDimsCm(pageFormat, orientation);
  styles = styles
    .replace(/fo:page-width="[^"]*"/, `fo:page-width="${round3(dims.w)}cm"`)
    .replace(/fo:page-height="[^"]*"/, `fo:page-height="${round3(dims.h)}cm"`);

  // Mirrored margins: fo:margin-left/right are the inner/outer pair, which is what
  // the editor already holds, so only the flag has to be written back.
  if (mirrored) {
    styles = styles.replace(/<style:page-layout /, '<style:page-layout style:page-usage="mirrored" ');
  }

  // A right-to-left page: its columns fill from the right, as the editor draws them.
  if (rtl) {
    styles = styles.replace(/<style:page-layout-properties /, '<style:page-layout-properties style:writing-mode="rl-tb" ');
  }

  // Page background and page border ride the page layout, exactly where LibreOffice
  // keeps them (probed). The border is offset from the text area by fo:padding.
  const decorProps = [
    decor.border ? `fo:border="${round3(decor.border.widthPt)}pt solid ${decor.border.color}"` : '',
    decor.border ? `fo:padding="${round3(decor.border.paddingCm)}cm"` : '',
    decor.background ? `fo:background-color="${decor.background}"` : '',
  ].filter(Boolean).join(' ');
  if (decorProps) {
    styles = styles.replace(/<style:page-layout-properties /, `<style:page-layout-properties ${decorProps} `);
  }

  // Line numbering is one document-wide element in office:styles (probed). LibreOffice
  // writes only what differs from the ODF defaults, so an unnumbered document has none.
  if (lineNumbering.on) {
    const cfg = `<text:linenumbering-configuration text:number-lines="true"`
      + ` text:offset="${round3(lineNumbering.distanceCm)}cm" style:num-format="1"`
      + ` text:number-position="left" text:increment="${lineNumbering.interval}"`
      + ` text:count-empty-lines="${lineNumbering.countEmpty}"`
      + ` text:restart-on-page="${lineNumbering.restart === 'page'}"/>`;
    styles = styles.includes('</office:styles>')
      ? styles.replace('</office:styles>', `${cfg}</office:styles>`)
      : styles.replace(/<office:automatic-styles\b/, `<office:styles>${cfg}</office:styles><office:automatic-styles`);
  }

  // How the page-number field counts. ODF keeps the format on the page layout; the start
  // value is a property of the document's first paragraph (applyPageNumberStart).
  if (pageNumbering.format !== '1') {
    styles = styles.replace(
      /<style:page-layout-properties /,
      `<style:page-layout-properties style:num-format="${pageNumbering.format}" `,
    );
  }

  // Document spell-check language: set fo:language/fo:country on the base
  // Standard paragraph style, which every paragraph inherits from. LibreOffice
  // and Word read this as the document default language.
  if (lang) {
    styles = styles.replace(
      /(<style:style style:name="Standard"[\s\S]*?<style:text-properties\b[^>]*?)\/>/,
      `$1 fo:language="${lang.language}" fo:country="${lang.country}"/>`,
    );
  }

  // Automatic hyphenation. ODF counts fo:hyphenate as a *text* property, so it sits
  // beside the language on the style every paragraph inherits from — probed: in
  // paragraph-properties LibreOffice ignores it and drops it on the next save. Its two
  // limits ride along at LibreOffice's own defaults.
  if (hyphenate) {
    styles = styles.replace(
      /(<style:style style:name="Standard"[\s\S]*?<style:text-properties\b[^>]*?)\/>/,
      '$1 fo:hyphenate="true" fo:hyphenation-remain-char-count="2" fo:hyphenation-push-char-count="2"/>',
    );
  }

  // The only occurrences of "Liberation Serif" in styles.xml are the default
  // font-face declaration and the Standard style's font-name attributes.
  styles = styles.split(ODFKIT_DEFAULT_FONT).join(EXPORT_FONT);

  styles = styles.replace(
    '<style:master-page style:name="Default"',
    '<style:master-page style:name="Standard"',
  );

  // The document's tab interval, on the paragraph default-style. Always written: a file
  // that declares none falls back to ODF's own 2cm, which is not what the editor shows
  // (measured — LibreOffice puts a bare A⇥X at 2cm, not at its UI default of 1.25).
  styles = styles.replace('<office:styles>', '<office:styles>'
    + `<style:default-style style:family="paragraph"><style:paragraph-properties style:tab-stop-distance="${round3(tabIntervalCm)}cm"/></style:default-style>`
    + notesStyles() + notesConfiguration(notes));

  // The separator belongs to the page layout, beside the margins it is measured against.
  styles = styles.replace(
    /<style:page-layout-properties\b[^>]*\/>/,
    (props) => `${props.slice(0, -2)}>${footnoteSepXml(notes.separator)}</style:page-layout-properties>`,
  );

  // odf-kit's Standard style carries fo:margin-bottom="0.212cm", but the editor (like
  // LibreOffice and Word) has no paragraph spacing by default — every paragraph and list
  // item inherits this, so zero it or the export gains ~6pt per block vs. the preview.
  styles = styles.replace(
    /(<style:style style:name="Standard"[\s\S]*?<style:paragraph-properties[^>]*?)fo:margin-bottom="[^"]*"/,
    `$1fo:margin-bottom="0cm"`,
  );


  // ODF requires a font-face declaration for every referenced font name.
  styles = styles.replace(
    '</office:font-face-decls>',
    `<style:font-face style:name="${HEADING_FONT}" svg:font-family="${HEADING_FONT}" style:font-family-generic="swiss" style:font-pitch="variable"/></office:font-face-decls>`,
  );

  // The document's named paragraph styles (Standard, Heading, Heading_20_N, Title, …)
  // with their parent chain: merged into odf-kit's own blocks, appended when new.
  styles = applyNamedStyles(styles, sheet, used, usedTables);

  files['styles.xml'] = strToU8(styles);
  return rezipOdt(files);
}

// ODF requires fo:color as #RRGGBB. TipTap may store hex (color picker) or rgb(r,g,b)
// after an HTML round-trip. Anything not valid hex is silently dropped by
// Word/LibreOffice → text renders black, so coerce it here. Also used on import.
export function normalizeColor(input: string): string | undefined {
  const s = input.trim();
  if (!s) return undefined;

  const hex = s.match(/^#([0-9a-fA-F]{3,8})$/);
  if (hex) {
    const h = hex[1];
    if (h.length === 3 || h.length === 4) {
      return `#${h[0]}${h[0]}${h[1]}${h[1]}${h[2]}${h[2]}`.toUpperCase();
    }
    if (h.length === 6 || h.length === 8) {
      return `#${h.slice(0, 6)}`.toUpperCase();
    }
    return undefined;
  }

  const rgb = s.match(/^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*[\d.]+\s*)?\)$/i);
  if (rgb) {
    const toHex = (v: string) => {
      const n = Math.max(0, Math.min(255, Math.round(parseFloat(v))));
      return n.toString(16).padStart(2, '0');
    };
    return `#${toHex(rgb[1])}${toHex(rgb[2])}${toHex(rgb[3])}`.toUpperCase();
  }

  // Named colors (red, blue, …): pass through — odf-kit resolves them.
  return s;
}

// Translate a TipTap mark set into odf-kit TextFormatting (bold/italic/underline,
// font family/size, colour, highlight). Shared by body runs and header/footer runs.
function formattingFromMarks(marks: TiptapNode['marks'] = []): TextFormatting {
  const tsm = marks.find(m => m.type === 'textStyle');
  const fmt: TextFormatting = {};
  if (marks.some(m => m.type === 'bold'))      fmt.bold = true;
  // Explicit weight (e.g. un-bolding heading text) overrides the bold shortcut.
  if (tsm?.attrs?.fontWeight) {
    const fw = String(tsm.attrs.fontWeight);
    fmt.fontWeight = (/^\d+$/.test(fw) ? Number(fw) : fw) as TextFormatting['fontWeight'];
  }
  if (marks.some(m => m.type === 'italic'))     fmt.italic = true;
  if (marks.some(m => m.type === 'underline'))  fmt.underline = true;
  if (marks.some(m => m.type === 'strike'))     fmt.strikethrough = true;
  if (marks.some(m => m.type === 'superscript')) fmt.superscript = true;
  else if (marks.some(m => m.type === 'subscript')) fmt.subscript = true;
  if (tsm?.attrs?.fontFamily) {
    const ff = String(tsm.attrs.fontFamily);
    // Explicitly choosing the editor default should match the untagged
    // default, which resolves to EXPORT_FONT via the Standard style.
    fmt.fontFamily = ff === ODFKIT_DEFAULT_FONT ? EXPORT_FONT : ff;
  }
  if (tsm?.attrs?.fontSize)   fmt.fontSize   = String(tsm.attrs.fontSize);
  if (tsm?.attrs?.color) {
    const c = normalizeColor(String(tsm.attrs.color));
    if (c) fmt.color = c;
  }
  // Text highlight (background). odf-kit maps highlightColor → fo:background-color
  // natively for normal paragraphs; this covers the custom-attr-paragraph path
  // (CUST_P/CUST_H), which bypasses odf-kit's own mark handling.
  const hl = marks.find(m => m.type === 'highlight');
  if (hl?.attrs?.color) {
    const c = normalizeColor(String(hl.attrs.color));
    if (c) fmt.highlightColor = c;
  }
  return fmt;
}

// Hyperlink target of a run, if any. odf-kit's native run path handles the link mark
// itself; this covers the custom emitters (CUST_P/_H, cells) that bypass it.
function linkHrefOf(marks: TiptapNode['marks'] = []): string | undefined {
  const href = marks.find(m => m.type === 'link')?.attrs?.href;
  return href ? String(href) : undefined;
}

// The sheet of the export in flight, so the run emitters can resolve character styles
// without threading it through every cell/list helper (mirrors docLangTag in docx.ts).
let exportSheet: StyleSheet = builtinStyleSheet();
let exportSpacingModel: SpacingModel = 'add';

// Emit each text node as an odf-kit run; link-marked runs become <text:a> via addLink.
// `force` bakes formatting onto every run regardless of marks — for header/region cells,
// whose formatting is presentational (CSS) in the editor and so isn't stored as marks.
function applyRuns(p: ParagraphBuilder | CellBuilder, content: TiptapNode[] = [], force: TextProps = {}) {
  const forced = Object.keys(force).length ? textFormatting(force) : null;
  for (const node of content) {
    if (node.type !== 'text' || !node.text) continue;
    const fmt = formattingFromMarks(node.marks);
    // A cell's header/region formatting is presentational (CSS) in the editor, so bake it
    // under the run's own marks; an explicit un-bold (fontWeight:normal) still wins.
    if (forced) {
      const direct = { ...fmt };
      Object.assign(fmt, forced, direct);
      if (!direct.bold && fmt.fontWeight === 'normal') delete fmt.bold;
      // A link keeps its own paint: LibreOffice's Internet Link style and the editor's
      // a-rule both outrank the region color, so the bake must not override it.
      if (!direct.color && node.marks?.some((m) => m.type === 'link' && !m.attrs?.plain)) {
        delete fmt.color;
      }
    }
    // A named character style: bake its resolved formatting (so odf-kit always mints a
    // span) and mark the run, so applyCharacterStyles can re-point that span at the style.
    const charStyle = charStyleOf(node.marks);
    let prefix = '';
    if (charStyle) {
      // The style is the base, the run's own marks stay on top.
      const direct = { ...fmt };
      Object.assign(fmt, charFormatting(exportSheet, charStyle), direct);
      prefix = `${CST}${charStyle}${CST}`;
    }
    const f = Object.keys(fmt).length ? fmt : undefined;
    const href = linkHrefOf(node.marks);
    if (href) p.addLink(prefix + node.text, href, f);
    else p.addText(prefix + node.text, f);
  }
}

// CSS line styles → ODF's own names for the same shapes.
const ODF_LINE_STYLE: Record<string, string> = { dotted: 'dotted', dashed: 'dash', wavy: 'wave' };

// The effects ODF carries but odf-kit's run formatting has no field for. Returned as
// the <style:text-properties> attributes applyTextEffects folds into the run's style.
export function odfExtraTextProps(marks: TiptapNode['marks'] = [], baseSizePt = DEFAULT_FONT_SIZE_PT): string {
  const a: string[] = [];
  const caps = marks.find(m => m.type === 'textStyle')?.attrs?.caps;
  if (caps === 'smallCaps') a.push('fo:font-variant="small-caps"');
  else if (caps === 'uppercase' || caps === 'lowercase' || caps === 'capitalize') a.push(`fo:text-transform="${caps}"`);
  const u = marks.find(m => m.type === 'underline')?.attrs;
  if (u?.lineStyle === 'double') a.push('style:text-underline-type="double"');
  else if (typeof u?.lineStyle === 'string' && ODF_LINE_STYLE[u.lineStyle]) {
    a.push(`style:text-underline-style="${ODF_LINE_STYLE[u.lineStyle]}"`);
  }
  if (u?.lineColor) {
    const c = normalizeColor(String(u.lineColor));
    if (c) a.push(`style:text-underline-color="${c}"`);
  }
  if (marks.find(m => m.type === 'strike')?.attrs?.lineStyle === 'double') {
    a.push('style:text-line-through-type="double"');
  }
  // ODF places a raised run in percent of its font size, Word and the editor in pt.
  const pos = marks.find(m => m.type === 'textStyle')?.attrs?.textPosition;
  if (typeof pos === 'number' && pos) {
    a.push(`style:text-position="${Math.round((pos / runSizePt(marks, baseSizePt)) * 10000) / 100}% 100%"`);
  }
  return a.join(' ');
}

// The run's own size where it declares one, else the block's (a heading run resolves to
// the level's size) — the reference for the percentage above; import mirrors this.
function runSizePt(marks: TiptapNode['marks'], baseSizePt: number): number {
  const size = marks?.find(m => m.type === 'textStyle')?.attrs?.fontSize;
  const pt = size ? parseFloat(String(size)) : NaN;
  return Number.isFinite(pt) && pt > 0 ? pt : baseSizePt;
}

function charStyleOf(marks: TiptapNode['marks']): string | null {
  const name = marks?.find(m => m.type === 'charStyle')?.attrs?.name;
  return typeof name === 'string' && name ? name : null;
}

// A character style's resolved props as odf-kit run formatting (baked so the file still
// looks right for readers that ignore the style reference).
function charFormatting(sheet: StyleSheet, name: string): Record<string, unknown> {
  return textFormatting(resolveStyle(sheet, name, 'character').text);
}

// Prefix the sentinel on every run carrying such an effect, wherever it sits — odf-kit
// reads marks itself on its native paths, so the pre-pass is what reaches all of them.
function markTextEffects(node: TiptapNode, baseSizePt = DEFAULT_FONT_SIZE_PT, sheet?: StyleSheet): TiptapNode {
  if (node.type === 'text') {
    const extra = odfExtraTextProps(node.marks, baseSizePt);
    // The empty trailing pair marks where the run ends: a bare run following would
    // otherwise be indistinguishable from the run's own text and get wrapped with it.
    return extra ? { ...node, text: `${TEF}${extra}${TEF}${node.text ?? ''}${TEF}${TEF}` } : node;
  }
  if (!node.content?.length) return node;
  // A named style's size is the reference for a raised run's percentage (a Title's
  // -2pt is a smaller share of its 28pt); import resolves against the same chain.
  const named = sheet && typeof node.attrs?.styleName === 'string'
    ? resolveStyle(sheet, node.attrs.styleName, 'paragraph').text.fontSizePt : null;
  const base = node.type === 'heading' || node.type === CUST_H
    ? parseFloat(HEADING_STYLE_OVERRIDES[Math.min(Math.max(Number(node.attrs?.level) || 1, 1), HEADING_STYLE_OVERRIDES.length) - 1].fontSize)
    : named ?? baseSizePt;
  return { ...node, content: node.content.map((c) => markTextEffects(c, base, sheet)) };
}

// odf-kit's list builder reads a run's marks itself and knows nothing about charStyle,
// and applyRuns never sees a list paragraph — so do its two jobs here: bake the style
// into direct marks (the run then gets a span) and prefix the CST sentinel for it.
function bakeListCharStyles(node: TiptapNode, sheet: StyleSheet, inList = false): TiptapNode {
  if (node.type === 'text') {
    const name = inList ? charStyleOf(node.marks) : null;
    if (!name) return node;
    return {
      ...node,
      text: `${CST}${name}${CST}${node.text ?? ''}`,
      marks: bakeMarks(node.marks ?? [], resolveStyle(sheet, name, 'character').text),
    };
  }
  if (!node.content?.length) return node;
  const nested = inList || node.type === 'bulletList' || node.type === 'orderedList';
  return { ...node, content: node.content.map(c => bakeListCharStyles(c, sheet, nested)) };
}

// The style's props as direct marks, with the run's own marks on top (as in applyRuns).
function bakeMarks(marks: TiptapMark[], t: TextProps): TiptapMark[] {
  const out = marks.filter(m => m.type !== 'textStyle');
  const own = marks.find(m => m.type === 'textStyle')?.attrs ?? {};
  const attrs: Record<string, unknown> = {};
  if (t.fontFamily) attrs.fontFamily = t.fontFamily;
  if (t.fontSizePt != null) attrs.fontSize = `${t.fontSizePt}pt`;
  if (t.color) attrs.color = t.color;
  for (const [key, value] of Object.entries(own)) if (value != null) attrs[key] = value;
  // An explicit weight is the un-bold channel and outranks the style's bold.
  const flags = [[t.bold && own.fontWeight == null, 'bold'], [t.italic, 'italic'],
    [t.underline, 'underline'], [t.strike, 'strike']] as const;
  for (const [on, type] of flags) if (on && !marks.some(m => m.type === type)) out.push({ type });
  if (Object.keys(attrs).length) out.push({ type: 'textStyle', attrs });
  return out;
}

// TextProps as odf-kit run formatting.
function textFormatting(t: TextProps): Record<string, unknown> {
  const fmt: Record<string, unknown> = {};
  if (t.bold != null) fmt.bold = t.bold;
  if (t.italic != null) fmt.italic = t.italic;
  if (t.underline) fmt.underline = true;
  if (t.strike) fmt.strikethrough = true;
  if (t.fontFamily) fmt.fontFamily = t.fontFamily === ODFKIT_DEFAULT_FONT ? EXPORT_FONT : t.fontFamily;
  if (t.fontSizePt != null) fmt.fontSize = `${t.fontSizePt}pt`;
  if (t.color) fmt.color = t.color;
  return fmt;
}

// Resolve CST sentinels: point each marked run's span at its named character style
// (a clone of the automatic style whose parent becomes the named one), then strip it.
function applyCharacterStyles(odtBytes: Uint8Array): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  if (!content.includes(CST)) return odtBytes;

  const minted: string[] = [];
  const nameByKey = new Map<string, string>();
  let counter = 0;

  const styleFor = (source: string, styleName: string): string => {
    const odfName = odfStyleName(styleName);
    const auto = source ? findAutoStyle(content, source) : null;
    if (!auto) return odfName;
    const key = `${source}|${odfName}`;
    const existing = nameByKey.get(key);
    if (existing) return existing;
    const name = `TS${++counter}`;
    nameByKey.set(key, name);
    minted.push(
      auto
        .replace(/style:name="[^"]*"/, `style:name="${name}"`)
        .replace(/^<style:style\b[^>]*?(\/?)>/, (tag) => setTagAttrs(tag, { 'style:parent-style-name': odfName })),
    );
    return name;
  };

  const cstRe = new RegExp(`${CST}([^${CST}]*)${CST}`);
  content = content.replace(
    new RegExp(`<text:span\\b((?:[^>]*[^/>])?)>([\\s\\S]*?)</text:span>`, 'g'),
    (m, attrs: string, inner: string) => {
      const sm = cstRe.exec(inner);
      if (!sm) return m;
      const cleaned = inner.replace(cstRe, '');
      const srcM = /text:style-name="([^"]*)"/.exec(attrs);
      const name = styleFor(srcM ? srcM[1] : '', sm[1]);
      const newAttrs = srcM
        ? attrs.replace(/text:style-name="[^"]*"/, `text:style-name="${name}"`)
        : ` text:style-name="${name}"${attrs}`;
      return `<text:span${newAttrs}>${cleaned}</text:span>`;
    },
  );
  content = content.replace(new RegExp(`${CST}[^${CST}]*${CST}`, 'g'), '');

  if (minted.length) {
    content = injectAutomaticStyles(content, minted.join(''));
  }

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Merge each TEF sentinel's effects into that run's own automatic text style (cloned,
// since the style is shared) and wrap a run that got no span in one. Shared by
// content.xml (body) and styles.xml (header/footer), which mint their styles separately.
function resolveTextEffects(xml: string, mint: (styleXml: string) => void, prefix: string): string {
  if (!xml.includes(TEF)) return xml;
  const nameByKey = new Map<string, string>();
  const styleFor = (source: string, extra: string): string => {
    const key = `${source}|${extra}`;
    const existing = nameByKey.get(key);
    if (existing) return existing;
    const name = `${prefix}${nameByKey.size + 1}`;
    nameByKey.set(key, name);
    const auto = source ? findAutoStyle(xml, source) : null;
    const names = [...extra.matchAll(/([\w:.-]+)=/g)].map(m => m[1]);
    mint(auto
      ? auto.replace(/style:name="[^"]*"/, `style:name="${name}"`)
          .replace(/<style:text-properties\b([^>]*?)(\/?)>/, (_m, attrs: string, slash: string) => {
            const kept = names.reduce((acc, n) => acc.replace(new RegExp(`\\s${n}="[^"]*"`, 'g'), ''), attrs);
            return `<style:text-properties${kept} ${extra}${slash}>`;
          })
      : `<style:style style:name="${name}" style:family="text"><style:text-properties ${extra}/></style:style>`);
    return name;
  };

  const tefRe = new RegExp(`${TEF}([^${TEF}]*)${TEF}`);
  let out = xml.replace(
    new RegExp(`<text:span\\b((?:[^>]*[^/>])?)>([\\s\\S]*?)</text:span>`, 'g'),
    (m, attrs: string, inner: string) => {
      const sm = tefRe.exec(inner);
      if (!sm) return m;
      const srcM = /text:style-name="([^"]*)"/.exec(attrs);
      const name = styleFor(srcM ? srcM[1] : '', sm[1]);
      const newAttrs = srcM
        ? attrs.replace(/text:style-name="[^"]*"/, `text:style-name="${name}"`)
        : ` text:style-name="${name}"${attrs}`;
      return `<text:span${newAttrs}>${inner.replace(new RegExp(tefRe.source, 'g'), '')}</text:span>`;
    },
  );
  // A run whose only formatting is such an effect never got a span: give it one, up to
  // the next real element — a tab/line-break/space, a bookmark marker or a comment's
  // annotation inside the run rides along, or the text behind it would fall out of the
  // span and lose the effect.
  // The annotation block is tempered to its first close tag, and (?=[\s>]) keeps it off
  // <office:annotation-end (\b sits before the hyphen) — either slip would stretch one
  // annotation across the next one's body and misplace the minted span's close.
  const inline = `<text:(?:tab|line-break|s|bookmark-start|bookmark-end)\\b[^>]*/>`
    + `|<office:annotation(?=[\\s>])(?:(?!</office:annotation>)[\\s\\S])*</office:annotation>`
    + `|<office:annotation-end\\b[^>]*/>`;
  out = out.replace(
    new RegExp(`${TEF}([^${TEF}]+)${TEF}((?:[^<${TEF}]|${inline})*)(?:${TEF}${TEF})?`, 'g'),
    (_m, extra: string, text: string) => `<text:span text:style-name="${styleFor('', extra)}">${text}</text:span>`,
  );
  // Drop any sentinels not consumed above (defensive — never legitimate text).
  return out.split(TEF).join('');
}

function applyTextEffects(odtBytes: Uint8Array): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  const before = strFromU8(contentBytes);
  const minted: string[] = [];
  const content = resolveTextEffects(before, (s) => minted.push(s), 'TE');
  if (content === before) return odtBytes;

  files['content.xml'] = strToU8(injectAutomaticStyles(content, minted.join('')));
  return rezipOdt(files);
}

// Emit the header/footer paragraph into odf-kit's HeaderFooterBuilder. hardBreak
// and pageCount ride as sentinels (LBR / PGC-wrapped digits) and are rewritten to
// <text:line-break/> / <text:page-count> in applyHfPostProcess (styles.xml).
function applyHfRuns(b: HeaderFooterBuilder, para: TiptapNode, pageCount: number): void {
  for (const node of para.content ?? []) {
    const fmt = formattingFromMarks(node.marks);
    const f = Object.keys(fmt).length ? fmt : undefined;
    if (node.type === 'text' && node.text) b.addText(node.text, f);
    else if (node.type === 'hardBreak')    b.addText(LBR);
    else if (node.type === 'pageNumber')   b.addPageNumber(f);
    else if (node.type === 'pageCount')    b.addText(`${PGC}${pageCount}${PGC}`, f);
    else if (node.type === 'chapterField') b.addText(chapterSentinel(node), f);
  }
}

// CHP<level>CHP<cached name>CHP — the cached name is what a reader shows before it
// resolves the field itself, so it rides along like LibreOffice writes it.
function chapterSentinel(node: TiptapNode): string {
  const level = Number(node.attrs?.level) || 1;
  return `${CHP}${level}${CHP}${String(node.attrs?.text ?? '')}${CHP}`;
}

// Emit a cell's inline content into odf-kit's run-based CellBuilder and, in lockstep,
// return a CellBlock[] descriptor. odf-kit serializes the runs into one <text:p>;
// applyCellBlocks splits on SEG and rebuilds real <text:h>/<text:p>/<text:list>.

// A segment is one paragraph, heading, or list item's paragraph; exactly one SEG
// between consecutive segments, so splitting yields one piece per segment in DFS order.
// Neither word processor passes the default style's spacing into a cell (LibreOffice's Table
// Contents zeroes both, Word's table styles the space below), and editor.css renders it that
// way — so the file says so too. A paragraph's own spacing still wins.
function cellParaStyle(attrs: TiptapNode['attrs']): ParaStyle {
  const style = paraStyleFromAttrs(attrs);
  if (attrs?.styleName) return style;
  const def = resolveStyle(exportSheet, DEFAULT_STYLE).para;
  if (!def.spaceBefore && !def.spaceAfter) return style;
  const spaceBefore = exportSpacingModel === 'max' ? style.spaceBefore : style.spaceBefore ?? 0;
  return { ...style, spaceBefore, spaceAfter: style.spaceAfter ?? 0 };
}

function buildCellContent(cell: TiptapNode, c: CellBuilder, force: TextProps = {}): CellBlock[] {
  const blocks: CellBlock[] = [];
  const state = { emitted: false }; // whether any segment has been emitted yet

  const emitSegment = (content: TiptapNode[] | undefined) => {
    if (state.emitted) c.addText(SEG);
    state.emitted = true;
    applyRuns(c, content ?? [], force);
  };

  const walkList = (listNode: TiptapNode): CellListBlock => {
    const ordered = listNode.type === 'orderedList';
    const start = ordered ? ((listNode.attrs?.start as number) ?? null) : null;
    const items: CellListItem[] = [];
    for (const item of listNode.content ?? []) {
      if (item.type !== 'listItem') continue;
      const firstPara = item.content?.find(x => x.type === 'paragraph');
      emitSegment(firstPara?.content); // one segment per item, in DFS order
      const nested = item.content?.find(x => x.type === 'bulletList' || x.type === 'orderedList');
      items.push({ style: paraStyleFromAttrs(firstPara?.attrs, false), nested: nested ? walkList(nested) : null });
    }
    // Raw attrs; applyCellBlocks resolves the depth defaults when it knows the depth.
    const listStyleType = ordered && typeof listNode.attrs?.listStyleType === 'string' ? (listNode.attrs.listStyleType as string) : null;
    const bulletChar = !ordered && typeof listNode.attrs?.bulletChar === 'string' ? (listNode.attrs.bulletChar as string) : null;
    return { kind: 'list', ordered, start, listStyleType, bulletChar, items };
  };

  for (const block of cell.content ?? []) {
    if (block.type === 'paragraph') {
      emitSegment(block.content);
      blocks.push({ kind: 'paragraph', style: cellParaStyle(block.attrs) });
    } else if (block.type === 'heading') {
      emitSegment(block.content);
      blocks.push({ kind: 'heading', level: (block.attrs?.level as number) ?? 1, style: paraStyleFromAttrs(block.attrs) });
    } else if (block.type === 'bulletList' || block.type === 'orderedList') {
      blocks.push(walkList(block));
    }
  }

  // Empty cell: odf-kit emits an empty <text:p/>; record one empty paragraph so
  // applyCellBlocks stays aligned and leaves it untouched.
  if (blocks.length === 0) {
    blocks.push({ kind: 'paragraph', style: cellParaStyle(undefined) });
  }
  return blocks;
}

// Per-column widths (cm) from the table's first row: the editor's proportional
// `colwidth` weights (tableView.ts) turned into absolute cm summing to the text width.
// With table:align="margins" this matches the preview. undefined → odf-kit even split.
function tableColumnWidthsCm(node: TiptapNode, contentWidthCm: number): string[] | undefined {
  const firstRow = (node.content ?? []).find(r => r.type === 'tableRow');
  if (!firstRow) return undefined;

  const weights: (number | null)[] = [];
  for (const cell of firstRow.content ?? []) {
    if (cell.type !== 'tableCell' && cell.type !== 'tableHeader') continue;
    const colspan = (cell.attrs?.colspan as number) ?? 1;
    const cw = cell.attrs?.colwidth as number[] | null | undefined;
    for (let k = 0; k < colspan; k++) weights.push(cw && cw[k] ? cw[k] : null);
  }
  if (weights.length === 0 || weights.every(w => w == null)) return undefined;

  const present = weights.filter((w): w is number => w != null);
  const avg = present.reduce((a, b) => a + b, 0) / present.length;
  const filled = weights.map(w => (w != null ? w : avg));
  const total = filled.reduce((a, b) => a + b, 0);

  const round3 = (v: number) => Math.round(v * 1000) / 1000;
  const cm = filled.map(w => round3((w / total) * contentWidthCm));
  // Absorb the rounding remainder into the last column so the widths sum exactly
  // to the text width (table:align="margins" scales otherwise).
  const sum = cm.reduce((a, b) => a + b, 0);
  cm[cm.length - 1] = round3(cm[cm.length - 1] + (contentWidthCm - sum));
  return cm.map(v => `${v}cm`);
}

// What rides on a table's own automatic style: its left/right margins (cm, from the
// outer-edge drag, clamped into the text width) and whether a page break may fall
// between its rows. null = a full-width table that may break, the common case.
function tablePropsOf(node: TiptapNode, contentWidthCm: number): TableProps | null {
  const round3 = (v: number) => Math.round(v * 1000) / 1000;
  let ml = Math.max(0, Number(node.attrs?.marginLeft) || 0);
  let mr = Math.max(0, Number(node.attrs?.marginRight) || 0);
  const mt = Math.max(0, Number(node.attrs?.marginTop) || 0);
  const mb = Math.max(0, Number(node.attrs?.marginBottom) || 0);
  const keepRows = node.attrs?.keepRows === true;
  const repeatHeader = node.attrs?.repeatHeader === true;
  if (ml + mr > contentWidthCm - 1) ml = mr = 0;
  if (!ml && !mr && !mt && !mb && !keepRows && !repeatHeader) return null;
  return { ml: round3(ml), mr: round3(mr), mt: round3(mt), mb: round3(mb), keepRows, repeatHeader };
}

// A formula cell as ODF writes it: LibreOffice's own formula language behind its
// `ooow:` prefix, plus the cached result as the cell's value.
type CellFormulaExport = { formula: string; value: number | null; format: CellFormat | null };

function ensureOoowNamespace(content: string): string {
  if (content.includes('xmlns:ooow=')) return content;
  return content.replace(/<office:document-content\b/, '<office:document-content xmlns:ooow="http://openoffice.org/2004/writer"');
}

// One entry per real cell in document order (covered cells carry no formula and never
// match the regex), the same walk applyCellBlocks makes.
function applyCellFormulas(odtBytes: Uint8Array, cells: (CellFormulaExport | null)[], lang: string): Uint8Array {
  if (!cells.some(Boolean)) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let idx = 0;
  // A number format lives on the cell *style*, and odf-kit shares one style across
  // every cell — so a formatted cell gets a copy of it carrying the data style.
  const minted: string[] = [];
  const derived = new Map<string, string>();
  let source = strFromU8(contentBytes);
  const styleFor = (base: string, format: CellFormat): string => {
    const key = `${base}|${format}`;
    const existing = derived.get(key);
    if (existing) return existing;
    const name = `Cf${derived.size + 1}`;
    const dataName = `Ncell${derived.size + 1}`;
    derived.set(key, name);
    minted.push(odfCellNumberStyle(format, dataName, lang));
    const props = new RegExp(`<style:style style:name="${base}" style:family="table-cell"[^>]*>([\\s\\S]*?)</style:style>`)
      .exec(source)?.[1] ?? '';
    minted.push(
      `<style:style style:name="${name}" style:family="table-cell" style:data-style-name="${dataName}">`
      + `${props}</style:style>`,
    );
    return name;
  };

  let content = source.replace(
    /<table:table-cell\b([^>]*?)(\/?)>/g,
    (match, attrs: string, selfClose: string) => {
      const cell = cells[idx++];
      if (!cell) return match;
      const value = cell.value == null ? '' : ` office:value-type="float" office:value="${cell.value}"`;
      const base = /table:style-name="([^"]+)"/.exec(attrs)?.[1];
      const styled = cell.format && base
        ? attrs.replace(`table:style-name="${base}"`, `table:style-name="${styleFor(base, cell.format)}"`)
        : attrs;
      return `<table:table-cell${styled} table:formula="ooow:${escapeXml(cell.formula)}"${value}${selfClose}>`;
    },
  );
  if (minted.length) content = ensureNumberNamespace(injectAutomaticStyles(content, minted.join('')));
  // `ooow:` in the value is a namespace prefix, so the reader resolves it against the
  // declarations: undeclared, LibreOffice reads the prefix as part of the formula and
  // prints "Expression is faulty" (probed).
  files['content.xml'] = strToU8(ensureOoowNamespace(content));
  return rezipOdt(files);
}

// The data style a formatted cell points at: how many decimals, whether the thousands
// are grouped, and the style family — percentage, currency and date each have their own.
function odfCellNumberStyle(format: CellFormat, name: string, lang: string): string {
  const spec = CELL_FORMAT_SPECS[format];
  const [code, country] = lang.split('-');
  // The style names the document's language: without it LibreOffice prints the
  // separators and the symbol of its own locale, not the ones the editor shows (probed).
  const at = `style:name="${name}" number:language="${code}"${country ? ` number:country="${country}"` : ''}`;
  if (spec.kind === 'date') return odfDateStyle(at, lang);
  const number = `<number:number number:decimal-places="${spec.decimals}"`
    + ` number:min-decimal-places="${spec.decimals}" number:min-integer-digits="1"`
    + `${spec.grouping ? ' number:grouping="true"' : ''}/>`;
  if (spec.kind === 'percent') {
    return `<number:percentage-style ${at}>${number}`
      + `<number:text>%</number:text></number:percentage-style>`;
  }
  if (spec.kind === 'currency') {
    const { symbol, before, space } = currencyParts(lang);
    const sym = `<number:currency-symbol number:language="${code}"`
      + `${country ? ` number:country="${country}"` : ''}>${escapeXml(symbol)}</number:currency-symbol>`;
    const gap = space ? `<number:text>${escapeXml(space)}</number:text>` : '';
    return `<number:currency-style ${at}>`
      + (before ? `${sym}${gap}${number}` : `${number}${gap}${sym}`)
      + `</number:currency-style>`;
  }
  return `<number:number-style ${at}>${number}</number:number-style>`;
}

// The locale's short date as ODF spells it: a `long` field is the zero-padded one, a
// long year the four-digit one.
function odfDateStyle(at: string, lang: string): string {
  const body = datePattern(lang).map((f) => {
    if (f.kind === 'literal') return `<number:text>${escapeXml(f.text)}</number:text>`;
    const long = f.kind === 'year' ? f.digits >= 4 : f.digits >= 2;
    return `<number:${f.kind}${long ? ' number:style="long"' : ''}/>`;
  }).join('');
  return `<number:date-style ${at}>${body}</number:date-style>`;
}

// A table's grid: where every real cell sits and what each slot reads, merged cells
// filling the box they span — so a formula's A1 is the cell the editor calls A1.
type CellGridJson = {
  at: Map<TiptapNode, CellRef>;
  rows: number;
  cols: number;
  text: (ref: CellRef) => string;
};

function cellText(node: TiptapNode): string {
  if (node.type === 'text') return node.text ?? '';
  return (node.content ?? []).map(cellText).join('');
}

function tableGridJson(rows: TiptapNode[]): CellGridJson {
  const slots: (string | undefined)[][] = [];
  const at = new Map<TiptapNode, CellRef>();
  rows.forEach((row, r) => {
    slots[r] ??= [];
    let c = 0;
    for (const cell of row.content ?? []) {
      if (cell.type !== 'tableCell' && cell.type !== 'tableHeader') continue;
      while (slots[r][c] !== undefined) c++;
      at.set(cell, { row: r, col: c });
      const text = cellText(cell);
      const colspan = (cell.attrs?.colspan as number) ?? 1;
      const rowspan = (cell.attrs?.rowspan as number) ?? 1;
      for (let dr = 0; dr < rowspan; dr++) {
        slots[r + dr] ??= [];
        for (let dc = 0; dc < colspan; dc++) slots[r + dr][c + dc] = text;
      }
      c += colspan;
    }
  });
  return {
    at,
    rows: rows.length,
    cols: Math.max(0, ...slots.map((s) => s.length)),
    text: (ref) => slots[ref.row]?.[ref.col] ?? '',
  };
}

// The cell's formula in LibreOffice's own language, plus the result it caches.
function cellFormulaOf(cell: TiptapNode, grid: CellGridJson, loc: NumberLocale): CellFormulaExport | null {
  const formula = typeof cell.attrs?.formula === 'string' ? cell.attrs.formula : '';
  const self = grid.at.get(cell);
  if (!formula || !self) return null;
  const ctx = {
    rows: grid.rows, cols: grid.cols, self,
    valueAt: (ref: CellRef) => parseCellNumber(grid.text(ref), loc),
  };
  return {
    formula: toWriterFormula(formula, ctx),
    value: parseCellNumber(grid.text(self), loc),
    format: isCellFormat(cell.attrs?.cellFormat) ? cell.attrs.cellFormat : null,
  };
}

// Build an ODF table from a CUST_TABLE node, bypassing odf-kit's native walkTable to
// pass an explicit cell border (the native path emits none → invisible). Column widths
// come from tableColumnWidthsCm; when absent odf-kit distributes columns evenly.
function exportTable(node: TiptapNode, doc: OdtDocument, contentWidthCm: number, cellBlocks: CellBlock[][], tableMargins: (TableProps | null)[], tableStyleNames: (TableStyleRef | null)[], cellFormulas: (CellFormulaExport | null)[], numberLoc: NumberLocale): void {
  const rows = (node.content ?? []).filter(r => r.type === 'tableRow');
  if (rows.length === 0) return;
  const grid = tableGridJson(rows);
  const margins = tablePropsOf(node, contentWidthCm);
  tableMargins.push(margins);
  // The named table style, if the registry still knows it: its name goes on the table's
  // automatic style (applyTableStyleNames), its text formatting is baked per cell.
  const styleName = typeof node.attrs?.tableStyle === 'string' ? node.attrs.tableStyle : null;
  const tableStyle = styleName ? exportSheet.table?.[styleName] : undefined;
  const look = parseTableLook(node.attrs?.tableLook);
  tableStyleNames.push(tableStyle && styleName ? { name: styleName, look } : null);
  const columnWidths = tableColumnWidthsCm(node, contentWidthCm - (margins ? margins.ml + margins.mr : 0));
  // Cell margins ride on every cell as a TRBL shorthand (ODF has no table-level one);
  // expandCellPadding splits it, since odf-kit only writes fo:padding and ODF only
  // allows one length there. A cell's own attr overrides the table's.
  const tablePad = parseCellPadding(node.attrs?.cellPadding) ?? DEFAULT_CELL_PADDING;
  const padValue = (p: CellPadding) => p.map(n => `${n}cm`).join(' ');
  doc.addTable((t: TableBuilder) => {
    for (const row of rows) {
      t.addRow((r: RowBuilder) => {
        for (const cell of row.content ?? []) {
          if (cell.type !== 'tableCell' && cell.type !== 'tableHeader') continue;
          // Emit the cell's runs (SEG-separated) and record its descriptor; addCell is
          // synchronous, so the push stays in document order, matching applyCellBlocks'
          // walk. Spans make odf-kit emit covered cells, which its cell regex never matches.
          const opts: CellOptions = { padding: padValue(parseCellPadding(cell.attrs?.cellPadding) ?? tablePad) };
          const colspan = (cell.attrs?.colspan as number) ?? 1;
          const rowspan = (cell.attrs?.rowspan as number) ?? 1;
          if (colspan > 1) opts.colSpan = colspan;
          if (rowspan > 1) opts.rowSpan = rowspan;
          // Cell shading → fo:background-color (odf-kit mints the cell style).
          const bg = cell.attrs?.backgroundColor;
          if (typeof bg === 'string') {
            const c = normalizeColor(bg);
            if (c) opts.backgroundColor = c;
          }
          // Content set against the middle/bottom of the box → style:vertical-align.
          const va = cell.attrs?.verticalAlign;
          if (va === 'middle' || va === 'bottom') opts.verticalAlign = va;
          // Per-side borders → fo:border-* (null = the table default border below).
          for (const side of BORDER_SIDES) {
            const b = parseBorderAttr(cell.attrs?.[side] as string | null);
            if (b === 'none') opts[side] = 'none';
            else if (b) opts[side] = `${b.widthPt}pt solid ${normalizeColor(b.color) ?? b.color}`;
          }
          // Header cells and a table style's regions render bold/font via CSS
          // (presentational), so bake that onto the runs for Word/LibreOffice.
          const force = regionText(tableStyle, cell.attrs?.region);
          if (bg === HEADER_SHADE) force.bold = true;
          cellFormulas.push(cellFormulaOf(cell, grid, numberLoc));
          r.addCell((c: CellBuilder) => {
            cellBlocks.push(buildCellContent(cell, c, force));
          }, opts);
        }
      });
    }
  }, columnWidths ? { border: TABLE_BORDER, columnWidths } : { border: TABLE_BORDER });
}

// odf-kit joins a multi-child element's children with "\n"; inside a <text:p>/<text:h>
// that newline is significant and collapses to a space, adding a spurious space at any
// mid-word run boundary. Strip the bare "\n" separators (real spaces sit adjacent, kept).
function collapseRunWhitespace(odtBytes: Uint8Array): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  content = content.replace(
    /<text:(p|h)\b(?:[^>]*[^/>])?>[\s\S]*?<\/text:\1>/g,
    (block) => block.replace(/\n/g, ''),
  );

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Rewrite the inline sentinels planted before serialization into real ODF elements:
// LBR → <text:line-break/>, TAB → <text:tab/> (both valid as bare paragraph text and
// inside <text:span>), and complete the decimal stop odf-kit only half-writes.
const CHAR_TAB_STOP = 'style:type="char"';

// The ODF line kind that goes with a fill character.
const ODF_LEADER_STYLE: Record<string, string> = { '.': 'dotted', '·': 'dotted', '-': 'dash', '_': 'solid' };

// odf-kit has no leader option and mints one automatic style per distinct option set,
// so the leader rides style:type — where a bare map would give two stops that agree on
// position and alignment the same style, and with it the same leader.
function applyTabLeaders(odtBytes: Uint8Array): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;
  let content = strFromU8(contentBytes);
  if (!content.includes(LEAD)) return odtBytes;
  content = content.replace(new RegExp(`style:type="([a-z]+)${LEAD}(.)"`, 'g'), (_m, type, ch) =>
    `style:type="${type}" style:leader-style="${ODF_LEADER_STYLE[ch]}" style:leader-text="${ch}"`);
  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

function applyInlineSentinels(odtBytes: Uint8Array): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  if (!content.includes(LBR) && !content.includes(TAB) && !content.includes(CHAR_TAB_STOP)) return odtBytes;

  content = content.split(LBR).join('<text:line-break/>').split(TAB).join('<text:tab/>');
  content = content.split(CHAR_TAB_STOP).join(`${CHAR_TAB_STOP} style:char="."`);
  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// ODF draw:transform for a rotated frame/shape. ODF rotate() is CCW radians (ours is
// CW degrees) about the origin, so the translate re-centres it on the unrotated box.
function frameTransform(rotationDeg: number, widthCm: number, heightCm: number): string {
  if (!rotationDeg || !widthCm || !heightCm) return '';
  const a = (-rotationDeg * Math.PI) / 180;
  const cw = widthCm / 2;
  const ch = heightCm / 2;
  const cos = Math.cos(a);
  const sin = Math.sin(a);
  const r3 = (v: number) => Math.round(v * 1000) / 1000;
  const tx = r3(cos * cw - sin * ch - cw);
  const ty = r3(sin * cw + cos * ch - ch);
  return ` draw:transform="rotate (${a.toFixed(6)}) translate (${tx}cm ${ty}cm)"`;
}

function imageTransform(img: ImageExport): string {
  return frameTransform(img.rotationDeg, img.widthCm, img.heightCm);
}

// ODF style:wrap is the side TEXT flows on (inverse of the image side); horizontal-pos
// places the frame on that side. topBottom ⇒ no wrap, placed at noneAlign — centred
// for an image, but a box with no align of its own sits at the left, as the editor
// draws it. An offset frame is placed by coordinate instead (svg:x on the frame).
function imageWrapProps(wrap: WrapMode, offset: number | null, align?: string | null, distCm?: number | null, noneAlign = 'center'): string {
  const pos = offset != null ? 'from-left' : null;
  // Only the text side is written; the frame's own offset covers the other one.
  const gap = distCm ? ` fo:margin-${wrap === 'right' ? 'left' : 'right'}="${distCm}cm"` : '';
  if (wrap === 'left') return `style:wrap="right" style:horizontal-pos="${pos ?? 'left'}"${gap}`;
  if (wrap === 'right') return `style:wrap="left" style:horizontal-pos="${pos ?? 'right'}"${gap}`;
  return `style:wrap="none" style:horizontal-pos="${align ?? pos ?? noneAlign}"`;
}

// The inverse of the importer's as-char alignment map (import/odt.ts): a frame with no
// entry stands on the baseline, which is what a style-less as-char frame does anyway.
const INLINE_VALIGN_ODF: Record<string, string> = {
  middle: 'style:vertical-pos="middle" style:vertical-rel="baseline"',
  below: 'style:vertical-pos="bottom" style:vertical-rel="baseline"',
  'text-top': 'style:vertical-pos="top" style:vertical-rel="text"',
  'text-middle': 'style:vertical-pos="middle" style:vertical-rel="text"',
  'text-bottom': 'style:vertical-pos="bottom" style:vertical-rel="text"',
  offset: 'style:vertical-pos="from-top" style:vertical-rel="text"',
};

// Graphic style for a floating frame (wrap + side, anchored to the paragraph top).
// Inline images need none. Injected into content.xml automatic-styles by applyImages.
function imageGraphicStyle(img: ImageExport, index: number): string {
  if (img.anchorPage) {
    return (
      `<style:style style:name="ImgFr${index + 1}" style:family="graphic">` +
      `<style:graphic-properties style:wrap="run-through" style:run-through="${img.inFront ? 'foreground' : 'background'}"` +
      ` style:horizontal-rel="page" style:horizontal-pos="from-left"` +
      ` style:vertical-rel="page" style:vertical-pos="from-top"/></style:style>`
    );
  }
  if (img.wrap === 'inline') {
    const v = INLINE_VALIGN_ODF[img.vAlign ?? ''];
    return v
      ? `<style:style style:name="ImgFr${index + 1}" style:family="graphic">` +
        `<style:graphic-properties style:wrap="none" ${v}/></style:style>`
      : '';
  }
  return (
    `<style:style style:name="ImgFr${index + 1}" style:family="graphic">` +
    `<style:graphic-properties ${imageWrapProps(img.wrap, img.wrapOffsetCm, img.wrapAlign, img.wrapDistCm)}` +
    ` style:number-wrapped-paragraphs="no-limit"` +
    ` style:horizontal-rel="paragraph-content"` +
    ` style:vertical-pos="${img.wrapOffsetYCm != null ? 'from-top' : 'top'}" style:vertical-rel="paragraph"/>` +
    `</style:style>`
  );
}

// One <draw:frame>. Inline = as-character (text-flow anchor). Floating = paragraph
// anchor + a graphic style (wrap + side). Size is the exact svg geometry and rotation
// the draw:transform, so all of it round-trips.
function imageFrameXml(img: ImageExport, index: number): string {
  const dims =
    (img.widthCm ? ` svg:width="${img.widthCm}cm"` : '') +
    (img.heightCm ? ` svg:height="${img.heightCm}cm"` : '');
  const title = img.alt ? `<svg:title>${escapeXml(img.alt)}</svg:title>` : '';
  const inner = `<draw:image xlink:href="${img.path}"/>${title}`;
  const floats = img.anchorPage != null || img.wrap !== 'inline';
  const anchor = img.anchorPage != null
    ? ` text:anchor-type="page" text:anchor-page-number="${img.anchorPage}"`
    : ` text:anchor-type="${floats ? 'paragraph' : 'as-char'}"`;
  const named = floats || (img.vAlign != null && img.vAlign in INLINE_VALIGN_ODF);
  const styleName = named ? ` draw:style-name="ImgFr${index + 1}"` : '';
  const x = img.wrapOffsetCm != null && floats && !img.wrapAlign ? ` svg:x="${img.wrapOffsetCm}cm"` : '';
  // An as-char frame carries svg:y only for the offset alignment, which is what it means.
  const y = img.wrapOffsetYCm != null && (floats || img.vAlign === 'offset')
    ? ` svg:y="${img.wrapOffsetYCm}cm"` : '';
  return (
    `<draw:frame draw:name="Image${index + 1}"${styleName}${anchor} draw:z-index="${index}"${dims}${x}${y}${imageTransform(img)}>` +
    `${inner}</draw:frame>`
  );
}

// <draw:frame> for a header/footer image. As-character by default; a positioned frame
// (a page-anchored background) instead rides the zone paragraph at its page corner
// offset, run through behind the text. Distinct draw:name per frame.
function hfImageFrameXml(img: ImageExport, index: number): string {
  const dims =
    (img.widthCm ? ` svg:width="${img.widthCm}cm"` : '') +
    (img.heightCm ? ` svg:height="${img.heightCm}cm"` : '');
  const title = img.alt ? `<svg:title>${escapeXml(img.alt)}</svg:title>` : '';
  const anchor =
    img.wrap === 'inline'
      ? `text:anchor-type="as-char"`
      : `text:anchor-type="paragraph" draw:style-name="${HF_BG_STYLE}${index + 1}"` +
        ` svg:x="${img.wrapOffsetCm ?? 0}cm" svg:y="${img.wrapOffsetYCm ?? 0}cm"`;
  return (
    `<draw:frame draw:name="HfImage${index + 1}" ${anchor} draw:z-index="${index}"${dims}>` +
    `<draw:image xlink:href="${img.path}"/>${title}</draw:frame>`
  );
}

const HF_BG_STYLE = 'HfBg';

// The graphic style a page-anchored zone frame points at: positioned from the page's
// top-left corner and run through behind the text, as LibreOffice writes a watermark.
function hfBackgroundStyleXml(index: number): string {
  return (
    `<style:style style:name="${HF_BG_STYLE}${index + 1}" style:family="graphic">` +
    `<style:graphic-properties style:wrap="run-through" style:run-through="background"` +
    ` style:horizontal-rel="page" style:horizontal-pos="from-left"` +
    ` style:vertical-rel="page" style:vertical-pos="from-top"/></style:style>`
  );
}

// Inject automatic styles into content.xml or styles.xml, tolerating an empty/self-closed
// or absent section — a document odf-kit gave none writes `<office:automatic-styles/>`, and
// a plain string replace on the closing tag would drop the styles there.
function injectAutomaticStyles(content: string, styles: string): string {
  if (!styles) return content;
  if (content.includes('</office:automatic-styles>')) {
    return content.replace('</office:automatic-styles>', `${styles}</office:automatic-styles>`);
  }
  const section = `<office:automatic-styles>${styles}</office:automatic-styles>`;
  if (content.includes('<office:automatic-styles/>')) {
    return content.replace('<office:automatic-styles/>', section);
  }
  return content.replace(/<office:(body|master-styles)\b/, (m) => `${section}${m}`);
}

// Resolve image sentinels: swap each IMG{i}IMG for its <draw:frame>, add the binary
// picture files, and register each in META-INF/manifest.xml. content.xml already
// declares the draw/svg/xlink namespaces and rezipOdt handles binary entries.
function applyImages(odtBytes: Uint8Array, images: ImageExport[]): Uint8Array {
  if (!images.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  content = content.replace(new RegExp(`${IMG}(\\d+)${IMG}`, 'g'), (_m, idx: string) => {
    const i = Number(idx);
    const img = images[i];
    return img ? imageFrameXml(img, i) : '';
  });
  // Graphic styles for the floating frames.
  content = injectAutomaticStyles(content, images.map((img, i) => imageGraphicStyle(img, i)).join(''));
  files['content.xml'] = strToU8(content);

  for (const img of images) files[img.path] = img.bytes;

  const manifestBytes = files['META-INF/manifest.xml'];
  if (manifestBytes) {
    const entries = images
      .map(img => `<manifest:file-entry manifest:full-path="${img.path}" manifest:media-type="${img.mimeType}"/>`)
      .join('');
    const manifest = strFromU8(manifestBytes).replace('</manifest:manifest>', `${entries}</manifest:manifest>`);
    files['META-INF/manifest.xml'] = strToU8(manifest);
  }

  return rezipOdt(files);
}

// The formula sub-document: an ODF formula document's content.xml is the MathML root
// itself. The LaTeX rides in an annotation so our own files re-import exactly; other
// readers ignore it and typeset the presentation markup.
function formulaObjectXml(f: FormulaExport): string {
  return `<?xml version="1.0" encoding="UTF-8"?>${mathmlDocument(parseLatex(f.latex), f.display, f.latex)}`;
}

// Resolve formula sentinels: swap each MTH{i}MTH for a <draw:frame> pointing at an
// embedded formula object, write that object's content.xml, and register both it and
// its directory in META-INF/manifest.xml — the same shape as applyImages.
function applyFormulas(odtBytes: Uint8Array, formulas: FormulaExport[]): Uint8Array {
  if (!formulas.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  content = content.replace(new RegExp(`${MTH}(\\d+)${MTH}`, 'g'), (_m, idx: string) => {
    const i = Number(idx);
    const f = formulas[i];
    if (!f) return '';
    // No svg:width/height on purpose: with a size the consumer scales the object to
    // fit it (LibreOffice magnifies a too-wide frame); without one it typesets the
    // formula at its natural size, matched to the surrounding text.
    return (
      `<draw:frame draw:name="Formula${i + 1}" draw:style-name="MthFr" text:anchor-type="as-char" draw:z-index="${i}">` +
      `<draw:object xlink:href="./Formula${i + 1}" xlink:type="simple" xlink:show="embed" xlink:actuate="onLoad"/></draw:frame>`
    );
  });
  // One shared graphic style: an as-char formula sits on the text baseline, which is
  // what LibreOffice writes for its own formula frames.
  content = injectAutomaticStyles(content,
    '<style:style style:name="MthFr" style:family="graphic">' +
    '<style:graphic-properties style:vertical-pos="middle" style:vertical-rel="text"' +
    ' fo:padding="0cm" fo:border="none"/></style:style>');
  files['content.xml'] = strToU8(content);

  for (const [i, f] of formulas.entries()) {
    files[`Formula${i + 1}/content.xml`] = strToU8(formulaObjectXml(f));
  }

  const manifestBytes = files['META-INF/manifest.xml'];
  if (manifestBytes) {
    const entries = formulas
      .map((_f, i) =>
        `<manifest:file-entry manifest:full-path="Formula${i + 1}/" manifest:media-type="application/vnd.oasis.opendocument.formula"/>` +
        `<manifest:file-entry manifest:full-path="Formula${i + 1}/content.xml" manifest:media-type="text/xml"/>`)
      .join('');
    files['META-INF/manifest.xml'] = strToU8(
      strFromU8(manifestBytes).replace('</manifest:manifest>', `${entries}</manifest:manifest>`));
  }

  return rezipOdt(files);
}

// Ensure content.xml declares the number namespace (odf-kit may omit it); the minted
// <number:date-style>/<number:time-style> and their references need the prefix.
function ensureNumberNamespace(content: string): string {
  if (content.includes('xmlns:number=')) return content;
  return content.replace(
    /<office:document-content\b/,
    '<office:document-content xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0"',
  );
}

// Resolve date/time field sentinels: swap each DTF{i}DTF for a <text:date>/<text:time>
// carrying the displayed value, the ISO date/time-value, text:fixed, and a minted
// data style. Auto fields render (and store) the current moment; fixed ones use `value`.
function applyDateTimeFields(odtBytes: Uint8Array, fields: DateTimeFieldExport[], lang: { language: string; country: string } | null): Uint8Array {
  if (!fields.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  const tag = localeTag(lang ? `${lang.language}` : 'en');
  // One data style per distinct format actually used; reference it by minted name.
  const styleNames = new Map<string, string>();
  const mintedStyles: string[] = [];
  const styleFor = (fmt: DtFormat): string => {
    const existing = styleNames.get(fmt.key);
    if (existing) return existing;
    const name = `Ndt${styleNames.size + 1}`;
    styleNames.set(fmt.key, name);
    mintedStyles.push(odfNumberStyle(fmt, name, lang));
    return name;
  };

  let content = strFromU8(contentBytes);
  content = content.replace(new RegExp(`${DTF}(\\d+)${DTF}`, 'g'), (_m, idx: string) => {
    const field = fields[Number(idx)];
    if (!field) return '';
    const fmt = findFormat(field.format)
      ?? findFormat(field.kind === 'time' ? DEFAULT_TIME_FORMAT : DEFAULT_DATE_FORMAT)!;
    const parsed = field.fixed && field.value ? new Date(field.value) : new Date();
    const when = isNaN(parsed.getTime()) ? new Date() : parsed;
    const display = escapeXml(renderFormat(fmt, when, tag));
    const styleName = styleFor(fmt);
    const fixedAttr = ` text:fixed="${field.fixed ? 'true' : 'false'}"`;
    if (fmt.kind === 'time') {
      return `<text:time text:time-value="${toTimeValue(when)}"${fixedAttr} style:data-style-name="${styleName}">${display}</text:time>`;
    }
    return `<text:date text:date-value="${toDateValue(when)}"${fixedAttr} style:data-style-name="${styleName}">${display}</text:date>`;
  });

  content = ensureNumberNamespace(content);
  content = injectAutomaticStyles(content, mintedStyles.join(''));
  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Graphic style for a text box / shape: fill, stroke, text padding, auto-grow, and —
// for floating boxes — the same wrap/position props as floating images.
function textBoxGraphicStyle(box: TextBoxExport, index: number): string {
  const r3 = (v: number) => Math.round(v * 1000) / 1000;
  const fill = box.fill
    ? `draw:fill="solid" draw:fill-color="${normalizeColor(box.fill) ?? '#FFFFFF'}"`
    : 'draw:fill="none"';
  const stroke = box.stroke
    ? `draw:stroke="solid" svg:stroke-color="${normalizeColor(box.stroke) ?? '#000000'}" svg:stroke-width="${r3(box.strokeWidthPt)}pt"`
    : 'draw:stroke="none"';
  // An as-char frame keeps only its horizontal-pos: that is what centres a figure
  // frame, and the anchor paragraph this export mints carries no alignment.
  const wrap = box.wrap === 'inline'
    ? (box.wrapAlign ? ` style:horizontal-pos="${box.wrapAlign}" style:horizontal-rel="paragraph-content"` : '')
    : ` ${imageWrapProps(box.wrap, box.wrapOffsetCm, box.wrapAlign, box.wrapDistCm, 'left')} style:number-wrapped-paragraphs="no-limit"` +
      ` style:horizontal-rel="paragraph-content"` +
      ` style:vertical-pos="${box.wrapOffsetYCm != null ? 'from-top' : 'top'}" style:vertical-rel="paragraph"`;
  // auto-grow only for plain text boxes; a custom-shape needs both explicitly
  // false, or LibreOffice's shape autofit shrinks it to its text.
  const grow = box.shapeKind === 'textbox' && !box.shapePath
    ? ' draw:auto-grow-height="true"'
    : ' draw:auto-grow-height="false" draw:auto-grow-width="false"';
  // An arrow head is a named marker in ODF, defined once in styles.xml.
  const heads = SHAPES[box.shapeKind].line;
  const marker = (side: 'start' | 'end') =>
    ` draw:marker-${side}="${ODF_ARROW}" draw:marker-${side}-width="${arrowHeadCm(box.strokeWidthPt)}cm"`;
  const arrows = heads === 'end' ? marker('end')
    : heads === 'both' ? marker('end') + marker('start') : '';
  // Vertical text is a *paragraph* property of the frame's style — probed: in the
  // graphic properties LibreOffice drops it, here it keeps it and lays the box out.
  const vertical = box.textVertical
    ? '<style:paragraph-properties style:writing-mode="tb-rl"/>'
    : '';
  return (
    `<style:style style:name="TbxFr${index + 1}" style:family="graphic">` +
    `<style:graphic-properties ${fill} ${stroke}${arrows} fo:padding="${box.paddingCm}cm"` +
    `${grow} draw:textarea-vertical-align="top"${wrap}/>${vertical}` +
    `</style:style>`
  );
}

// The anchor paragraph carries the spacing the box stands in for (import/odt.ts hands a
// lifted box its anchor's margins); nothing to mint when it has none.
function textBoxAnchorStyle(box: TextBoxExport, index: number): string {
  if (!box.spaceBeforePt && !box.spaceAfterPt) return '';
  return (
    `<style:style style:name="TbxP${index + 1}" style:family="paragraph" style:parent-style-name="Standard">` +
    `<style:paragraph-properties fo:margin-top="${box.spaceBeforePt}pt" fo:margin-bottom="${box.spaceAfterPt}pt"/>` +
    `</style:style>`
  );
}

// The drawing element wrapping a box's serialized blocks: a <draw:frame>/<draw:text-box>
// for plain text boxes (height = fo:min-height, so it grows with content like the
// editor), or a <draw:custom-shape> with the preset geometry of `utils/shapes.ts`.
function textBoxXml(box: TextBoxExport, inner: string, index: number): string {
  const n = index + 1;
  const anchor = box.wrap === 'inline' ? 'as-char' : 'paragraph';
  const transform = frameTransform(box.rotationDeg, box.widthCm, box.heightCm);
  const at = box.wrap === 'inline' ? ''
    : (box.wrapOffsetCm != null ? ` svg:x="${box.wrapOffsetCm}cm"` : '') +
      (box.wrapOffsetYCm != null ? ` svg:y="${box.wrapOffsetYCm}cm"` : '');
  const common =
    ` draw:style-name="TbxFr${n}" text:anchor-type="${anchor}" draw:z-index="${index}"` +
    ` svg:width="${box.widthCm}cm"${at}`;
  // A line is its two endpoints, so ODF gives it its own element rather than a frame
  // with a width and a height. The blocks the schema keeps on the node are dropped:
  // <draw:line> holds no text, and the editor draws none.
  if (isLineKind(box.shapeKind)) {
    const [y1, y2] = box.flipV ? [box.heightCm, 0] : [0, box.heightCm];
    return (
      `<draw:line draw:name="Line${n}"${common.replace(/ svg:width="[^"]*"/, '')}` +
      ` svg:x1="0cm" svg:y1="${y1}cm" svg:x2="${box.widthCm}cm" svg:y2="${y2}cm"/>`
    );
  }
  if (box.shapeKind === 'textbox' && !box.shapePath) {
    // svg:height for consumers without auto-grow; fo:min-height is the real semantic
    // (height = minimum, content grows the box) and wins on our own re-import.
    return (
      `<draw:frame draw:name="TextBox${n}"${common} svg:height="${box.heightCm}cm"${transform}>` +
      `<draw:text-box fo:min-height="${box.heightCm}cm">${inner}</draw:text-box></draw:frame>`
    );
  }
  // A freeform is its own outline rather than a preset's: `non-primitive` plus the
  // path, which is what LibreOffice writes back out unchanged (probed).
  const geometry = box.shapePath
    ? `<draw:enhanced-geometry svg:viewBox="0 0 21600 21600" draw:type="non-primitive"`
      + ` draw:enhanced-path="${odfEnhancedPath(box.shapePath)}"/>`
    : odfEnhancedGeometry(box.shapeKind) ?? '';
  return (
    `<draw:custom-shape draw:name="Shape${n}"${common} svg:height="${box.heightCm}cm"${transform}>` +
    `${inner}${geometry}</draw:custom-shape>`
  );
}

// LibreOffice's own standard arrow head, name and path alike, so a file we write and
// one it writes carry the same marker rather than two that look the same.
const ODF_ARROW = 'Arrow';
const ODF_ARROW_MARKER = `<draw:marker draw:name="${ODF_ARROW}" svg:viewBox="0 0 20 30" svg:d="m10 0-10 30h20z"/>`;

// Resolve the text-box marker paragraphs: wrap each S{i}…E{i} region (the box's
// hoisted, fully serialized blocks) into its drawing element inside a fresh anchor
// paragraph, and inject the minted graphic styles.
function applyTextBoxes(odtBytes: Uint8Array, boxes: TextBoxExport[]): Uint8Array {
  if (!boxes.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  content = content.replace(
    new RegExp(`<text:p\\b[^>]*>${TBX}S(\\d+)${TBX}</text:p>([\\s\\S]*?)<text:p\\b[^>]*>${TBX}E\\1${TBX}</text:p>`, 'g'),
    (_m, idx: string, inner: string) => {
      const i = Number(idx);
      const box = boxes[i];
      if (!box) return '';
      const style = box.spaceBeforePt || box.spaceAfterPt ? `TbxP${i + 1}` : 'Standard';
      return `<text:p text:style-name="${style}">${textBoxXml(box, inner, i)}</text:p>`;
    },
  );
  content = injectAutomaticStyles(
    content,
    boxes.map((b, i) => textBoxGraphicStyle(b, i) + textBoxAnchorStyle(b, i)).join(''),
  );
  files['content.xml'] = strToU8(content);
  // An arrow head is referenced by name, so its one definition goes where LibreOffice
  // keeps its own — office:styles in styles.xml — and only when a line asks for it.
  const stylesBytes = files['styles.xml'];
  if (stylesBytes && boxes.some((b) => SHAPES[b.shapeKind].line && SHAPES[b.shapeKind].line !== 'none')) {
    const styles = ensureDrawNamespaces(strFromU8(stylesBytes));
    if (!styles.includes(`draw:name="${ODF_ARROW}"`)) {
      files['styles.xml'] = strToU8(styles.replace(/<office:styles(\s[^>]*)?>/, (m) => `${m}${ODF_ARROW_MARKER}`));
    }
  }
  return rezipOdt(files);
}

// Section style for a multi-column region: balanced columns with a uniform gap.
// text:dont-balance-text-columns sits on <style:columns> (not section-properties).
function columnsSectionStyle(cols: ColumnsExport, index: number): string {
  return (
    `<style:style style:name="ColSec${index + 1}" style:family="section">` +
    `<style:section-properties style:editable="false">` +
    `<style:columns fo:column-count="${cols.count}" fo:column-gap="${cols.gapCm}cm"` +
    ` text:dont-balance-text-columns="false"/>` +
    `</style:section-properties></style:style>`
  );
}

// Resolve the columns marker paragraphs: wrap each S{i}…E{i} region (the section's
// hoisted, fully serialized blocks) into a <text:section> — a block-level element,
// so no anchor paragraph — and inject the minted section styles.
function applyColumns(odtBytes: Uint8Array, cols: ColumnsExport[]): Uint8Array {
  if (!cols.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  content = content.replace(
    new RegExp(`<text:p\\b[^>]*>${COL}S(\\d+)${COL}</text:p>([\\s\\S]*?)<text:p\\b[^>]*>${COL}E\\1${COL}</text:p>`, 'g'),
    (_m, idx: string, inner: string) => {
      const i = Number(idx);
      if (!cols[i]) return '';
      return `<text:section text:style-name="ColSec${i + 1}" text:name="ColumnsSection${i + 1}">${inner}</text:section>`;
    },
  );
  content = injectAutomaticStyles(content, cols.map((c, i) => columnsSectionStyle(c, i)).join(''));
  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Minted automatic paragraph style for a TOC entry level: per-level left indent and a
// right tab stop at the text width with a dotted leader (so the page number right-aligns
// with dots, matching the on-screen TOC and Word/LibreOffice).
// The note styles LibreOffice ships, written verbatim so a re-save changes nothing:
// Footnote/Endnote at 10pt with a 0.6cm hanging indent, and the two character styles
// its notes-configuration points at (the anchor raised, the symbol plain).
function notesStyles(): string {
  const para = (name: string) =>
    `<style:style style:name="${name}" style:family="paragraph" style:parent-style-name="Standard" style:class="extra">`
    + `<style:paragraph-properties fo:margin-left="${NOTE_INDENT_CM}cm" fo:text-indent="-${NOTE_INDENT_CM}cm" style:auto-text-indent="false"/>`
    + `<style:text-properties fo:font-size="${NOTE_FONT_SIZE_PT}pt" style:font-size-asian="${NOTE_FONT_SIZE_PT}pt" style:font-size-complex="${NOTE_FONT_SIZE_PT}pt"/>`
    + '</style:style>';
  const anchor = (name: string, display: string) =>
    `<style:style style:name="${name}" style:display-name="${display}" style:family="text">`
    + '<style:text-properties style:text-position="super 58%"/></style:style>';
  return para('Footnote') + para('Endnote')
    + `<style:style style:name="Footnote_20_Symbol" style:display-name="Footnote Symbol" style:family="text"/>`
    + `<style:style style:name="Endnote_20_Symbol" style:display-name="Endnote Symbol" style:family="text"/>`
    + anchor('Footnote_20_anchor', 'Footnote anchor')
    + anchor('Endnote_20_anchor', 'Endnote anchor');
}

// <text:notes-configuration> per class. ODF counts start-value from 0, so the first
// note of a class carries startAt - 1.
function notesConfiguration(settings: NoteSettings): string {
  const one = (kind: NoteKind) => {
    const s = settings[kind];
    const foot = kind === 'footnote';
    const prefix = s.prefix ? ` style:num-prefix="${escapeXml(s.prefix)}"` : '';
    const suffix = s.suffix ? ` style:num-suffix="${escapeXml(s.suffix)}"` : '';
    return `<text:notes-configuration text:note-class="${kind}"`
      + ` text:citation-style-name="${odfStyleName(s.citationStyle)}"`
      + ` text:citation-body-style-name="${foot ? 'Footnote_20_anchor' : 'Endnote_20_anchor'}"`
      + ` text:default-style-name="${odfStyleName(s.bodyStyle)}"`
      + ` style:num-format="${s.numFormat}"${prefix}${suffix}`
      + ` text:start-value="${Math.max(0, s.startAt - 1)}"`
      + (foot ? ` text:footnotes-position="${s.position}" text:start-numbering-at="${s.restart}"` : '')
      + '/>';
  };
  return one('footnote') + one('endnote');
}

// <style:footnote-sep> lives inside the page layout's own properties, not the styles.
function footnoteSepXml(sep: NoteSettings['separator']): string {
  const round3 = (v: number) => Math.round(v * 1000) / 1000;
  return `<style:footnote-sep style:width="${round3((sep.weightPt / 72) * 2.54)}cm"`
    + ` style:distance-before-sep="${round3(sep.spaceAboveCm)}cm"`
    + ` style:distance-after-sep="${round3(sep.spaceBelowCm)}cm"`
    + ` style:line-style="solid" style:adjustment="${sep.align}"`
    + ` style:rel-width="${round3(sep.relWidthPercent)}%" style:color="${sep.color}"/>`;
}

function contentsEntryStyle(name: string, level: number, tabPosCm: number): string {
  const indentCm = level === 2 ? 0.6 : level === 3 ? 1.2 : 0;
  const margin = indentCm > 0 ? ` fo:margin-left="${indentCm}cm"` : '';
  return (
    `<style:style style:name="${name}" style:family="paragraph" style:parent-style-name="Standard">` +
    `<style:paragraph-properties${margin}>` +
    `<style:tab-stops><style:tab-stop style:position="${tabPosCm}cm" style:type="right" style:leader-style="dotted" style:leader-text="."/></style:tab-stops>` +
    `</style:paragraph-properties></style:style>`
  );
}

// The index title style (bold, 16pt) — mirrors the .toc-title on screen.
function contentsHeadingStyle(name: string): string {
  return (
    `<style:style style:name="${name}" style:family="paragraph" style:parent-style-name="Standard">` +
    `<style:paragraph-properties fo:margin-top="0cm" fo:margin-bottom="0.3cm"/>` +
    `<style:text-properties fo:font-size="16pt" fo:font-weight="bold"/></style:style>`
  );
}

// A level's entry style: the file's own named one where the index came with it, else the
// automatic Contents_20_N this export mints.
function tocLevelStyle(toc: TocExport, level: number): string {
  const own = toc.levelStyles?.[level - 1];
  return own ? odfStyleName(own) : `${ODF_INDEX[toc.kind].entryStyle}${level}`;
}

// ODF has one element family per index. A caption index is single-level and finds its
// entries by the counter's name, so its template carries no text:outline-level.
const ODF_INDEX: Record<IndexKind, { el: string; heading: string; entryStyle: string; docName: string; seq?: string }> = {
  toc: { el: 'table-of-content', heading: 'Contents_20_Heading', entryStyle: 'Contents_20_', docName: 'Table of Contents' },
  figures: { el: 'illustration-index', heading: 'Illustration_20_Index_20_Heading', entryStyle: 'Illustration_20_Index_20_', docName: 'Illustration Index', seq: 'Illustration' },
  tables: { el: 'table-index', heading: 'Table_20_Index_20_Heading', entryStyle: 'Table_20_Index_20_', docName: 'Table Index', seq: 'Table' },
  alphabetical: { el: 'alphabetical-index', heading: 'Index_20_Heading', entryStyle: 'Index_20_', docName: 'Alphabetical Index' },
  bibliography: { el: 'bibliography', heading: 'Bibliography_20_Heading', entryStyle: 'Bibliography_20_', docName: 'Bibliography' },
};

// A bibliography's entry template is per source type, and LibreOffice regenerates the
// rows from it — so it spells out the citation style's own row, token for token (which
// is what an ODF template is). Only the types actually cited get one; the rest
// LibreOffice fills in itself.
function bibEntryTemplates(style: string, types: string[], cite: CitationStyle): string {
  const body = rowTemplate(cite).map(t => ('field' in t
    ? `<text:index-entry-bibliography text:bibliography-data-field="${t.field}"/>`
    : `<text:index-entry-span>${escapeXml(t.text)}</text:index-entry-span>`)).join('');
  return (types.length ? types : ['book'])
    .map(t => `<text:bibliography-entry-template text:bibliography-type="${t}" text:style-name="${style}">${body}</text:bibliography-entry-template>`)
    .join('');
}

function tocXml(toc: TocExport, index: number, bibTypes: string[]): string {
  const spec = ODF_INDEX[toc.kind];
  const title = toc.title ?? INDEX_TITLES[toc.kind];
  const name = `${spec.docName}${index + 1}`;
  const stop =
    `<text:index-entry-tab-stop style:type="right"` +
    `${toc.tabPosCm ? ` style:position="${toc.tabPosCm}cm"` : ''}` +
    `${toc.leader ? ` style:leader-char="${escapeXml(toc.leader)}"` : ''}/>`;
  const entry = (levelAttr: string, style: string) =>
    `<text:${spec.el}-entry-template${levelAttr} text:style-name="${style}">` +
    `<text:index-entry-link-start/><text:index-entry-text/>${stop}` +
    `<text:index-entry-page-number/><text:index-entry-link-end/>` +
    `</text:${spec.el}-entry-template>`;
  // An alphabetical index is fed by its marks, is single-level, and merges the pages of
  // a term the reader marked more than once — LibreOffice's text:combine-entries.
  const sourceAttrs = toc.kind === 'bibliography'
    // LibreOffice's own two flags for a numbered bibliography: [1] before each row, and
    // the rows in the order the document cites them rather than sorted.
    ? (toc.citationStyle === 'numbered' ? ' text:numbered-entries="true" text:sort-by-position="true"' : '')
    : toc.kind === 'alphabetical'
    ? ' text:combine-entries="true" text:ignore-case="true"'
    : spec.seq
      ? ` text:use-caption="true" text:caption-sequence-name="${spec.seq}" text:caption-sequence-format="category-and-value"`
      : ` text:outline-level="${toc.maxLevel}" text:use-index-marks="false" text:use-index-source-styles="false"`;
  const templates = toc.kind === 'bibliography'
    ? bibEntryTemplates(tocLevelStyle(toc, 1), bibTypes, toc.citationStyle)
    : spec.seq
    ? entry('', tocLevelStyle(toc, 1))
    : toc.kind === 'alphabetical'
      ? entry(' text:outline-level="1"', tocLevelStyle(toc, 1))
      : HEADING_LEVELS.filter(l => l <= toc.maxLevel)
          .map(l => entry(` text:outline-level="${l}"`, tocLevelStyle(toc, l)))
          .join('');
  const source =
    `<text:${spec.el}-source${sourceAttrs}>` +
    (title ? `<text:index-title-template text:style-name="${spec.heading}">${escapeXml(title)}</text:index-title-template>` : '') +
    templates +
    `</text:${spec.el}-source>`;
  const body =
    `<text:index-body>` +
    (title
      ? `<text:index-title text:name="${escapeXml(name)}_Head">` +
        `<text:p text:style-name="${spec.heading}">${escapeXml(title)}</text:p>` +
        `</text:index-title>`
      : '') +
    toc.entries
      .map(e => `<text:p text:style-name="${tocLevelStyle(toc, e.level)}">${escapeXml(e.text).replace(/\n/g, '<text:line-break/>')}`
        // A bibliography row is the source, nothing else: no tab, no page number.
        + (toc.kind === 'bibliography' ? '' : `<text:tab/>${e.pages?.join(', ') ?? e.page}`) + '</text:p>')
      .join('') +
    `</text:index-body>`;
  return `<text:${spec.el} text:name="${escapeXml(name)}" text:protected="true">${source}${body}</text:${spec.el}>`;
}

// BMS/BME/XRF sentinels → <text:bookmark-start/>, <text:bookmark-end/> and
// <text:bookmark-ref>. All three are legal anywhere in paragraph content, so a plain
// replace works wherever odf-kit put the run — inside a <text:span> included.
function applyBookmarks(odtBytes: Uint8Array, refs: CrossRefExport[]): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  if (!content.includes(BMS) && !content.includes(XRF)) return odtBytes;

  content = content
    .replace(new RegExp(`${BMS}([^${BMS}]*)${BMS}`, 'g'), (_m, name: string) => `<text:bookmark-start text:name="${name}"/>`)
    .replace(new RegExp(`${BME}([^${BME}]*)${BME}`, 'g'), (_m, name: string) => `<text:bookmark-end text:name="${name}"/>`)
    .replace(new RegExp(`${XRF}(\\d+)${XRF}([^${XRF}]*)${XRF}`, 'g'), (_m, idx: string, shown: string) => {
      const ref = refs[Number(idx)];
      if (!ref) return shown;
      return `<text:bookmark-ref text:reference-format="${ref.format}" text:ref-name="${ref.name}">${shown}</text:bookmark-ref>`;
    });

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// CMS/CME sentinels → <office:annotation> (author, date and body) and
// <office:annotation-end/>. content.xml declares neither dc: nor loext:, so the two
// namespaces are added on the root when a document actually has comments.
function applyComments(odtBytes: Uint8Array, list: CommentExport[]): Uint8Array {
  if (!list.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  if (!content.includes(CMS)) return odtBytes;

  content = content
    .replace(new RegExp(`${CMS}(\\d+)${CMS}`, 'g'), (_m, idx: string) => {
      const c = list[Number(idx)];
      if (!c) return '';
      // LibreOffice reads its own resolved flag off loext: and writes it either way;
      // its comment bodies carry the pool's Comment paragraph style.
      const body = c.text.split('\n').map(line => `<text:p text:style-name="Comment">${escapeXml(line)}</text:p>`).join('');
      return `<office:annotation office:name="${escapeXml(c.name)}" loext:resolved="${c.resolved}">`
        + (c.author ? `<dc:creator>${escapeXml(c.author)}</dc:creator>` : '')
        + (c.date ? `<dc:date>${escapeXml(c.date)}</dc:date>` : '')
        + (body || '<text:p text:style-name="Comment"/>')
        + '</office:annotation>';
    })
    .replace(new RegExp(`${CME}(\\d+)${CME}`, 'g'), (_m, idx: string) => {
      const c = list[Number(idx)];
      return c ? `<office:annotation-end office:name="${escapeXml(c.name)}"/>` : '';
    });

  // applyRevisions may already have declared dc:; declaring either twice is invalid XML.
  content = ensureDcNamespace(content);
  if (!content.includes('xmlns:loext=')) {
    content = content.replace('<office:document-content ',
      '<office:document-content xmlns:loext="urn:org:documentfoundation:names:experimental:office:xmlns:loext:1.0" ');
  }

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Cut each hoisted note paragraph out of content.xml and splice its runs into a
// <text:note> at the anchor sentinel. Runs last of the content.xml passes, so the note
// text carries everything the earlier ones resolved inside it.
function applyNotes(odtBytes: Uint8Array, notes: NoteExport[]): Uint8Array {
  if (!notes.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  if (!content.includes(FNT)) return odtBytes;

  // The note's runs, taken out of the paragraph the hoist gave it. A wrapper span may
  // hold the sentinel, so it is cut by string and the empty remains are swept after.
  const bodies: string[] = notes.map((_note, i) => {
    const open = `${FNT}B${i}${FNT}`;
    const at = content.indexOf(open);
    if (at < 0) return '';
    const start = content.lastIndexOf('<text:p', at);
    const end = content.indexOf('</text:p>', at);
    if (start < 0 || end < 0) return '';
    const block = content.slice(start, end + '</text:p>'.length);
    content = content.slice(0, start) + content.slice(end + '</text:p>'.length);
    return block
      .replace(/^<text:p\b[^>]*>/, '')
      .replace(/<\/text:p>$/, '')
      .replace(open, '')
      .replace(/<text:span\b[^>]*\/>|<text:span\b[^>]*><\/text:span>/g, '');
  });

  content = content.replace(new RegExp(`${FNT}A(\\d+)${FNT}`, 'g'), (_m, idx: string) => {
    const i = Number(idx);
    const note = notes[i];
    if (!note) return '';
    const endnote = note.kind === 'endnote';
    const label = note.label ? ` text:label="${escapeXml(note.label)}"` : '';
    return `<text:note text:id="${endnote ? 'edn' : 'ftn'}${i + 1}" text:note-class="${note.kind}">`
      + `<text:note-citation${label}>${escapeXml(note.citation)}</text:note-citation>`
      + `<text:note-body><text:p text:style-name="${odfStyleName(note.styleName ?? (endnote ? 'Endnote' : 'Footnote'))}">${bodies[i]}</text:p></text:note-body>`
      + '</text:note>';
  });
  // Defensive: strip any sentinel the passes above left behind.
  content = content.split(FNT).join('');

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

function applyToc(odtBytes: Uint8Array, tocs: TocExport[], contentWidthCm: number, bibTypes: string[]): Uint8Array {
  if (!tocs.length) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;

  let content = strFromU8(contentBytes);
  if (!content.includes(TOC_SENT)) return odtBytes;

  content = content.replace(
    new RegExp(`<text:p\\b[^>]*>${TOC_SENT}(\\d+)${TOC_SENT}</text:p>`, 'g'),
    (_m, idx: string) => {
      const toc = tocs[Number(idx)];
      return toc ? tocXml(toc, Number(idx), bibTypes) : '';
    },
  );
  // Defensive: strip any sentinels not consumed above.
  content = content.split(TOC_SENT).join('');

  const tabPosCm = Math.max(1, Math.round(contentWidthCm * 1000) / 1000);
  // One set of entry styles per index family actually present; a caption index has the
  // single level its ODF template declares.
  const styles = [...new Set(tocs.map(t => t.kind))]
    .map((kind) => {
      const spec = ODF_INDEX[kind];
      const levels = kind === 'toc' ? HEADING_LEVELS : [1];
      return contentsHeadingStyle(spec.heading)
        + levels.map(l => contentsEntryStyle(`${spec.entryStyle}${l}`, l, tabPosCm)).join('');
    })
    .join('');
  content = injectAutomaticStyles(content, styles);

  files['content.xml'] = strToU8(content);
  return rezipOdt(files);
}

// Header/footer input for the export: one single-paragraph doc per zone (or null),
// the page count snapshot for the stored <text:page-count> value, and the page-edge
// distances (cm; default HF_DISTANCE_CM) for header (from top) / footer (from bottom).
export type HfExport = {
  header: HfDoc;
  footer: HfDoc;
  // First-page overrides (Word titlePg / ODF header-first); only used when
  // differentFirstPage is set. null = the first page's zone is blank.
  headerFirst?: HfDoc;
  footerFirst?: HfDoc;
  differentFirstPage?: boolean;
  // Even-page overrides (Word evenAndOddHeaders / ODF header-left); only used when
  // differentOddEven is set. null = the even pages' zone is blank.
  headerEven?: HfDoc;
  footerEven?: HfDoc;
  differentOddEven?: boolean;
  // One set per section, in body order; [0] repeats the fields above. Absent = the
  // document has a single section.
  sections?: HfSet[];
  pageCount: number;
  headerDistanceCm?: number;
  footerDistanceCm?: number;
};

// The full document → .odt pipeline, DOM-free; returns the .odt bytes.
export async function buildOdt(docJson: TiptapNode, margins: PageMargins = DEFAULT_MARGINS, orientation: Orientation = 'portrait', hf?: HfExport, language?: { language: string; country: string } | null, pageFormat: PageFormat = 'A4', styles: StyleSheet = builtinStyleSheet(), tabIntervalCm: number = DEFAULT_TAB_INTERVAL_CM, spacingModel: SpacingModel = 'add', rtl = false, notesSettings: NoteSettings = DEFAULT_NOTE_SETTINGS, props: DocProperties = EMPTY_DOC_PROPERTIES, hyphenate = false, pageNumbering: PageNumbering = DEFAULT_PAGE_NUMBERING, decor: PageDecor = EMPTY_PAGE_DECOR, lineNumbering: LineNumbering = DEFAULT_LINE_NUMBERING, recordChanges = false): Promise<Uint8Array> {
  // Images become IMG sentinels before serialization; applyImages resolves them and writes
  // the Pictures/ + manifest entries. Text boxes and columns hoist after replacePageBreaks
  // (so PGB misses their blocks) and before the inline passes (which then cover them).
  exportSheet = styles;
  exportSpacingModel = spacingModel;
  const images: ImageExport[] = [];
  const tocs: TocExport[] = [];
  const textBoxes: TextBoxExport[] = [];
  const columns: ColumnsExport[] = [];
  const dateFields: DateTimeFieldExport[] = [];
  const formulas: FormulaExport[] = [];
  const crossRefs: CrossRefExport[] = [];
  const notes: NoteExport[] = [];
  const commentList: CommentExport[] = [];
  const seqFields: SequenceExport[] = [];
  const revisionList = new Map<string, RevisionExport>();
  const indexMarks: IndexEntryExport[] = [];
  const bibMarks: BibExport[] = [];
  const rubies: RubyExport[] = [];
  const sentinels = replaceRuby(replaceBibEntries(replaceIndexEntries(replaceRevisions(replaceSequenceFields(replaceComments(replaceBookmarks(replaceFormulas(replaceDateTimeFields(replaceImages(replaceTabs(replaceHardBreaks(replaceSectionBreaks(replaceNotes(replaceColumns(replaceTextBoxes(replacePageBreaks(replaceTableOfContents(docJson, tocs)), textBoxes), columns), notes)))), images), dateFields), formulas), crossRefs), commentList), seqFields), revisionList), indexMarks), bibMarks), rubies);
  const raw = markTextEffects(bakeListCharStyles(sentinels, styles), DEFAULT_FONT_SIZE_PT, styles);
  let headerPara = hf && !hfIsEmpty(hf.header) ? (hf.header!.content![0] as TiptapNode) : null;
  let footerPara = hf && !hfIsEmpty(hf.footer) ? (hf.footer!.content![0] as TiptapNode) : null;
  // Different first page (ODF header-first): page 1 gets its own zone content.
  const differentFirstPage = !!hf?.differentFirstPage;
  let firstHeaderPara = differentFirstPage && hf && !hfIsEmpty(hf.headerFirst ?? null) ? (hf.headerFirst!.content![0] as TiptapNode) : null;
  let firstFooterPara = differentFirstPage && hf && !hfIsEmpty(hf.footerFirst ?? null) ? (hf.footerFirst!.content![0] as TiptapNode) : null;
  // Different odd & even pages (ODF header-left): even pages get their own zone.
  const differentOddEven = !!hf?.differentOddEven;
  let evenHeaderPara = differentOddEven && hf && !hfIsEmpty(hf.headerEven ?? null) ? (hf.headerEven!.content![0] as TiptapNode) : null;
  let evenFooterPara = differentOddEven && hf && !hfIsEmpty(hf.footerEven ?? null) ? (hf.footerEven!.content![0] as TiptapNode) : null;
  // Hoist header/footer inline images out to HFIMG sentinels before odf-kit serializes
  // the zones; applyHfPostProcess rewrites them to <draw:frame> in styles.xml.
  const hfImages: ImageExport[] = [];
  headerPara = headerPara && markTextEffects(headerPara);
  footerPara = footerPara && markTextEffects(footerPara);
  headerPara = replaceHfImages(headerPara, hfImages);
  footerPara = replaceHfImages(footerPara, hfImages);
  firstHeaderPara = replaceHfImages(firstHeaderPara, hfImages);
  firstFooterPara = replaceHfImages(firstFooterPara, hfImages);
  evenHeaderPara = replaceHfImages(evenHeaderPara, hfImages);
  evenFooterPara = replaceHfImages(evenFooterPara, hfImages);
  // With the flag on, page 1 is independent: whenever a side has a zone on either
  // variant, emit both — an empty one blanks its side, as the editor shows it.
  if (differentFirstPage) {
    const empty = (): TiptapNode => ({ type: 'paragraph', content: [] });
    if (headerPara || firstHeaderPara) { headerPara ??= empty(); firstHeaderPara ??= empty(); }
    if (footerPara || firstFooterPara) { footerPara ??= empty(); firstFooterPara ??= empty(); }
  }
  // Same for even pages: an empty even zone blanks it while the default fills odd pages.
  if (differentOddEven) {
    const empty = (): TiptapNode => ({ type: 'paragraph', content: [] });
    if (headerPara || evenHeaderPara) { headerPara ??= empty(); evenHeaderPara ??= empty(); }
    if (footerPara || evenFooterPara) { footerPara ??= empty(); evenFooterPara ??= empty(); }
  }
  // Distance from the page edge to the header (top) / footer (bottom). Becomes the
  // ODF page margin; clamped below the body margin so the body still starts at it.
  const headerDist = Math.min(hf?.headerDistanceCm ?? HF_DISTANCE_CM, margins.top);
  const footerDist = Math.min(hf?.footerDistanceCm ?? HF_DISTANCE_CM, margins.bottom);
  let json = injectCustomTypes(raw);
  if (headerPara || footerPara) {
    json = { ...json, content: [{ type: CUST_HF }, ...(json.content ?? [])] };
  }

  // Text width = the format's page width (orientation-swapped) minus the L/R
  // margins. Table column widths are scaled to fill exactly this width.
  const pageWidthCm = pageDimsCm(pageFormat, orientation).w;
  const contentWidthCm = pageWidthCm - margins.left - margins.right;

  // Filled by exportTable, in document order, one CellBlock[] per table cell.
  // applyCellBlocks consumes it to rebuild real <text:h>/<text:p>/<text:list>.
  const cellBlocks: CellBlock[][] = [];
  // One entry per table, same order — consumed by applyTableProps.
  const tableMargins: (TableProps | null)[] = [];
  // The named table style + its options per table, same order — applyTableStyleNames.
  const tableStyleNames: (TableStyleRef | null)[] = [];
  // One entry per cell, same order as cellBlocks — applyCellFormulas. A cell's number
  // is read in the document's language, as LibreOffice reads it.
  const cellFormulas: (CellFormulaExport | null)[] = [];
  const langTag = language ? `${language.language}-${language.country}` : 'en';
  const numberLoc = numberLocale(langTag);

  const odt = await tiptapToOdt(json, {
    // Orientation sets style:print-orientation; rewriteStylesXml overrides the exact
    // fo:page-width/height for the chosen format (odf-kit only knows 5 presets).
    orientation,
    // Margins (cm) from the Layout panel, matching the editor's padding so line
    // wrapping / page flow is identical. With a header/footer the vertical margin is
    // the edge→zone distance; applyHfPostProcess keeps the body starting at the margin.
    marginTop: `${headerPara ? headerDist : margins.top}cm`,
    marginBottom: `${footerPara ? footerDist : margins.bottom}cm`,
    marginLeft: `${margins.left}cm`,
    marginRight: `${margins.right}cm`,
    unknownNodeHandler(node: TiptapNode, doc: OdtDocument) {
      if (node.type === CUST_HF) {
        if (headerPara) doc.setHeader((b: HeaderFooterBuilder) => applyHfRuns(b, headerPara, hf!.pageCount));
        if (footerPara) doc.setFooter((b: HeaderFooterBuilder) => applyHfRuns(b, footerPara, hf!.pageCount));
        return;
      }
      if (node.type === CUST_TABLE) {
        exportTable(node, doc, contentWidthCm, cellBlocks, tableMargins, tableStyleNames, cellFormulas, numberLoc);
        return;
      }
      const opts: {
        lineHeight?: number | string;
        align?: AlignValue;
        spaceBefore?: string;
        spaceAfter?: string;
        indentLeft?: string;
        indentFirst?: string;
        tabStops?: { position: string; type: 'left' | 'center' | 'right' }[];
      } = {};
      if (node.attrs?.lineHeight != null) {
        const lhRaw = String(node.attrs.lineHeight);
        const lhNum = parseFloat(lhRaw);
        opts.lineHeight = isNaN(lhNum) ? lhRaw : lhNum;
      } else {
        opts.lineHeight = DEFAULT_LINE_HEIGHT;
      }
      const ta = node.attrs?.textAlign;
      if (ta === 'left' || ta === 'center' || ta === 'right' || ta === 'justify') {
        opts.align = ta;
      }
      if (node.attrs?.spaceBefore != null) opts.spaceBefore = `${node.attrs.spaceBefore}pt`;
      if (node.attrs?.spaceAfter != null) opts.spaceAfter = `${node.attrs.spaceAfter}pt`;
      // Left indent → fo:margin-left (odf-kit emits it natively from indentLeft).
      if (typeof node.attrs?.indent === 'number' && node.attrs.indent > 0) {
        opts.indentLeft = `${node.attrs.indent}cm`;
      }
      // First-line indent → fo:text-indent; negative is a hanging indent.
      if (typeof node.attrs?.indentFirst === 'number' && node.attrs.indentFirst !== 0) {
        opts.indentFirst = `${node.attrs.indentFirst}cm`;
      }
      // Tab stops → <style:tab-stops>. odf-kit's type has no decimal stop, so it goes
      // out as 'char' and applyInlineSentinels adds the style:char ODF requires.
      const stops = parseTabStops(node.attrs?.tabStops);
      if (stops.length) {
        opts.tabStops = stops.map((s) => ({
          position: `${s.pos}cm`,
          // odf-kit writes style:type verbatim but types it without ODF's 'char'; a
          // LEAD suffix rides along so the leader reaches applyTabLeaders.
          type: ((s.align === 'decimal' ? 'char' : s.align)
            + (normalizeLeader(s.leader) ? `${LEAD}${s.leader}` : '')) as 'left' | 'center' | 'right',
        }));
      }
      const content = node.content ?? [];
      // The paragraph-mark font size rides as an FSZ sentinel that
      // applyEmptyLineFontSizes turns into a paragraph-style fo:font-size — it is the
      // block's line-height floor, so it matters on a filled block as much as an empty one.
      const fszPayload = markFontPayload(node.attrs);
      const fsz = fszPayload ? `${FSZ}${fszPayload}${FSZ}` : '';
      // Paragraph background/borders ride as a leading PBX sentinel (odf-kit has no such
      // options); applyParagraphBoxes mints the style. FSZ stays first so its own pass,
      // which runs earlier, still matches it right after the opening tag.
      const spec = paraBoxSpec(node.attrs);
      const pbx = spec ? `${PBX}${spec}${PBX}` : '';
      // Named style, unless it is the one odf-kit puts on this node type anyway.
      const styleName = styleOf(node);
      const sty = styleName !== odfDefaultStyleOf(node) ? `${STY}${styleName}${STY}` : '';
      const marks = fsz + sty + pbx;
      const withPbx = (p: ParagraphBuilder) => { if (marks) p.addText(marks); applyRuns(p, content); };

      if (node.type === CUST_P) {
        if (content.length === 0) doc.addParagraph(marks, opts);
        else doc.addParagraph(withPbx, opts);
      } else if (node.type === CUST_H) {
        const level = (node.attrs?.level as number) ?? 1;
        if (content.length === 0) doc.addHeading(marks, level, opts);
        else doc.addHeading(withPbx, level, opts);
      }
    },
  });

  // Rewrite odf-kit's default numbering (1.) into per-level formats (depth cycle,
  // explicit types, multilevel chains). Runs before applyListItemStyles, which only
  // touches <text:p> styles, not the <text:list-style> definitions.
  const olFormats: (OlStyleFix | null)[] = [];
  collectOrderedListFormats(raw, olFormats);
  let numberedOdt = applyOrderedListFormats(odt as Uint8Array, olFormats);

  // A Word list continued across an intervening paragraph splits into separate nodes with
  // a `start` attr; odf-kit drops it, so emit text:start-value on each such list's first item.
  const listStarts: (number | null)[] = [];
  collectListStartValues(raw, listStarts);
  numberedOdt = applyListStartValues(numberedOdt, listStarts);

  // Rewrite odf-kit's default bullet chars into the per-level bulletChar attrs.
  const blChars: (string[] | null)[] = [];
  collectBulletListChars(raw, blChars);
  numberedOdt = applyBulletListChars(numberedOdt, blChars);

  const nestedFixes: (ListDef | null)[] = [];
  collectNestedListFixes(raw, nestedFixes);
  numberedOdt = applyNestedListTypes(numberedOdt, nestedFixes);

  const listStyles: ParaStyle[] = [];
  collectListItemStyles(raw, listStyles);
  const styledLists = applyListItemStyles(numberedOdt, listStyles);

  // Whole-list indent → added to each L# list-style's level margins.
  const listLevels: ListLevelProps[][] = [];
  collectListLevelProps(raw, listLevels);
  let indentedLists = applyListLevelProps(styledLists, listLevels);

  // Marker formatting → a minted character style on each L# level definition.
  const markerFormats: (MarkerFormat | null)[][] = [];
  collectListMarkerFormats(raw, markerFormats);
  indentedLists = applyListMarkerFormats(indentedLists, markerFormats);

  // Rebuild real headings/lists/paragraphs inside table cells. Must run after
  // applyListItemStyles (cell lists don't exist yet) and before collapseRunWhitespace.
  const styledCells = applyCellFormulas(applyCellBlocks(indentedLists, cellBlocks), cellFormulas, langTag);

  const rowHeights: (string | null)[] = [];
  collectTableRowHeights(raw, rowHeights);
  const styledRows = applyTableRowHeights(expandCellPadding(styledCells), rowHeights);
  const withTableMargins = applyTableStyleNames(
    applyTableHeaderRows(applyTableProps(styledRows, tableMargins, contentWidthCm), tableMargins), tableStyleNames);

  const cleaned = collapseRunWhitespace(withTableMargins);
  // Before applyInlineSentinels: it matches the bare style:type="char" a leader would hide.
  const withBreaks = applyInlineSentinels(applyTabLeaders(cleaned));
  const withImages = applyImages(withBreaks, images);
  const withDateFields = applyDateTimeFields(withImages, dateFields, language ?? null);
  const withSequences = applyRuby(applyBibEntries(applyIndexEntries(applyRevisions(applySequenceFields(withDateFields, seqFields), revisionList, recordChanges), indexMarks), bibMarks), rubies);
  const withFormulas = applyFormulas(withSequences, formulas);
  const withTextBoxes = applyTextBoxes(withFormulas, textBoxes);
  const withColumns = applyColumns(withTextBoxes, columns);
  const withBookmarks = applyComments(applyBookmarks(withColumns, crossRefs), commentList);
  // After every other content.xml pass: the note's own runs are hoisted into the body,
  // so they must be fully resolved before they are cut out and moved into <text:note>.
  const withNotes = applyNotes(withBookmarks, notes);
  const withToc = applyToc(withNotes, tocs, contentWidthCm, [...new Set(bibMarks.map(m => m.type))]);
  const withPageBreaks = applyPageBreaks(withToc);
  const withEmptyFontSizes = applyEmptyLineFontSizes(withPageBreaks);
  const withParaBoxes = applyParagraphBoxes(withEmptyFontSizes);
  // Effects first: applyCharacterStyles then clones the style that already carries them.
  const withNamedStyles = applyCharacterStyles(applyTextEffects(applyParagraphStyles(withParaBoxes)));
  const usedTables = new Set(tableStyleNames.filter((t): t is TableStyleRef => !!t).map(t => t.name));
  const withStyles = rewriteStylesXml(withNamedStyles, language ?? null, pageFormat, orientation, styles, usedStyleNames(docJson, styles), usedTables, tabIntervalCm, margins.mirrored === true, rtl, notesSettings, hyphenate, pageNumbering, decor, lineNumbering);
  const withHf = applyHfPostProcess(withStyles, margins, headerPara, footerPara, headerDist, footerDist, firstHeaderPara, firstFooterPara, hf?.pageCount ?? 1, hfImages, evenHeaderPara, evenFooterPara);
  const withWatermark = applyWatermarkOdf(withHf, decor.watermark);
  // Sections past the first get their own master page, which is where ODF keeps a
  // section's header/footer; the SEC-marked block points at it.
  const withSections = applySectionMasterPages(withWatermark, hf?.sections ?? [], hf?.pageCount ?? 1, margins, pageFormat, orientation);
  return zipFinal(applyDocProperties(applyPageNumberStart(applySpacingModel(withSections, spacingModel), pageNumbering.start), props));
}

// The document's first page number. ODF has no document-level start: LibreOffice puts
// `style:page-number` on the first paragraph's own style (probed), beside the master page
// it names.
function applyPageNumberStart(odtBytes: Uint8Array, start: number): Uint8Array {
  if (start <= 1) return odtBytes;
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  if (!contentBytes) return odtBytes;
  const content = strFromU8(contentBytes);
  const body = /<office:text\b[^>]*>/.exec(content);
  if (!body) return odtBytes;
  const first = /<text:(p|h)\b([^>]*)>/.exec(content.slice(body.index + body[0].length));
  if (!first) return odtBytes;
  const at = body.index + body[0].length + first.index;
  const srcM = /text:style-name="([^"]*)"/.exec(first[2]);
  const source = srcM ? srcM[1] : 'Standard';
  const name = 'PgNumStart';
  const def = findAutoStyle(content, source);
  const minted = def
    ? cloneStyleWithParaProps(def, name, `style:page-number="${start}"`)
    : `<style:style style:name="${name}" style:family="paragraph" style:parent-style-name="${source}"><style:paragraph-properties style:page-number="${start}"/></style:style>`;
  const tag = srcM
    ? first[0].replace(/text:style-name="[^"]*"/, `text:style-name="${name}"`)
    : `<text:${first[1]} text:style-name="${name}"${first[2]}>`;
  files['content.xml'] = strToU8(
    injectAutomaticStyles(content.slice(0, at) + tag + content.slice(at + first[0].length), minted),
  );
  return rezipOdt(files);
}

// The descriptive metadata → meta.xml, which odf-kit already writes (generator +
// creation date). LibreOffice's File ▸ Properties and Word's File ▸ Info read it.
function applyDocProperties(odtBytes: Uint8Array, props: DocProperties): Uint8Array {
  const files = unzipSync(odtBytes);
  const metaBytes = files['meta.xml'];
  if (!metaBytes) return odtBytes;
  const el = (tag: string, value: string) => (value.trim() ? `<${tag}>${escapeXml(value.trim())}</${tag}>` : '');
  const author = props.author.trim();
  const fields = el('dc:title', props.title) + el('dc:subject', props.subject)
    + el('dc:description', props.description)
    + keywordList(props.keywords).map(k => `<meta:keyword>${escapeXml(k)}</meta:keyword>`).join('')
    + (author ? el('meta:initial-creator', author) + el('dc:creator', author) : '')
    + `<dc:date>${new Date().toISOString()}</dc:date>`;
  files['meta.xml'] = strToU8(strFromU8(metaBytes)
    .replace('<meta:generator>odf-kit</meta:generator>', `<meta:generator>${GENERATOR}</meta:generator>`)
    .replace('</office:meta>', `${fields}</office:meta>`));
  return rezipOdt(files);
}

// A document that takes the larger of two adjoining spacings needs LibreOffice's
// AddParaTableSpacing=false — its own default adds them, so without this the space
// between every pair of blocks would grow when the file is reopened.
function applySpacingModel(odtBytes: Uint8Array, model: SpacingModel): Uint8Array {
  if (model !== 'max') return odtBytes;
  const files = unzipSync(odtBytes);
  const item =
    '<config:config-item-set config:name="ooo:configuration-settings">' +
    '<config:config-item config:name="AddParaTableSpacing" config:type="boolean">false</config:config-item>' +
    '</config:config-item-set>';
  const existing = files['settings.xml'];
  if (existing) {
    files['settings.xml'] = strToU8(strFromU8(existing).replace('</office:settings>', `${item}</office:settings>`));
    return rezipOdt(files);
  }
  files['settings.xml'] = strToU8(
    '<?xml version="1.0" encoding="UTF-8"?>' +
    '<office:document-settings xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"' +
    ' xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0" office:version="1.3">' +
    `<office:settings>${item}</office:settings></office:document-settings>`,
  );
  const manifestBytes = files['META-INF/manifest.xml'];
  if (manifestBytes) {
    const entry = '<manifest:file-entry manifest:full-path="settings.xml" manifest:media-type="text/xml"/>';
    const manifest = strFromU8(manifestBytes);
    if (!manifest.includes('"settings.xml"')) {
      files['META-INF/manifest.xml'] = strToU8(manifest.replace('</manifest:manifest>', `${entry}</manifest:manifest>`));
    }
  }
  return rezipOdt(files);
}

function hfAlign(para: TiptapNode): AlignValue | null {
  const ta = para.attrs?.textAlign;
  return ta === 'center' || ta === 'right' || ta === 'justify' ? ta : null;
}

// <style:tab-stops> for a zone paragraph: odf-kit builds the body's, but a header/footer
// style is written by hand here.
function tabStopsXml(attrs: TiptapNode['attrs']): string {
  const stops = parseTabStops(attrs?.tabStops);
  if (!stops.length) return '';
  const inner = stops.map((st) => {
    const leader = normalizeLeader(st.leader);
    return `<style:tab-stop style:position="${st.pos}cm" style:type="${st.align === 'decimal' ? 'char' : st.align}"`
      + (st.align === 'decimal' ? ' style:char="."' : '')
      + (leader ? ` style:leader-style="${ODF_LEADER_STYLE[leader]}" style:leader-text="${leader}"` : '')
      + '/>';
  }).join('');
  return `<style:tab-stops>${inner}</style:tab-stops>`;
}

// The whole <style:paragraph-properties> of a zone paragraph, or '' when it needs none:
// alignment plus the paragraph background ("colored field") and per-side borders.
function hfParaPropsXml(para: TiptapNode): string {
  const props: string[] = [];
  const align = hfAlign(para);
  if (align) props.push(`fo:text-align="${align}"`);
  const s = paraStyleFromAttrs(para.attrs);
  if (s.background) props.push(`fo:background-color="${s.background}"`);
  // The zone's own margins, which grow the band on the way back in (import/CLAUDE.md).
  for (const [attr, side] of [['spaceBefore', 'top'], ['spaceAfter', 'bottom']] as const) {
    const v = para.attrs?.[attr];
    if (typeof v === 'number' && v) props.push(`fo:margin-${side}="${v}pt"`);
  }
  for (const [attr, side] of [
    ['borderTop', 'top'], ['borderRight', 'right'], ['borderBottom', 'bottom'], ['borderLeft', 'left'],
  ] as const) {
    if (s[attr]) props.push(`fo:border-${side}="${s[attr]}"`);
  }
  const tabs = tabStopsXml(para.attrs);
  if (!props.length && !tabs) return '';
  const open = `<style:paragraph-properties${props.length ? ` ${props.join(' ')}` : ''}`;
  return tabs ? `${open}>${tabs}</style:paragraph-properties>` : `${open}/>`;
}

// Header/footer post-processing on styles.xml: resolve LBR/PGC sentinels, apply the
// paragraph alignment to the Header/Footer styles, and rewrite the geometry to the
// ODF's own mapping (page margin = HF distance, min-height fills up to the body margin).
function applyHfPostProcess(odtBytes: Uint8Array, margins: PageMargins, headerPara: TiptapNode | null, footerPara: TiptapNode | null, headerDist: number, footerDist: number, firstHeaderPara: TiptapNode | null = null, firstFooterPara: TiptapNode | null = null, pageCount = 1, hfImages: ImageExport[] = [], evenHeaderPara: TiptapNode | null = null, evenFooterPara: TiptapNode | null = null): Uint8Array {
  if (!headerPara && !footerPara && !firstHeaderPara && !firstFooterPara && !evenHeaderPara && !evenFooterPara) return odtBytes;

  const files = unzipSync(odtBytes);
  const stylesBytes = files['styles.xml'];
  if (!stylesBytes) return odtBytes;
  let styles = strFromU8(stylesBytes);

  // Same fix as collapseRunWhitespace: odf-kit joins runs with "\n", which would
  // collapse into spurious spaces. styles.xml only has text:p inside header/footer.
  styles = styles.replace(/<text:p\b[^>]*>[\s\S]*?<\/text:p>/g, (block) => block.replace(/\n/g, ''));
  styles = styles.split(LBR).join('<text:line-break/>');
  styles = styles.replace(new RegExp(`${PGC}(\\d*)${PGC}`, 'g'), '<text:page-count>$1</text:page-count>');
  styles = styles.replace(new RegExp(`${CHP}(\\d)${CHP}([\\s\\S]*?)${CHP}`, 'g'),
    (_m, level: string, name: string) => `<text:chapter text:display="name" text:outline-level="${level}">${name}</text:chapter>`);

  const mintedStyles: string[] = [];
  const mint = (n: string) => { mintedStyles.push(n); };
  styles = resolveTextEffects(styles, mint, 'HFTE');

  const round3 = (v: number) => Math.round(v * 1000) / 1000;
  const zone = (kind: 'header' | 'footer', para: TiptapNode, bodyMarginCm: number, distCm: number) => {
    // min-height fills the gap between the edge→zone distance and the body margin,
    // so the body still starts at bodyMarginCm (page margin was set to distCm).
    const minH = round3(Math.max(0.2, bodyMarginCm - distCm));
    // The spacing attr sits on the body-facing side: below the header, above the footer.
    const spacingAttr = kind === 'header' ? 'fo:margin-bottom' : 'fo:margin-top';
    styles = styles.replace(
      new RegExp(`<style:${kind}-style>[\\s\\S]*?</style:${kind}-style>`),
      `<style:${kind}-style><style:header-footer-properties fo:min-height="${minH}cm" ${spacingAttr}="0cm" style:dynamic-spacing="false"/></style:${kind}-style>`,
    );
    const props = hfParaPropsXml(para);
    if (props) {
      const styleName = kind === 'header' ? 'Header' : 'Footer';
      styles = styles.replace(
        new RegExp(`(<style:style style:name="${styleName}"[^>]*?)/>`),
        `$1>${props}</style:style>`,
      );
    }
  };
  if (headerPara) zone('header', headerPara, margins.top, headerDist);
  if (footerPara) zone('footer', footerPara, margins.bottom, footerDist);

  // Different first page / odd-even: inject <style:{header,footer}-{first,left}> content
  // into the master page (ODF 1.3; LibreOffice reads them). The page-layout header/footer
  // geometry above is shared across variants, so only the content differs here.
  if (firstHeaderPara || firstFooterPara || evenHeaderPara || evenFooterPara) {
    const injectVariant = (kind: 'header' | 'footer', suffix: 'first' | 'left', para: TiptapNode | null) => {
      if (!para) return;
      const xml = hfVariantZoneXml(kind, suffix, para, pageCount, mint);
      // Insert after the matching default zone (always present when a variant exists,
      // since buildOdt emits an empty default alongside it), else at the master-page bounds.
      const closeTag = `</style:${kind}>`;
      if (styles.includes(closeTag)) styles = styles.replace(closeTag, `${closeTag}${xml}`);
      else if (kind === 'header') styles = styles.replace(/(<style:master-page\b[^>]*>)/, `$1${xml}`);
      else styles = styles.replace('</style:master-page>', `${xml}</style:master-page>`);
    };
    injectVariant('header', 'first', firstHeaderPara);
    injectVariant('header', 'left', evenHeaderPara);
    injectVariant('footer', 'first', firstFooterPara);
    injectVariant('footer', 'left', evenFooterPara);
  }
  if (mintedStyles.length) {
    const defs = mintedStyles.join('');
    styles = injectAutomaticStyles(styles, defs);
  }

  // Resolve HFIMG sentinels (default + first-page zones) to as-char <draw:frame>s, then
  // add the picture binaries and their manifest entries (mirrors the body applyImages).
  if (hfImages.length) {
    styles = ensureDrawNamespaces(styles);
    styles = styles.replace(new RegExp(`${HFIMG}(\\d+)${HFIMG}`, 'g'), (_m, idx: string) => {
      const img = hfImages[Number(idx)];
      return img ? hfImageFrameXml(img, Number(idx)) : '';
    });
    const bgStyles = hfImages.map((img, i) => (img.wrap === 'inline' ? '' : hfBackgroundStyleXml(i))).join('');
    if (bgStyles) {
      styles = injectAutomaticStyles(styles, bgStyles);
    }
    for (const img of hfImages) files[img.path] = img.bytes;
    const manifestBytes = files['META-INF/manifest.xml'];
    if (manifestBytes) {
      const entries = hfImages
        .map((img) => `<manifest:file-entry manifest:full-path="${img.path}" manifest:media-type="${img.mimeType}"/>`)
        .join('');
      files['META-INF/manifest.xml'] = strToU8(strFromU8(manifestBytes).replace('</manifest:manifest>', `${entries}</manifest:manifest>`));
    }
  }

  files['styles.xml'] = strToU8(styles);
  return rezipOdt(files);
}

// styles.xml needs draw/svg/xlink namespaces for an image frame; odf-kit may not declare
// all three (svg is used by page geometry, but draw/xlink can be absent).
function ensureDrawNamespaces(styles: string): string {
  const ns: [string, string][] = [
    ['draw', 'urn:oasis:names:tc:opendocument:xmlns:drawing:1.0'],
    ['svg', 'urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0'],
    ['xlink', 'http://www.w3.org/1999/xlink'],
  ];
  const missing = ns.filter(([p]) => !styles.includes(`xmlns:${p}=`)).map(([p, uri]) => `xmlns:${p}="${uri}"`);
  return missing.length ? styles.replace(/<office:document-styles\b/, `<office:document-styles ${missing.join(' ')}`) : styles;
}

// A variant zone paragraph → <style:{header,footer}-{first,left}> XML (suffix null = the
// section's own zone). Runs and page fields become <text:span>s referencing minted
// automatic text styles (pushed via `mint`); hardBreak → line-break.
function hfVariantZoneXml(kind: 'header' | 'footer', suffix: 'first' | 'left' | null, para: TiptapNode, pageCount: number, mint: (styleXml: string) => void, prefix = ''): string {
  let styleSeq = 0;
  // Distinct minted-style prefix per variant so first + even styles never collide.
  const pfx = `${prefix}HF${suffix === 'first' ? 'F' : suffix === 'left' ? 'L' : 'D'}${kind[0].toUpperCase()}`;
  // Wrap inline XML in a minted text style span when the run carries formatting.
  const styled = (innerXml: string, marks: TiptapNode['marks']): string => {
    const props = odfTextPropsFromMarks(marks);
    if (!props) return innerXml;
    const name = `${pfx}T${++styleSeq}`;
    mint(`<style:style style:name="${name}" style:family="text"><style:text-properties ${props}/></style:style>`);
    return `<text:span text:style-name="${name}">${innerXml}</text:span>`;
  };

  let inner = '';
  for (const node of para.content ?? []) {
    if (node.type === 'text' && node.text) inner += styled(odfEncodeInline(node.text), node.marks);
    else if (node.type === 'hardBreak') inner += '<text:line-break/>';
    else if (node.type === 'pageNumber') inner += styled('<text:page-number text:select-page="current">1</text:page-number>', node.marks);
    else if (node.type === 'pageCount') inner += styled(`<text:page-count>${pageCount}</text:page-count>`, node.marks);
    else if (node.type === 'chapterField') inner += styled(
      `<text:chapter text:display="name" text:outline-level="${Number(node.attrs?.level) || 1}">${odfEncodeInline(String(node.attrs?.text ?? ''))}</text:chapter>`, node.marks);
  }

  const parent = kind === 'header' ? 'Header' : 'Footer';
  const props = hfParaPropsXml(para);
  let paraStyle = parent;
  if (props) {
    paraStyle = `${pfx}P`;
    mint(`<style:style style:name="${paraStyle}" style:family="paragraph" style:parent-style-name="${parent}">${props}</style:style>`);
  }
  const tag = suffix ? `${kind}-${suffix}` : kind;
  return `<style:${tag}><text:p text:style-name="${paraStyle}">${inner}</text:p></style:${tag}>`;
}

// A section's own master page: the Standard one cloned under its own name, carrying that
// section's zones. ODF has no per-section header/footer other than this.
function masterPageXml(name: string, layoutName: string, set: HfSet, pageCount: number, mint: (styleXml: string) => void, pfx: string): string {
  const zone = (kind: 'header' | 'footer', suffix: 'first' | 'left' | null, doc: HfDoc): string => {
    if (hfIsEmpty(doc)) return '';
    return hfVariantZoneXml(kind, suffix, doc!.content![0] as TiptapNode, pageCount, mint, pfx);
  };
  // An empty default beside a variant blanks its side, as the editor renders it.
  const need = (a: HfDoc, b: HfDoc) => (hfIsEmpty(a) && !hfIsEmpty(b) ? { type: 'doc', content: [{ type: 'paragraph', content: [] }] } as HfDoc : a);
  const hFirst = set.differentFirstPage ? set.headerFirst : null;
  const fFirst = set.differentFirstPage ? set.footerFirst : null;
  const hEven = set.differentOddEven ? set.headerEven : null;
  const fEven = set.differentOddEven ? set.footerEven : null;
  const body = zone('header', null, need(need(set.header, hFirst), hEven))
    + zone('header', 'first', hFirst) + zone('header', 'left', hEven)
    + zone('footer', null, need(need(set.footer, fFirst), fEven))
    + zone('footer', 'first', fFirst) + zone('footer', 'left', fEven);
  return `<style:master-page style:name="${name}" style:page-layout-name="${layoutName}">${body}</style:master-page>`;
}

// Point each SEC-marked block at its section's master page (ODF's only per-section
// header/footer), minting the master pages beside the Standard one odf-kit wrote.
function applySectionMasterPages(odtBytes: Uint8Array, sets: HfSet[], pageCount: number, margins: PageMargins, format: PageFormat, orientation: Orientation): Uint8Array {
  const files = unzipSync(odtBytes);
  const contentBytes = files['content.xml'];
  const stylesBytes = files['styles.xml'];
  if (!contentBytes || !stylesBytes) return odtBytes;
  let content = strFromU8(contentBytes);
  if (!content.includes(SEC)) return odtBytes;
  let styles = strFromU8(stylesBytes);

  const minted: string[] = [];
  const used = new Set<number>();
  let counter = 0;
  content = content.replace(
    new RegExp(`<text:(p|h)\\b([^>]*)>${SEC}(\\d+)${SEC}`, 'g'),
    (_m, tag: string, attrs: string, idx: string) => {
      const index = Number(idx);
      used.add(index);
      const sm = /text:style-name="([^"]*)"/.exec(attrs);
      const source = sm?.[1] ?? '';
      const def = source ? findAutoStyle(content, source) : null;
      const name = `MP${++counter}`;
      const master = ` style:master-page-name="Section${index + 1}"`;
      let style = def
        ? def.replace(/style:name="[^"]*"/, `style:name="${name}"`).replace(/(<style:style\b[^>]*?)(\/?>)/, `$1${master}$2`)
        : `<style:style style:name="${name}" style:family="paragraph" style:parent-style-name="${source || 'Standard'}"${master}/>`;
      // A section restarting the numbering says so on this same paragraph — ODF has no
      // other place for it (applyPageNumberStart writes the document's own that way).
      const restart = sets[index]?.pageNumberStart;
      if (restart != null) style = upsertProps(style, 'paragraph', { 'style:page-number': String(restart) });
      minted.push(style);
      const rest = attrs.replace(/\s*text:style-name="[^"]*"/, '');
      return `<text:${tag}${rest} text:style-name="${name}">`;
    },
  );
  if (minted.length) {
    content = injectAutomaticStyles(content, minted.join(''));
  }

  // The page layout odf-kit gave the Standard master page: reused as is by a section
  // whose margins are the document's, cloned with them shifted by a section that has
  // its own — a shift, so whatever the header/footer pass folded into it survives.
  const layout = /<style:master-page\b[^>]*style:page-layout-name="([^"]*)"/.exec(styles)?.[1] ?? 'pm1';
  const layoutXml = new RegExp(`<style:page-layout\\b[^>]*style:name="${layout}"[\\s\\S]*?</style:page-layout>`).exec(styles)?.[0] ?? null;
  const layouts: string[] = [];
  const layoutFor = (index: number, set: HfSet): string => {
    const m = set.margins;
    const paper = set.format || set.orientation ? pageDimsCm(set.format ?? format, set.orientation ?? orientation) : null;
    if ((!m && !paper) || !layoutXml) return layout;
    const name = `${layout}Sec${index + 1}`;
    layouts.push(layoutXml
      .replace(`style:name="${layout}"`, `style:name="${name}"`)
      .replace(/<style:page-layout-properties\b[^>]*>/, (props) => {
        // The margins are a shift, so whatever the header/footer pass folded into them
        // survives; the paper is set outright.
        let p = m
          ? (['top', 'bottom', 'left', 'right'] as const).reduce((q, side) =>
            q.replace(new RegExp(`fo:margin-${side}="([\\d.]+)cm"`), (_x, cm: string) =>
              `fo:margin-${side}="${Math.max(0, Math.round((parseFloat(cm) + m[side] - margins[side]) * 1000) / 1000)}cm"`), props)
          : props;
        if (paper) {
          const round3 = (v: number) => Math.round(v * 1000) / 1000;
          p = p
            .replace(/fo:page-width="[^"]*"/, `fo:page-width="${round3(paper.w)}cm"`)
            .replace(/fo:page-height="[^"]*"/, `fo:page-height="${round3(paper.h)}cm"`)
            .replace(/style:print-orientation="[^"]*"/, `style:print-orientation="${paper.w > paper.h ? 'landscape' : 'portrait'}"`);
        }
        return p;
      }));
    return name;
  };
  const hfStyles: string[] = [];
  const pages: string[] = [];
  for (const index of [...used].sort((a, b) => a - b)) {
    const set = sets[index];
    if (!set) continue;
    pages.push(masterPageXml(`Section${index + 1}`, layoutFor(index, set), set, pageCount, (x) => hfStyles.push(x), `MS${index}`));
  }
  if (layouts.length) styles = styles.replace('</office:automatic-styles>', `${layouts.join('')}</office:automatic-styles>`);
  if (pages.length) styles = styles.replace('</office:master-styles>', `${pages.join('')}</office:master-styles>`);
  if (hfStyles.length) {
    const defs = hfStyles.join('');
    styles = injectAutomaticStyles(styles, defs);
  }

  files['content.xml'] = strToU8(content);
  files['styles.xml'] = strToU8(styles);
  return rezipOdt(files);
}

// A text run's ODF <style:text-properties> attribute string from TipTap marks (mirrors
// formattingFromMarks). Empty string → no styling needed (returned as null).
function odfTextPropsFromMarks(marks: TiptapNode['marks']): string | null {
  const fmt = formattingFromMarks(marks);
  const a: string[] = [];
  // The effects below name the underline's own shape and colour where the run has them.
  const extra = odfExtraTextProps(marks);
  if (fmt.fontWeight != null) a.push(`fo:font-weight="${fmt.fontWeight}"`);
  else if (fmt.bold) a.push('fo:font-weight="bold"');
  if (fmt.italic) a.push('fo:font-style="italic"');
  if (fmt.underline) {
    a.push('style:text-underline-width="auto"');
    if (!/style:text-underline-style=/.test(extra)) a.push('style:text-underline-style="solid"');
    if (!/style:text-underline-color=/.test(extra)) a.push('style:text-underline-color="font-color"');
  }
  if (fmt.strikethrough) a.push('style:text-line-through-style="solid"');
  if (extra) a.push(extra);
  if (fmt.superscript) a.push('style:text-position="super 58%"');
  else if (fmt.subscript) a.push('style:text-position="sub 58%"');
  if (fmt.fontFamily) {
    const q = /\s/.test(fmt.fontFamily) ? `'${fmt.fontFamily}'` : fmt.fontFamily;
    a.push(`style:font-name="${fmt.fontFamily}" fo:font-family="${q}"`);
  }
  if (fmt.fontSize) a.push(`fo:font-size="${fmt.fontSize}"`);
  if (fmt.color) a.push(`fo:color="${fmt.color}"`);
  if (fmt.highlightColor) a.push(`fo:background-color="${fmt.highlightColor}"`);
  return a.length ? a.join(' ') : null;
}

// Encode inline text as ODF: runs of ≥2 spaces → <text:s text:c>, tabs → <text:tab/>,
// the rest XML-escaped (so LibreOffice preserves significant whitespace).
function odfEncodeInline(s: string): string {
  let out = '';
  for (let i = 0; i < s.length; ) {
    const ch = s[i];
    if (ch === '\t') { out += '<text:tab/>'; i++; continue; }
    if (ch === ' ') {
      let n = 1;
      while (s[i + n] === ' ') n++;
      out += n === 1 ? ' ' : `<text:s text:c="${n}"/>`;
      i += n;
      continue;
    }
    out += ch === '&' ? '&amp;' : ch === '<' ? '&lt;' : ch === '>' ? '&gt;' : ch;
    i++;
  }
  return out;
}

// Document filename derived from the first non-empty heading (sanitized, max 50
// chars), falling back to document.odt.
export function deriveFilename(json: TiptapNode): string {
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  const content = (json as any).content as any[] | undefined;
  const heading = content?.find(
    (node: any) => node.type === 'heading' && node.content?.length
  );
  const firstText: string | undefined = heading?.content?.[0]?.text;
  if (firstText) {
    const name = firstText
      .slice(0, 50)
      .replace(/[^a-zA-Z0-9\s-]/g, '')
      .trim()
      .replace(/\s+/g, '-');
    if (name) return `${name}.odt`;
  }
  return 'document.odt';
}