@illusions-lab/mdi 2.0.7 → 2.0.9

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -24,15 +34,26 @@ __export(index_exports, {
   MDI_SPEC_VERSION: () => MDI_SPEC_VERSION,
   parse: () => parse,
   parseMdiSyntax: () => parseMdiSyntax,
+  prepareRender: () => prepareRender,
   renderDocx: () => renderDocx,
+  renderDocxWithDiagnostics: () => renderDocxWithDiagnostics,
+  renderDocxWithProfile: () => renderDocxWithProfile,
   renderEpub: () => renderEpub,
+  renderEpubWithDiagnostics: () => renderEpubWithDiagnostics,
+  renderEpubWithProfile: () => renderEpubWithProfile,
   renderHtml: () => renderHtml,
+  renderHtmlWithDiagnostics: () => renderHtmlWithDiagnostics,
   renderText: () => renderText,
   renderTextFormat: () => renderTextFormat,
-  serializeMdi: () => serializeMdi
+  renderTextFormatWithDiagnostics: () => renderTextFormatWithDiagnostics,
+  renderTextWithDiagnostics: () => renderTextWithDiagnostics,
+  serializeMdi: () => serializeMdi,
+  toPublicationMdast: () => toPublicationMdast
 });
 module.exports = __toCommonJS(index_exports);
 var import_mdi_core = require("@illusions-lab/mdi-core");
+var import_mdi_export_profile = require("@illusions-lab/mdi-export-profile");
+var import_yaml = require("yaml");
 var MDI_SPEC_VERSION = "2.0";
 var MDI_IR_VERSION = "1.0";
 function parse(source) {
@@ -43,18 +64,322 @@ function parse(source) {
   }
   return result;
 }
