@franken-suite/franken-markdown 0.4.2 → 0.4.4

package/fmd-view.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `<fmd-view>` web component type surface (bead uito).
+ */
+
+export interface FmdRenderedDetail {
+  bytes: number;
+  sourceLength: number;
+  diagnostics: Array<{
+    severity: "warning" | "error";
+    start: number;
+    end: number;
+    message: string;
+  }>;
+}
+
+export interface FmdViewEventMap {
+  "fmd-rendered": CustomEvent<FmdRenderedDetail>;
+  "fmd-error": CustomEvent<{ error: string }>;
+}
+
+export interface FmdView extends HTMLElement {
+  addEventListener<K extends keyof FmdViewEventMap>(
+    type: K,
+    listener: (this: FmdView, ev: FmdViewEventMap[K]) => void,
+    options?: boolean | AddEventListenerOptions
+  ): void;
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void;
+}
+
+/**
+ * Register `<fmd-view>` (idempotent). Auto-registered in browser globals on
+ * import; call this explicitly for a non-global registry.
+ */
+export function registerFmdView(
+  registry?: Pick<CustomElementRegistry, "define" | "get">
+): "fmd-view";

package/fmd-view.js

@@ -0,0 +1,137 @@
+// <fmd-view> — drop-in Markdown renderer web component (bead uito).
+//
+// Framework-free custom element over the package's createRenderer surface:
+//
+//   <fmd-view src="./README.md"></fmd-view>
+//   <fmd-view>Six **bytes** of markdown</fmd-view>
+//
+// Attributes:
+//   src       - fetch this URL as the Markdown source (slot content is the
+//               fallback when src is absent/unset)
+//   font      - "sans" | "serif"
+//   dark-mode - "auto" | "disabled"
+//
+// The rendered document lands in a shadow root (style-isolated; the engine's
+// self-contained HTML carries its own CSS). A "fmd-rendered" CustomEvent with
+// { bytes, sourceLength, diagnostics } fires after each successful render;
+// "fmd-error" fires on fetch/render failure. Bytes parity with renderHtml()
+// is exact: the same call is used.
+//
+// Zero dependencies; the shared wasm payload is the package's.
+
+import { createRenderer } from "./franken_markdown.js";
+
+let rendererPromise = null;
+
+function sharedRenderer(wasmInput) {
+  if (!rendererPromise) {
+    rendererPromise = createRenderer(wasmInput);
+  }
+  return rendererPromise;
+}
+
+const SLOT_RENDER = Symbol("slot source");
+
+class FmdView extends HTMLElement {
+  static get observedAttributes() {
+    return ["src", "font", "dark-mode"];
+  }
+
+  #root = null;
+  #lastSrc = undefined;
+
+  constructor() {
+    super();
+    this.#root = this.attachShadow({ mode: "open" });
+    this.#root.innerHTML = "<style>:host{display:block}</style><slot></slot>";
+  }
+
+  connectedCallback() {
+    this.#render();
+  }
+
+  attributeChangedCallback(name, oldV, newV) {
+    if (oldV === newV || !this.#root) {
+      return;
+    }
+    if (name === "src" && newV !== this.#lastSrc) {
+      this.#render();
+      return;
+    }
+    if (name === "font" || name === "dark-mode") {
+      this.#render();
+    }
+  }
+
+  async #source() {
+    const src = this.getAttribute("src");
+    if (src) {
+      const res = await fetch(src);
+      if (!res.ok) {
+        throw new Error(`fmd-view: fetch ${src} -> HTTP ${res.status}`);
+      }
+      return await res.text();
+    }
+    // Slot content as inline Markdown. Preserve text exactly.
+    const slot = this.querySelector("script[type='text/markdown']");
+    if (slot) {
+      return slot.textContent ?? "";
+    }
+    return this.textContent ?? "";
+  }
+
+  async #render() {
+    const srcAttr = this.getAttribute("src");
+    this.#lastSrc = srcAttr;
+    let markdown;
+    try {
+      markdown = await this.#source();
+    } catch (err) {
+      this.dispatchEvent(new CustomEvent("fmd-error", { detail: { error: String(err) } }));
+      return;
+    }
+    let renderer;
+    try {
+      // If the host already initialized the engine with explicit wasm bytes,
+      // a package-level export would be needed; default path resolves the
+      // bundled artifact via the wrapper's own URL resolution.
+      renderer = await sharedRenderer(undefined);
+    } catch (err) {
+      this.dispatchEvent(new CustomEvent("fmd-error", { detail: { error: String(err) } }));
+      return;
+    }
+    const out = await renderer.renderHtml(markdown, {
+      font: this.getAttribute("font") === "serif" ? "serif" : "sans",
+      darkMode: this.getAttribute("dark-mode") === "disabled" ? "disabled" : "auto",
+    });
+    const html = out.text();
+    this.#root.innerHTML = `<style>:host{display:block}</style>${html}`;
+    this.dispatchEvent(
+      new CustomEvent("fmd-rendered", {
+        detail: {
+          bytes: out.bytes.byteLength,
+          sourceLength: out.sourceLength,
+          diagnostics: out.diagnostics,
+        },
+      })
+    );
+  }
+}
+
+const ELEMENT_NAME = "fmd-view";
+
+/**
+ * Register <fmd-view> on a customElements registry (defaults to global).
+ * Idempotent; returns the element name.
+ */
+export function registerFmdView(registry = globalThis.customElements) {
+  if (!registry.get(ELEMENT_NAME)) {
+    registry.define(ELEMENT_NAME, FmdView);
+  }
+  return ELEMENT_NAME;
+}
+
+// Auto-register in browser globals (no-op under Node/bundlers without it).
+if (typeof globalThis.customElements !== "undefined") {
+  registerFmdView();
+}