-function renderHtml(source) {
-  if (typeof source !== "string") throw new TypeError("source must be a string");
-  return (0, import_mdi_core.renderHtml)(source);
+function renderHtml(source, options) {
+  assertSource(source);
+  assertHtmlOptions(options);
+  const html = (0, import_mdi_core.renderHtml)(source);
+  return options?.bodyOnly ? htmlBody(html) : html;
+}
+function renderHtmlWithDiagnostics(source, options) {
+  assertSource(source);
+  assertHtmlOptions(options);
+  return renderWithDiagnostics(source, () => renderHtml(source, options));
+}
+function prepareRender(source) {
+  return parse(source);
 }
-function renderEpub(source) {
+function renderEpub(source, options) {
   if (typeof source !== "string") throw new TypeError("source must be a string");
+  if (options !== void 0) {
+    assertEpubOptions(options);
+    return renderEpubWithProfile(source, options);
+  }
   return (0, import_mdi_core.renderEpub)(source);
 }
-function renderDocx(source) {
+function renderEpubWithDiagnostics(source, options) {
+  return options === void 0 ? renderWithDiagnostics(source, () => renderEpub(source)) : renderWithDiagnosticsAsync(source, () => renderEpub(source, options));
+}
+function renderDocx(source, profile) {
   if (typeof source !== "string") throw new TypeError("source must be a string");
+  if (profile !== void 0) {
+    assertPlainObject(profile, "profile");
+    return renderDocxWithProfile(source, profile);
+  }
   return (0, import_mdi_core.renderDocx)(source);
 }
+function renderDocxWithDiagnostics(source, profile) {
+  return profile === void 0 ? renderWithDiagnostics(source, () => renderDocx(source)) : renderWithDiagnosticsAsync(source, () => renderDocx(source, profile));
+}
+async function renderEpubWithProfile(source, options = {}) {
+  assertSource(source);
+  assertEpubOptions(options);
+  const { mdiToEpub } = await import("@illusions-lab/mdi-to-epub");
+  const normalized = normalizeEpubOptions(options);
+  (0, import_mdi_export_profile.requireLayoutSystem)(normalized.profile);
+  return mdiToEpub(toPublicationMdast(parse(source).document), normalized);
+}
+async function renderDocxWithProfile(source, profile = {}) {
+  assertSource(source);
+  assertPlainObject(profile, "profile");
+  prepareNodeDocxImport();
+  const { mdiToDocx } = await import("@illusions-lab/mdi-to-docx");
+  const normalized = normalizeDocxProfile(profile);
+  (0, import_mdi_export_profile.requireLayoutSystem)(normalized);
+  return mdiToDocx(toPublicationMdast(parse(source).document), normalized);
+}
+function prepareNodeDocxImport() {
+  const nodeProcess = globalThis.process;
+  if (nodeProcess?.release?.name === "node" && !nodeProcess.execArgv?.some((argument) => argument.startsWith("--localstorage-file="))) {
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+    if (descriptor?.configurable && descriptor.get)
+      Object.defineProperty(globalThis, "localStorage", {
+        value: void 0,
+        configurable: true
+      });
+  }
+}
+function toPublicationMdast(document) {
+  const children = document.children.map(toPublicationMdastNode);
+  const tree = { type: "root", children };
+  if (document.frontmatter) {
+    children.unshift({ type: "yaml", value: document.frontmatter.raw });
+    const frontmatter = publicationFrontmatter(document.frontmatter.raw);
+    tree.data ??= {};
+    tree.data.frontmatter = frontmatter;
+  }
+  return tree;
+}
+function toPublicationMdastNode(node) {
+  const { span: _span, children, ...rest } = node;
+  const mapped = { ...rest };
+  if (children) mapped.children = children.map(toPublicationMdastNode);
+  switch (node.type) {
+    case "ruby": {
+      const ruby = node.ruby;
+      return { ...mapped, type: "mdiRuby", ruby: ruby.value };
+    }
+    case "tcy":
+      return { ...mapped, type: "mdiTcy" };
+    case "break":
+      return { ...mapped, type: "mdiBreak" };
+    case "em":
+      return { ...mapped, type: "mdiEm" };
+    case "noBreak":
+      return { ...mapped, type: "mdiNoBreak" };
+    case "warichu":
+      return { ...mapped, type: "mdiWarichu" };
+    case "kern":
+      return { ...mapped, type: "mdiKern" };
+    case "blank":
+      return { ...mapped, type: "mdiBlank" };
+    case "pagebreak": {
+      if (mapped.variant === null) delete mapped.variant;
+      return { ...mapped, type: "mdiPagebreak" };
+    }
+    case "paragraph": {
+      const data = {};
+      if (typeof mapped.indent === "number") data.mdiIndent = mapped.indent;
+      if (typeof mapped.bottom === "number") data.mdiBottom = mapped.bottom;
+      delete mapped.indent;
+      delete mapped.bottom;
+      if (Object.keys(data).length) mapped.data = data;
+      return mapped;
+    }
+    default:
+      return mapped;
+  }
+}
+function publicationFrontmatter(raw) {
+  let value;
+  try {
+    value = (0, import_yaml.parse)(raw);
+  } catch {
+    value = void 0;
+  }
+  const source = isRecord(value) ? value : {};
+  const writingMode = source["writing-mode"] === "vertical" ? "vertical" : "horizontal";
+  return {
+    mdi: stringValue(source.mdi) ?? "2.0",
+    title: stringValue(source.title),
+    author: stringValue(source.author),
+    lang: stringValue(source.lang) ?? "ja",
+    date: stringValue(source.date),
+    writingMode,
+    pageProgression: source["page-progression"] === "ltr" || source["page-progression"] === "rtl" ? source["page-progression"] : writingMode === "vertical" ? "rtl" : "ltr"
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function renderWithDiagnostics(source, render) {
+  const parsed = parse(source);
+  return {
+    output: render(),
+    document: parsed.document,
+    diagnostics: parsed.diagnostics,
+    headings: headingsFromDocument(parsed.document)
+  };
+}
+async function renderWithDiagnosticsAsync(source, render) {
+  const parsed = parse(source);
+  return {
+    output: await render(),
+    document: parsed.document,
+    diagnostics: parsed.diagnostics,
+    headings: headingsFromDocument(parsed.document)
+  };
+}
+function assertSource(source) {
+  if (typeof source !== "string") throw new TypeError("source must be a string");
+}
+function assertHtmlOptions(options) {
+  if (options === void 0) return;
+  assertPlainObject(options, "options");
+  if (options.bodyOnly !== void 0 && typeof options.bodyOnly !== "boolean") {
+    throw new TypeError("options.bodyOnly must be a boolean");
+  }
+}
+function htmlBody(html) {
+  const match = /<body(?:\s[^>]*)?>([\s\S]*)<\/body>/i.exec(html);
+  if (!match) throw new Error("Rust HTML renderer returned a document without a body");
+  return match[1];
+}
+function headingsFromDocument(document) {
+  const headings = [];
+  visitNodes(document.children, (node) => {
+    if (node.type !== "heading" || !isHeadingDepth(node.depth)) return;
+    headings.push({
+      depth: node.depth,
+      text: plainNodeText(node),
+      span: node.span,
+      node
+    });
+  });
+  return headings;
+}
+function visitNodes(nodes, visit) {
+  for (const node of nodes) {
+    visit(node);
+    if (node.children) visitNodes(node.children, visit);
+  }
+}
+function isHeadingDepth(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 6;
+}
+function plainNodeText(node) {
+  if (node.type === "ruby" && typeof node.base === "string") return node.base;
+  const value = node.value;
+  const ownText = typeof value === "string" ? value : "";
+  return ownText + (node.children?.map(plainNodeText).join("") ?? "");
+}
+function assertPlainObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`${label} must be an object`);
+  }
+}
+function assertEpubOptions(options) {
+  assertPlainObject(options, "options");
+  if (options.cover !== void 0) {
+    assertPlainObject(options.cover, "options.cover");
+    if (!(options.cover.data instanceof Uint8Array)) {
+      throw new TypeError("options.cover.data must be a Uint8Array");
+    }
+    if (options.cover.mediaType !== "image/jpeg" && options.cover.mediaType !== "image/png") {
+      throw new TypeError("options.cover.mediaType must be image/jpeg or image/png");
+    }
+  }
+  if (options.coverImage !== void 0 && !(options.coverImage instanceof Uint8Array)) {
+    throw new TypeError("options.coverImage must be a Uint8Array");
+  }
+  if (options.coverMediaType !== void 0 && options.coverMediaType !== "image/jpeg" && options.coverMediaType !== "image/png") {
+    throw new TypeError("options.coverMediaType must be image/jpeg or image/png");
+  }
+}
+function normalizeEpubOptions(options) {
+  const {
+    title,
+    author,
+    publisher,
+    identifier,
+    language,
+    date,
+    verticalWriting,
+    fontFamily,
+    fontSize,
+    lineSpacing,
+    textIndent,
+    fullwidthSpaceIndent,
+    gridMode,
+    chapterSplitLevel,
+    coverImage,
+    coverMediaType,
+    cover,
+    profile
+  } = options;
+  const metadata = { ...profile?.metadata, ...defined({ title, author, publisher, identifier, language, date }) };
+  const writingMode = verticalWriting === void 0 ? void 0 : verticalWriting ? "vertical" : "horizontal";
+  const typesetting = {
+    ...profile?.typesetting,
+    ...defined({
+      writingMode,
+      fontFamily,
+      fontSize,
+      lineSpacing,
+      textIndentEm: textIndent,
+      fullwidthSpaceIndent
+    })
+  };
+  const epub = { ...profile?.epub, ...defined({ chapterSplitLevel }) };
+  return {
+    profile: {
+      ...profile,
+      metadata,
+      typesetting,
+      epub,
+      pagination: { ...profile?.pagination, ...defined({ gridMode }) }
+    },
+    cover: cover ?? (coverImage ? { data: coverImage, mediaType: coverMediaType ?? "image/png" } : void 0)
+  };
+}
+function normalizeDocxProfile(profile) {
+  const {
+    title,
+    author,
+    publisher,
+    identifier,
+    language,
+    date,
+    verticalWriting,
+    fontFamily,
+    fontSize,
+    lineSpacing,
+    textIndent,
+    pageSize,
+    landscape,
+    gridMode,
+    charactersPerLine,
+    linesPerPage,
+    margins,
+    fullwidthSpaceIndent,
+    showPageNumbers,
+    pageNumberPosition,
+    pageNumberFormat,
+    ...nested
+  } = profile;
+  const writingMode = verticalWriting === void 0 ? void 0 : verticalWriting ? "vertical" : "horizontal";
+  return {
+    ...nested,
+    metadata: { ...nested.metadata, ...defined({ title, author, publisher, identifier, language, date }) },
+    typesetting: {
+      ...nested.typesetting,
+      ...defined({ writingMode, fontFamily, fontSize, lineSpacing, textIndentEm: textIndent, fullwidthSpaceIndent })
+    },
+    pagination: {
+      ...nested.pagination,
+      ...defined({ pageSize, landscape, gridMode, charactersPerLine, linesPerPage, margins }),
+      pageNumbers: {
+        ...nested.pagination?.pageNumbers,
+        ...defined({ enabled: showPageNumbers, position: pageNumberPosition, format: pageNumberFormat })
+      }
+    }
+  };
+}
+function defined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
 function serializeMdi(source) {
   if (typeof source !== "string") throw new TypeError("source must be a string");
   return (0, import_mdi_core.serializeMdi)(source);
@@ -63,12 +388,18 @@ function renderText(source) {
   if (typeof source !== "string") throw new TypeError("source must be a string");
   return (0, import_mdi_core.renderText)(source);
 }
+function renderTextWithDiagnostics(source) {
+  return renderWithDiagnostics(source, () => renderText(source));
+}
 function renderTextFormat(source, format, indentPrefix = "") {
   if (typeof source !== "string" || typeof indentPrefix !== "string") {
     throw new TypeError("source and indentPrefix must be strings");
   }
   return (0, import_mdi_core.renderTextFormat)(source, format, indentPrefix);
 }
+function renderTextFormatWithDiagnostics(source, format, indentPrefix = "") {
+  return renderWithDiagnostics(source, () => renderTextFormat(source, format, indentPrefix));
+}
 var parseMdiSyntax = parse;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -76,10 +407,19 @@ var parseMdiSyntax = parse;
   MDI_SPEC_VERSION,
   parse,
   parseMdiSyntax,
+  prepareRender,
   renderDocx,
+  renderDocxWithDiagnostics,
+  renderDocxWithProfile,
   renderEpub,
+  renderEpubWithDiagnostics,
+  renderEpubWithProfile,
   renderHtml,
+  renderHtmlWithDiagnostics,
   renderText,
   renderTextFormat,
-  serializeMdi
+  renderTextFormatWithDiagnostics,
+  renderTextWithDiagnostics,
+  serializeMdi,
+  toPublicationMdast
 });

package/dist/index.d.cts

@@ -1,3 +1,68 @@
+import { EpubExportOptions, EpubCover } from '@illusions-lab/mdi-to-epub';
+export { EpubCover, EpubExportOptions } from '@illusions-lab/mdi-to-epub';
+import { ExportProfile } from '@illusions-lab/mdi-export-profile';
+export { ExportProfile } from '@illusions-lab/mdi-export-profile';
+import { Root } from 'mdast';
+
+/**
+ * Options for a configured EPUB export.  The profile controls metadata,
+ * chapter splitting and typography; `cover` supplies the actual image data.
+ */
+type MdiEpubExportOptions = EpubExportOptions & {
+    /** Ergonomic aliases merged into `profile.metadata`. */
+    title?: string;
+    author?: string;
+    publisher?: string;
+    identifier?: string;
+    language?: string;
+    date?: string;
+    /** Ergonomic aliases merged into `profile.typesetting` and `profile.epub`. */
+    verticalWriting?: boolean;
+    fontFamily?: string;
+    /** Body type size in typographic points. */
+    fontSize?: number;
+    /** Baseline multiplier, for example 1.5 for one-and-a-half spacing. */
+    lineSpacing?: number;
+    textIndent?: number;
+    /** Use an ideographic-space-compatible first-line indent. */
+    fullwidthSpaceIndent?: boolean;
+    /** EPUB has no fixed pages; use `typographic` when overriding type metrics. */
+    gridMode?: "strict" | "typographic";
+    chapterSplitLevel?: "h1" | "h2" | "h3" | "none";
+    /** Shorthand for `cover: { data: coverImage, mediaType: coverMediaType }`. */
+    coverImage?: Uint8Array;
+    coverMediaType?: EpubCover["mediaType"];
+};
+/**
+ * Profile for a configured DOCX export, including page geometry and numbering.
+ */
+type MdiDocxExportProfile = ExportProfile & {
+    title?: string;
+    author?: string;
+    publisher?: string;
+    identifier?: string;
+    language?: string;
+    date?: string;
+    verticalWriting?: boolean;
+    fontFamily?: string;
+    /** Point size; requires a publication adapter that supports it. */
+    fontSize?: number;
+    /** Line-height multiplier; requires a publication adapter that supports it. */
+    lineSpacing?: number;
+    textIndent?: number;
+    pageSize?: NonNullable<ExportProfile["pagination"]>["pageSize"];
+    landscape?: boolean;
+    /** `strict` enforces the character/line grid; `typographic` prioritizes explicit type metrics. */
+    gridMode?: "strict" | "typographic";
+    charactersPerLine?: number;
+    linesPerPage?: number;
+    margins?: NonNullable<NonNullable<ExportProfile["pagination"]>["margins"]>;
+    /** Emit literal ideographic spaces for first-line indentation in DOCX. */
+    fullwidthSpaceIndent?: boolean;
+    showPageNumbers?: boolean;
+    pageNumberPosition?: NonNullable<NonNullable<ExportProfile["pagination"]>["pageNumbers"]>["position"];
+    pageNumberFormat?: NonNullable<NonNullable<ExportProfile["pagination"]>["pageNumbers"]>["format"];
+};
 /** MDI specification version implemented by this binding. */
 declare const MDI_SPEC_VERSION: "2.0";
 /** Version of the complete Rust-owned document IR. */
@@ -48,6 +113,27 @@ interface MdiDocument {
     frontmatter?: MdiFrontmatter;
     children: MdiNode[];
 }
+/** A source-backed heading available to host navigation and chapter UIs. */
+interface MdiHeading {
+    depth: 1 | 2 | 3 | 4 | 5 | 6;
+    /** Plain, source-order text. Inline MDI is represented by `node` as well. */
+    text: string;
+    span?: MdiSourceSpan;
+    /** The complete Rust-owned heading node, including inline children. */
+    node: MdiNode;
+}
+/** HTML output controls that do not alter MDI semantics. */
+interface MdiHtmlRenderOptions {
+    /** Return the semantic contents of `<body>` rather than a standalone page. */
+    bodyOnly?: boolean;
+}
+/** A parsed document retained with renderer output for UI diagnostics. */
+interface MdiRenderResult<T> {
+    output: T;
+    document: MdiDocument;
+    diagnostics: MdiDiagnostic[];
+    headings: MdiHeading[];
+}
 /**
  * Versioned result returned by the Rust parser.
  *
@@ -68,20 +154,79 @@ type MdiSyntaxDocument = MdiDocument;
  * language-neutral document IR. JavaScript performs no grammar work.
  */
 declare function parse(source: string): MdiSyntaxParseResult;
-/** Render complete `.mdi` source to standalone HTML in Rust. */
-declare function renderHtml(source: string): string;
+/** Render complete `.mdi` source to standalone semantic HTML in Rust. */
+declare function renderHtml(source: string, options?: MdiHtmlRenderOptions): string;
+/**
+ * Render HTML while retaining the Rust parser result that made the semantic
+ * decisions. Use this in editors: warnings and source spans remain available
+ * instead of being silently discarded, and `headings` can drive navigation or
+ * chapter controls without scraping generated HTML.
+ *
+ * The low-level Rust ABI currently accepts source for rendering, rather than a
+ * serializable IR handle. This helper therefore validates with the same Rust
+ * parser immediately before rendering and returns that exact parse result.
+ */
+declare function renderHtmlWithDiagnostics(source: string, options?: MdiHtmlRenderOptions): MdiRenderResult<string>;
+/**
+ * Parse once for a host workflow that needs stable diagnostics and source
+ * spans before selecting one of the renderer APIs. The returned document is
+ * Rust-owned IR and must not be mutated as an input to a renderer.
+ */
+declare function prepareRender(source: string): MdiSyntaxParseResult;
 /** Build a baseline EPUB 3 archive from complete source in Rust. */
 declare function renderEpub(source: string): Uint8Array;
+/**
+ * Build a profile-configured EPUB 3 archive. This overload is asynchronous
+ * because archive generation is performed by the Node.js publication adapter.
+ */
+declare function renderEpub(source: string, options: MdiEpubExportOptions): Promise<Uint8Array>;
+/** Build a baseline Rust EPUB while retaining diagnostics for an export UI. */
+declare function renderEpubWithDiagnostics(source: string): MdiRenderResult<Uint8Array>;
+declare function renderEpubWithDiagnostics(source: string, options: MdiEpubExportOptions): Promise<MdiRenderResult<Uint8Array>>;
 /** Build a baseline DOCX archive from complete source in Rust. */
 declare function renderDocx(source: string): Uint8Array;
+/**
+ * Build a profile-configured DOCX archive. This overload is asynchronous
+ * because archive generation is performed by the Node.js publication adapter.
+ */
+declare function renderDocx(source: string, profile: MdiDocxExportProfile): Promise<Uint8Array>;
+/** Build a baseline Rust DOCX while retaining diagnostics for an export UI. */
+declare function renderDocxWithDiagnostics(source: string): MdiRenderResult<Uint8Array>;
+declare function renderDocxWithDiagnostics(source: string, profile: MdiDocxExportProfile): Promise<MdiRenderResult<Uint8Array>>;
+/**
+ * Build a configured EPUB using the same profile schema as the dedicated
+ * publication adapters.  Unlike the one-argument {@link renderEpub}, this
+ * returns a Promise and supports cover art, metadata, chapters and vertical
+ * writing.
+ */
+declare function renderEpubWithProfile(source: string, options?: MdiEpubExportOptions): Promise<Uint8Array>;
+/**
+ * Build a configured DOCX using the shared print profile.  The profile
+ * supports metadata, writing mode, paper size, margins and page numbers.
+ */
+declare function renderDocxWithProfile(source: string, profile?: MdiDocxExportProfile): Promise<Uint8Array>;
+/**
+ * Map the Rust-owned IR to mdast for the publication adapters. This is a
+ * structural conversion only: all grammar decisions have already been made
+ * by {@link parse}, so it never reparses MDI source in JavaScript.
+ */
+/**
+ * Convert a Rust-owned MDI document IR into mdast for publication adapters.
+ * This performs no parsing and preserves the adapter node conventions.
+ */
+declare function toPublicationMdast(document: MdiDocument): Root;
 /** Parse and normalize complete `.mdi` source with Rust's serializer. */
 declare function serializeMdi(source: string): string;
 /** Render complete `.mdi` source to deterministic plain text in Rust. */
 declare function renderText(source: string): string;
+/** Render plain text without discarding Rust diagnostics and source spans. */
+declare function renderTextWithDiagnostics(source: string): MdiRenderResult<string>;
 type MdiTextFormat = "txt" | "txt-ruby" | "narou" | "kakuyomu" | "aozora";
 /** Render a named publication-text convention through Rust. */
 declare function renderTextFormat(source: string, format: MdiTextFormat, indentPrefix?: string): string;
+/** Render a named text format without discarding Rust diagnostics and spans. */
+declare function renderTextFormatWithDiagnostics(source: string, format: MdiTextFormat, indentPrefix?: string): MdiRenderResult<string>;
 /** @deprecated Use {@link parse}; it now parses the complete document. */
 declare const parseMdiSyntax: typeof parse;
 
-export { MDI_IR_VERSION, MDI_SPEC_VERSION, type MdiDiagnostic, type MdiDocument, type MdiFrontmatter, type MdiNode, type MdiParserCapabilities, type MdiRubyReading, type MdiSourceSpan, type MdiSyntaxDocument, type MdiSyntaxParseResult, type MdiTextFormat, parse, parseMdiSyntax, renderDocx, renderEpub, renderHtml, renderText, renderTextFormat, serializeMdi };
+export { MDI_IR_VERSION, MDI_SPEC_VERSION, type MdiDiagnostic, type MdiDocument, type MdiDocxExportProfile, type MdiEpubExportOptions, type MdiFrontmatter, type MdiHeading, type MdiHtmlRenderOptions, type MdiNode, type MdiParserCapabilities, type MdiRenderResult, type MdiRubyReading, type MdiSourceSpan, type MdiSyntaxDocument, type MdiSyntaxParseResult, type MdiTextFormat, parse, parseMdiSyntax, prepareRender, renderDocx, renderDocxWithDiagnostics, renderDocxWithProfile, renderEpub, renderEpubWithDiagnostics, renderEpubWithProfile, renderHtml, renderHtmlWithDiagnostics, renderText, renderTextFormat, renderTextFormatWithDiagnostics, renderTextWithDiagnostics, serializeMdi, toPublicationMdast };