package/franken_markdown.d.ts

@@ -1,4 +1,12 @@
-export type FmdOutputFormat = "html" | "pdf";
+export type FmdOutputFormat =
+  | "html"
+  | "pdf"
+  | "svg"
+  | "epub"
+  | "interactive-html"
+  | "diff-html"
+  | "book-site"
+  | "book-pdf";
 export type FmdFont = "sans" | "serif";
 export type FmdDarkMode = "auto" | "disabled";
 
@@ -58,6 +66,20 @@ export interface FmdRenderOptions {
   headingScale?: number;
   /** Nominal table cell size override in points; clamped to [5, base]. */
   tableFontSize?: number;
+  /** BCP-47 language tag used for HTML metadata and language-aware hyphenation. */
+  lang?: "en" | "de" | "fr" | "es" | "nl" | string;
+  /** Generate a document table of contents. */
+  toc?: boolean;
+  /** Maximum generated TOC heading depth (1...6). */
+  tocDepth?: number;
+  /** Adaptive PDF page-count target. */
+  fitToPages?: number;
+  /** Enable optical-margin punctuation protrusion for justified PDF text. */
+  microtype?: "disabled" | "protrusion";
+  /** Boolean alias for microtype: "protrusion". */
+  microtypeProtrusion?: boolean;
+  /** Standalone SVG poster width in points. */
+  maxWidthPt?: number;
   /** Host-supplied image bytes (HTML data URIs and PDF embedding); any number per render. */
   pdfImages?: FmdPdfImageAsset[];
   /** Host-supplied TrueType font bytes by renderer slot. */
@@ -110,14 +132,80 @@ export interface FmdCapabilities {
 
 export interface FmdRenderer {
   capabilities(): Promise<FmdCapabilities>;
+  accessibilityAudit(markdown: string): Promise<FmdAccessibilityReport>;
+  documentStats(markdown: string): Promise<FmdDocumentStats>;
+  renderBookPdf(files: FmdBookFile[], options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+  renderBookSite(files: FmdBookFile[], options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+  renderEpub(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
   renderHtml(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+  renderInteractiveHtml(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
   renderPdf(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+  renderSemanticDiff(oldMarkdown: string, newMarkdown: string, options?: FmdDiffOptions): Promise<FmdRenderOutput>;
+  renderSvg(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+  searchIndex(markdown: string): Promise<FmdSearchIndex>;
+  semanticDiff(oldMarkdown: string, newMarkdown: string, options?: FmdDiffOptions): Promise<FmdSemanticDiff>;
+}
+
+export interface FmdBookFile { path: string; source: string; }
+export interface FmdDiffOptions { oldName?: string; newName?: string; }
+export interface FmdFinding { severity?: string; code: string; message?: string; detail?: string; }
+export interface FmdDocumentStats {
+  schema: "fmd-document-stats-v1";
+  bytes: number;
+  lines: number;
+  words: number;
+  characters: number;
+  sentences: number;
+  syllables: number;
+  reading_time_secs: number;
+  speaking_time_secs: number;
+  flesch_reading_ease: number;
+  flesch_kincaid_grade: number;
+  reading_ease_label: string;
+  structure: Record<string, unknown>;
+  outline: Array<{ level: number; text: string; slug: string }>;
+  findings: FmdFinding[];
+}
+export interface FmdAccessibilityReport {
+  schema_version: "1";
+  target: "pdf";
+  findings: FmdFinding[];
+  [key: string]: unknown;
+}
+export interface FmdSearchIndex {
+  schema: "fmd-search-index-v1";
+  entries: Array<{ kind: "heading" | "paragraph"; level?: number; anchor: string; text: string }>;
+}
+export interface FmdSemanticDiff {
+  schema: "fmd-diff-v1";
+  old_name: string;
+  new_name: string;
+  stats: {
+    unchanged_blocks: number;
+    inserted_blocks: number;
+    deleted_blocks: number;
+    modified_blocks: number;
+    words_inserted: number;
+    words_deleted: number;
+    similarity_ratio: number;
+  };
+  [key: string]: unknown;
 }
 
 export function init(input?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module): Promise<void>;
 export function capabilities(): Promise<FmdCapabilities>;
+export function accessibilityAudit(markdown: string): Promise<FmdAccessibilityReport>;
+export function documentStats(markdown: string): Promise<FmdDocumentStats>;
+export function renderBookPdf(files: FmdBookFile[], options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+export function renderBookSite(files: FmdBookFile[], options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+export function renderEpub(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
 export function renderHtml(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+export function renderInteractiveHtml(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
 export function renderPdf(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+export function renderSemanticDiff(oldMarkdown: string, newMarkdown: string, options?: FmdDiffOptions): Promise<FmdRenderOutput>;
+export function renderSvg(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+export function searchIndex(markdown: string): Promise<FmdSearchIndex>;
+export function semanticDiff(oldMarkdown: string, newMarkdown: string, options?: FmdDiffOptions): Promise<FmdSemanticDiff>;
 export function createRenderer(
   input?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module
 ): Promise<FmdRenderer>;

package/franken_markdown.js

@@ -1,9 +1,17 @@
 import initWasm, {
+  accessibilityAudit as wasmAccessibilityAudit,
   capabilities as wasmCapabilities,
-  renderHtmlConfigured,
-  renderHtmlConfiguredWithFonts,
-  renderHtmlConfiguredMulti,
-  renderPdfConfiguredMulti
+  documentStats as wasmDocumentStats,
+  renderBookPdf as wasmRenderBookPdf,
+  renderBookSite as wasmRenderBookSite,
+  renderEpubConfigured,
+  renderHtmlConfiguredAdvanced,
+  renderInteractiveHtmlConfigured,
+  renderPdfConfiguredMulti,
+  renderSemanticDiffHtml as wasmRenderSemanticDiffHtml,
+  renderSvgConfigured,
+  searchIndex as wasmSearchIndex,
+  semanticDiff as wasmSemanticDiff
 } from "./pkg/franken_markdown.js";
 
 let initPromise = null;
@@ -29,62 +37,37 @@ export async function renderHtml(markdown, options = {}) {
   await init();
   const pdfImages = pdfImagesOption(options.pdfImages);
   const fontAssets = fontAssetsOption(options.fontAssets);
-  if (pdfImages.length > 0) {
-    const destinations = pdfImages.map((image) => image.destination);
-    const lengths = new Uint32Array(pdfImages.map((image) => image.bytes.length));
-    const totalBytes = pdfImages.reduce((sum, image) => sum + image.bytes.length, 0);
-    const flatBytes = new Uint8Array(totalBytes);
-    let offset = 0;
-    for (const image of pdfImages) {
-      flatBytes.set(image.bytes, offset);
-      offset += image.bytes.length;
-    }
-    return normalizeResult(
-      renderHtmlConfiguredMulti(
-        String(markdown),
-        stringOption(options.font),
-        darkModeOption(options.darkMode),
-        verbatimOption(options.title),
-        verbatimOption(options.customCss),
-        Boolean(options.allowRawHtml),
-        fontBytesForSlot(fontAssets, "body-regular"),
-        fontBytesForSlot(fontAssets, "body-bold"),
-        fontBytesForSlot(fontAssets, "body-italic"),
-        fontBytesForSlot(fontAssets, "body-bold-italic"),
-        fontBytesForSlot(fontAssets, "mono-regular"),
-        fontWeightsForSlots(fontAssets),
-        destinations,
-        flatBytes,
-        lengths
-      )
-    );
-  }
-  if (fontAssets.length > 0) {
-    return normalizeResult(
-      renderHtmlConfiguredWithFonts(
-        String(markdown),
-        stringOption(options.font),
-        darkModeOption(options.darkMode),
-        verbatimOption(options.title),
-        verbatimOption(options.customCss),
-        Boolean(options.allowRawHtml),
-        fontBytesForSlot(fontAssets, "body-regular"),
-        fontBytesForSlot(fontAssets, "body-bold"),
-        fontBytesForSlot(fontAssets, "body-italic"),
-        fontBytesForSlot(fontAssets, "body-bold-italic"),
-        fontBytesForSlot(fontAssets, "mono-regular"),
-        fontWeightsForSlots(fontAssets)
-      )
-    );
+  const fontScale = fontScaleOption(options.fontScale ?? options.typeSize);
+  const destinations = pdfImages.map((image) => image.destination);
+  const lengths = new Uint32Array(pdfImages.map((image) => image.bytes.length));
+  const totalBytes = pdfImages.reduce((sum, image) => sum + image.bytes.length, 0);
+  const flatBytes = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const image of pdfImages) {
+    flatBytes.set(image.bytes, offset);
+    offset += image.bytes.length;
   }
   return normalizeResult(
-    renderHtmlConfigured(
+    renderHtmlConfiguredAdvanced(
       String(markdown),
       stringOption(options.font),
       darkModeOption(options.darkMode),
       verbatimOption(options.title),
       verbatimOption(options.customCss),
-      Boolean(options.allowRawHtml)
+      Boolean(options.allowRawHtml),
+      fontScale,
+      fontBytesForSlot(fontAssets, "body-regular"),
+      fontBytesForSlot(fontAssets, "body-bold"),
+      fontBytesForSlot(fontAssets, "body-italic"),
+      fontBytesForSlot(fontAssets, "body-bold-italic"),
+      fontBytesForSlot(fontAssets, "mono-regular"),
+      fontWeightsForSlots(fontAssets),
+      destinations,
+      flatBytes,
+      lengths,
+      stringOption(options.lang),
+      Boolean(options.toc),
+      integerOption(options.tocDepth, "tocDepth")
     )
   );
 }
@@ -93,6 +76,8 @@ export async function renderPdf(markdown, options = {}) {
   await init();
   const pdfImages = pdfImagesOption(options.pdfImages);
   const fontAssets = fontAssetsOption(options.fontAssets);
+  const fontScale = fontScaleOption(options.fontScale ?? options.typeSize);
+  const baseFontSize = numberOption(options.baseFontSize) ?? (fontScale !== undefined ? 11 * fontScale : undefined);
 
   // Flatten any number of images into the three parallel arrays the core ABI
   // accepts (wasm-bindgen cannot pass a Vec<Vec<u8>>): a destination per image,
@@ -126,20 +111,134 @@ export async function renderPdf(markdown, options = {}) {
       fontBytesForSlot(fontAssets, "body-bold-italic"),
       fontBytesForSlot(fontAssets, "mono-regular"),
       fontWeightsForSlots(fontAssets),
-      numberOption(options.baseFontSize),
+      baseFontSize,
       numberOption(options.headingScale),
       numberOption(options.tableFontSize),
-      Boolean(options.pageNumbers)
+      Boolean(options.pageNumbers),
+      fontScale,
+      stringOption(options.lang),
+      Boolean(options.toc),
+      integerOption(options.tocDepth, "tocDepth"),
+      integerOption(options.fitToPages, "fitToPages"),
+      options.microtype === "protrusion" || options.microtypeProtrusion === true
     )
   );
 }
 
+export async function renderSvg(markdown, options = {}) {
+  await init();
+  return normalizeResult(renderSvgConfigured(
+    String(markdown),
+    stringOption(options.font),
+    darkModeOption(options.darkMode),
+    fontScaleOption(options.fontScale ?? options.typeSize),
+    numberOption(options.maxWidthPt)
+  ));
+}
+
+export async function renderEpub(markdown, options = {}) {
+  await init();
+  return normalizeResult(renderEpubConfigured(
+    String(markdown),
+    stringOption(options.font),
+    darkModeOption(options.darkMode),
+    verbatimOption(options.title),
+    stringOption(options.lang),
+    fontScaleOption(options.fontScale ?? options.typeSize)
+  ));
+}
+
+export async function renderInteractiveHtml(markdown, options = {}) {
+  await init();
+  return normalizeResult(renderInteractiveHtmlConfigured(
+    String(markdown),
+    stringOption(options.font),
+    darkModeOption(options.darkMode),
+    verbatimOption(options.title),
+    stringOption(options.lang),
+    fontScaleOption(options.fontScale ?? options.typeSize)
+  ));
+}
+
+export async function documentStats(markdown) {
+  await init();
+  return parseJson(wasmDocumentStats(String(markdown)), "document stats JSON");
+}
+
+export async function searchIndex(markdown) {
+  await init();
+  return parseJson(wasmSearchIndex(String(markdown)), "search index JSON");
+}
+
+export async function accessibilityAudit(markdown) {
+  await init();
+  return parseJson(wasmAccessibilityAudit(String(markdown)), "accessibility audit JSON");
+}
+
+export async function semanticDiff(oldMarkdown, newMarkdown, options = {}) {
+  await init();
+  return parseJson(wasmSemanticDiff(
+    String(oldMarkdown),
+    String(newMarkdown),
+    verbatimOption(options.oldName),
+    verbatimOption(options.newName)
+  ), "semantic diff JSON");
+}
+
+export async function renderSemanticDiff(oldMarkdown, newMarkdown, options = {}) {
+  await init();
+  return normalizeResult(wasmRenderSemanticDiffHtml(
+    String(oldMarkdown),
+    String(newMarkdown),
+    verbatimOption(options.oldName),
+    verbatimOption(options.newName)
+  ));
+}
+
+export async function renderBookSite(files, options = {}) {
+  await init();
+  const normalized = bookFilesOption(files);
+  return normalizeResult(wasmRenderBookSite(
+    normalized.map((file) => file.path),
+    normalized.map((file) => file.source),
+    verbatimOption(options.title),
+    stringOption(options.font),
+    darkModeOption(options.darkMode),
+    fontScaleOption(options.fontScale ?? options.typeSize)
+  ));
+}
+
+export async function renderBookPdf(files, options = {}) {
+  await init();
+  const normalized = bookFilesOption(files);
+  return normalizeResult(wasmRenderBookPdf(
+    normalized.map((file) => file.path),
+    normalized.map((file) => file.source),
+    verbatimOption(options.title),
+    verbatimOption(options.author),
+    stringOption(options.font),
+    darkModeOption(options.darkMode),
+    fontScaleOption(options.fontScale ?? options.typeSize),
+    options.pageNumbers !== false
+  ));
+}
+
 export async function createRenderer(input) {
   await init(input);
   return Object.freeze({
     capabilities,
+    accessibilityAudit,
+    documentStats,
+    renderBookPdf,
+    renderBookSite,
+    renderEpub,
     renderHtml,
-    renderPdf
+    renderInteractiveHtml,
+    renderPdf,
+    renderSemanticDiff,
+    renderSvg,
+    searchIndex,
+    semanticDiff
   });
 }
 
@@ -267,6 +366,118 @@ function numberOption(value) {
   }
   return value;
 }
+
+function integerOption(value, label) {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError(`${label} must be a positive integer`);
+  }
+  return value;
+}
+
+function bookFilesOption(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new TypeError("book files must be a non-empty array of { path, source } objects");
+  }
+  return value.map((file, index) => {
+    if (file === null || typeof file !== "object") {
+      throw new TypeError(`book files[${index}] must be an object`);
+    }
+    const path = stringOption(file.path);
+    if (path === undefined) {
+      throw new TypeError(`book files[${index}].path must be a non-empty string`);
+    }
+    return Object.freeze({ path, source: String(file.source ?? "") });
+  });
+}
+
+function fontScaleOption(value) {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new TypeError("fontScale must be a positive finite number");
+    }
+    return Math.min(3.0, Math.max(0.5, value));
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim().toLowerCase();
+    switch (trimmed) {
+      case "xs":
+      case "x-small":
+      case "extra-small":
+      case "extrasmall":
+      case "tiny":
+        return 0.75;
+      case "sm":
+      case "small":
+      case "compact":
+        return 0.875;
+      case "md":
+      case "medium":
+      case "normal":
+      case "default":
+      case "regular":
+      case "standard":
+        return 1.0;
+      case "lg":
+      case "large":
+      case "comfortable":
+        return 1.125;
+      case "xl":
+      case "x-large":
+      case "extra-large":
+      case "extralarge":
+        return 1.25;
+      case "2xl":
+      case "xxl":
+      case "huge":
+      case "display":
+        return 1.5;
+      default:
+        break;
+    }
+    if (trimmed.endsWith("%")) {
+      const parsed = parseFloat(trimmed.slice(0, -1));
+      if (Number.isFinite(parsed) && parsed > 0) {
+        return Math.min(3.0, Math.max(0.5, parsed / 100));
+      }
+    }
+    if (trimmed.endsWith("rem")) {
+      const parsed = parseFloat(trimmed.slice(0, -3));
+      if (Number.isFinite(parsed) && parsed > 0) {
+        return Math.min(3.0, Math.max(0.5, parsed));
+      }
+    }
+    if (trimmed.endsWith("em")) {
+      const parsed = parseFloat(trimmed.slice(0, -2));
+      if (Number.isFinite(parsed) && parsed > 0) {
+        return Math.min(3.0, Math.max(0.5, parsed));
+      }
+    }
+    if (trimmed.endsWith("px")) {
+      const parsed = parseFloat(trimmed.slice(0, -2));
+      if (Number.isFinite(parsed) && parsed > 0) {
+        return Math.min(3.0, Math.max(0.5, parsed / 16));
+      }
+    }
+    if (trimmed.endsWith("pt")) {
+      const parsed = parseFloat(trimmed.slice(0, -2));
+      if (Number.isFinite(parsed) && parsed > 0) {
+        return Math.min(3.0, Math.max(0.5, parsed / 11));
+      }
+    }
+    const parsed = parseFloat(trimmed);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return Math.min(3.0, Math.max(0.5, parsed));
+    }
+    throw new TypeError(`unknown fontScale '${value}'. Valid choices: xs, sm, md, lg, xl, 2xl, or a number/percentage.`);
+  }
+  throw new TypeError("fontScale must be a number or string");
+}
 function pdfImagesOption(value) {
   if (value === undefined || value === null) {
     return [];

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@franken-suite/franken-markdown",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Browser/WASM package for franken_markdown Markdown to HTML/PDF rendering.",
   "type": "module",
-  "sideEffects": false,
+  "sideEffects": [
+    "./fmd-view.js"
+  ],
   "license": "LicenseRef-MIT-OpenAI-Anthropic-Rider",
   "author": "Jeffrey Emanuel",
   "homepage": "https://github.com/Dicklesworthstone/franken_markdown#readme",
@@ -35,6 +37,10 @@
     ".": {
       "types": "./franken_markdown.d.ts",
       "import": "./franken_markdown.js"
+    },
+    "./web-component": {
+      "types": "./fmd-view.d.ts",
+      "import": "./fmd-view.js"
     }
   },
   "files": [
@@ -45,6 +51,8 @@
     "pkg/franken_markdown.js",
     "pkg/franken_markdown_bg.wasm",
     "pkg/franken_markdown_bg.wasm.d.ts",
-    "pkg/franken_markdown.d.ts"
+    "pkg/franken_markdown.d.ts",
+    "fmd-view.js",
+    "fmd-view.d.ts"
   ]
 }