@flamingo-stack/openframe-frontend-core 0.0.508 → 0.0.509

package/dist/components/ui/markdown/base-components.d.ts

@@ -0,0 +1,51 @@
+import type { Components } from 'react-markdown';
+import type { ResolveLinkResult } from '../../../types/doc-source';
+import type { TextSizeElement } from './text-size';
+export declare function hasRenderableSrc(src: unknown): src is string;
+export interface BuildBaseComponentsOptions {
+    textSizes: Record<TextSizeElement, string>;
+    demoteMarkdownH1ToH2: boolean;
+    brokenLinks: readonly string[];
+    currentPath?: string;
+    onInternalLinkClick?: (path: string, options?: {
+        expandFolder?: boolean;
+        fromInternalLink?: boolean;
+    }) => void;
+    onResolveLink?: (href: string, currentPath: string) => Promise<ResolveLinkResult>;
+}
+/**
+ * The standard leaf renderers (`code` block + inline, `blockquote`, `div`
+ * pass-through) as standalone functions.
+ *
+ * SSOT for compositions that must OVERRIDE these renderers for a narrow
+ * special case and then fall through: the rich composition intercepts embed
+ * fence languages, shortcode-expanded `div`s and Reddit's `reddit-embed-bq`
+ * blockquote, and delegates everything else here. Previously it reproduced
+ * these renderers byte-for-byte, so any class change here silently drifted
+ * on content surfaces.
+ *
+ * THESE MUST STAY HOOK-FREE: the rich composition calls them as plain
+ * functions from inside its own renderers (`standard.code(props)`), which is
+ * not a React render of a component and would break the rules of hooks.
+ * Hook-using renderers (the headings, which read the heading-line offset
+ * from context) live in `buildBaseComponents` below and are never delegated
+ * to this way.
+ *
+ * ODS-TOKENS FLAG (ODS_TOKEN_RULES §Typography / §General): inline code keeps
+ * an inline `text-[0.9em]`, carried over verbatim from the pre-unification
+ * renderers — ODS has no relative-to-parent code size, so mapping it onto an
+ * existing token would visibly change every inline code span. Same shape as
+ * the flag in ./text-size.ts — flagged for addition to ODS, not copied
+ * anywhere else.
+ *
+ * The code BLOCK's font is NOT flagged: the raw "JetBrains Mono", "SF Mono",
+ * Consolas stack the old renderer inlined is gone, replaced by Tailwind's
+ * `font-mono` (→ `var(--font-family-heading)`, the Azeret Mono ODS stack) —
+ * the same class the inline-code branch below already used, so the two code
+ * surfaces no longer disagree about their family.
+ */
+export declare function buildStandardLeafRenderers({ textSizes, }: {
+    textSizes: Record<TextSizeElement, string>;
+}): Pick<Components, 'code' | 'blockquote' | 'div'>;
+export declare function buildBaseComponents({ textSizes, demoteMarkdownH1ToH2, brokenLinks, currentPath: propCurrentPath, onInternalLinkClick, onResolveLink, }: BuildBaseComponentsOptions): Components;
+//# sourceMappingURL=base-components.d.ts.map

package/dist/components/ui/markdown/base-components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-components.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/base-components.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AA4CnD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAE5D;AAED,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;IAC3C,oBAAoB,EAAE,OAAO,CAAC;IAC9B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC/G,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACnF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,0BAA0B,CAAC,EACzC,SAAS,GACV,EAAE;IACD,SAAS,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;CAC5C,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,GAAG,KAAK,CAAC,CA4DlD;AAED,wBAAgB,mBAAmB,CAAC,EAClC,SAAS,EACT,oBAAoB,EACpB,WAAW,EACX,WAAW,EAAE,eAAe,EAC5B,mBAAmB,EACnB,aAAa,GACd,EAAE,0BAA0B,GAAG,UAAU,CAwLzC"}

package/dist/components/ui/markdown/engine.d.ts

@@ -0,0 +1,99 @@
+/**
+ * MarkdownEngine — THE one react-markdown pipeline for every surface
+ * (chat messages, blog, docs, KB articles, legal, releases, admin previews).
+ *
+ * `SimpleMarkdownRenderer` and `RichMarkdownRenderer` are thin compositions
+ * over this engine (see ./simple-markdown-renderer.tsx and ./rich/) — there
+ * is exactly ONE parse path, ONE sanitizer stack, ONE mermaid, ONE
+ * heading-id algorithm, ONE link-click model. Do not fork this pipeline;
+ * extend via `componentOverrides` / `additionalRemarkPlugins` /
+ * `preprocessContent` / `extraAllowedHtmlTags`.
+ *
+ * Pipeline order (each stage documented in ./sanitize.ts):
+ *   preprocessContent (composition hook, e.g. shortcodes)
+ *   → completeStreamingTail (streaming only — MUST precede the escape pass)
+ *   → escapeUnknownHtmlTags (text pre-pass, React 19 crash guard)
+ *   → remark: remarkGfm, remarkBreaks, ...additionalRemarkPlugins
+ *   → rehype: rehypeRaw → rehypeSanitize(schema) → rehypeStripUnsafe
+ *       → rehypeHighlight
+ *   → urlTransform: cardAwareUrlTransform
+ *   → components: buildBaseComponents(...) spread-last componentOverrides
+ */
+import React from 'react';
+import { type Components } from 'react-markdown';
+import type { PluggableList } from 'unified';
+import type { ResolveLinkResult } from '../../../types/doc-source';
+import { type TextSizeConfig } from './text-size';
+import { type HeadingSection } from './heading-ids';
+export type { ResolveLinkResult };
+/**
+ * Module-scope empty default for `brokenLinks`.
+ *
+ * A `brokenLinks = []` DEFAULT PARAMETER allocates a fresh array on every
+ * render, so the `components` useMemo (which lists it as a dep) recomputed
+ * every render, which changed `StreamingBlockRenderer`'s `components` prop
+ * identity, which made its `memo` bail EVERY time — every completed block
+ * re-parsed on every streamed token, defeating the entire atomic-block
+ * optimization. Any new default that is an object/array/function MUST be
+ * hoisted here for the same reason.
+ *
+ * Exported so the compositions that apply the SAME default before handing
+ * props down (rich) share this ONE identity instead of declaring a second
+ * module-scope empty array with a copy of this rationale. Deliberately NOT
+ * re-exported from ./index — it is an internal identity contract between the
+ * engine and its compositions, not public API.
+ */
+export declare const NO_BROKEN_LINKS: readonly string[];
+export interface MarkdownEngineProps {
+    content: string;
+    className?: string;
+    /** Backend-provided heading IDs for deep-link anchors */
+    sectionIds?: HeadingSection[];
+    /** When the page already has an H1, render markdown `#` as `<h2>` */
+    demoteMarkdownH1ToH2?: boolean;
+    /** List of broken link hrefs detected server-side (shown with [BROKEN] badge) */
+    brokenLinks?: readonly string[];
+    /** Callback for internal (non-http, non-anchor) link clicks */
+    onInternalLinkClick?: (path: string, options?: {
+        expandFolder?: boolean;
+        fromInternalLink?: boolean;
+    }) => void;
+    /** Current documentation path — enables internal-link mode when set */
+    currentPath?: string;
+    /** Resolve an internal link href to a navigation path. */
+    onResolveLink?: (href: string, currentPath: string) => Promise<ResolveLinkResult>;
+    /** Pre-process the raw markdown string before rendering (e.g. shortcode expansion) */
+    preprocessContent?: (content: string) => string;
+    /** Merge additional or override react-markdown component renderers (spread LAST — caller wins) */
+    componentOverrides?: Partial<Components>;
+    /** Extra remark plugins appended after the built-in remarkGfm + remarkBreaks */
+    additionalRemarkPlugins?: PluggableList;
+    /** Text sizing preset / per-element overrides */
+    textSize?: TextSizeConfig;
+    /**
+     * Extra raw-HTML tags this composition admits. Unioned into BOTH the
+     * text pre-pass allowlist AND the sanitize schema together (the
+     * coupled-allowlist invariant — see ./sanitize.ts).
+     */
+    extraAllowedHtmlTags?: string[];
+    /**
+     * Set true for the actively streaming message ONLY. Enables atomic-block
+     * memoization + fence tail-completion + an aria-live wrapper. The caller
+     * MUST flip back to false on completion — that final render is one
+     * authoritative whole-document parse (block cache discarded), so
+     * streaming can never permanently diverge from the settled output.
+     */
+    streaming?: boolean;
+}
+/**
+ * Memoized so a parent re-render with UNCHANGED props (same `content`
+ * string, same memoized `componentOverrides`/plugins) does NOT re-parse the
+ * markdown. Re-parsing rebuilds the entire react-markdown subtree, which
+ * RE-MOUNTS any embedded inline entity cards — closing their open menus and
+ * re-triggering their fetch on every chat re-render (streaming chunk AND
+ * scroll). With stable props the renderer bails, so completed messages'
+ * cards stay mounted. The streaming path additionally memoizes completed
+ * atomic blocks so the in-flight message re-parses only its live tail.
+ */
+export declare const MarkdownEngine: React.NamedExoticComponent<MarkdownEngineProps>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/components/ui/markdown/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/engine.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAwB,MAAM,OAAO,CAAC;AAC7C,OAAsB,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAM7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAQnE,OAAO,EAAyB,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,eAAe,CAAC;AAIvB,YAAY,EAAE,iBAAiB,EAAE,CAAC;AAElC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAAO,CAAC;AAErD,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;IAC9B,qEAAqE;IACrE,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iFAAiF;IACjF,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,+DAA+D;IAC/D,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC/G,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAClF,sFAAsF;IACtF,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IAChD,kGAAkG;IAClG,kBAAkB,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IACzC,gFAAgF;IAChF,uBAAuB,CAAC,EAAE,aAAa,CAAC;IACxC,iDAAiD;IACjD,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAqMD;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,iDAA2B,CAAC"}

package/dist/components/ui/markdown/heading-ids.d.ts

@@ -0,0 +1,65 @@
+export interface HeadingSection {
+    id: string;
+    title: string;
+    level: number;
+}
+/** `line (1-based, document-wide) → heading id`. */
+export type HeadingIdMap = ReadonlyMap<number, string>;
+/**
+ * Line offset added to unit-relative hast positions. Non-zero only on the
+ * streaming path, where each atomic unit is parsed by its own
+ * `ReactMarkdown` (see `StreamingBlock.startLine`).
+ */
+export declare const HeadingLineOffsetContext: import("react").Context<number>;
+/**
+ * The document's heading-id map, delivered by CONTEXT rather than baked into
+ * the react-markdown `components` map on purpose: the map is rebuilt on every
+ * streamed token (its input is the growing `processedContent`), so listing it
+ * as a `components` memo dep would change that map's identity each token and
+ * make every completed streaming block's `memo` bail — the exact regression
+ * `NO_BROKEN_LINKS` was introduced to fix. Through context only the heading
+ * renderers re-render.
+ */
+export declare const HeadingIdMapContext: import("react").Context<HeadingIdMap>;
+/** Look up the pre-computed id for a heading hast node. Pure. */
+export declare function useHeadingId(node: any): string | undefined;
+/**
+ * Build the document's `line → id` map. Pure: same content + same
+ * `sectionIds` always yields the same map.
+ */
+export declare function buildHeadingIdMap(content: string, sectionIds?: HeadingSection[]): HeadingIdMap;
+/**
+ * Memoized `buildHeadingIdMap` for the engine, with the map's IDENTITY held
+ * stable across content changes that don't touch any heading.
+ *
+ * `content` changes on every streamed token, so the `useMemo` alone rebuilt
+ * a fresh `Map` per token; that map is the context value, so EVERY heading
+ * consumer in every already-completed block re-rendered on every token —
+ * the same identity-churn class `NO_BROKEN_LINKS` exists to prevent, just
+ * one layer down. Rebuilding is cheap; re-rendering the consumers is not, so
+ * the newly built map is compared to the previous one and the previous
+ * object is returned when the entries match.
+ */
+export declare function useHeadingIdMap(content: string, sectionIds?: HeadingSection[]): HeadingIdMap;
+/**
+ * Fallback id for a heading the source scan could NOT see — in practice only
+ * a heading synthesized by a caller remark/rehype plugin, which carries no
+ * source position. (Setext, blockquote/list-nested ATX and multiple raw
+ * `<hN>`s on one line are all scanned now, so they no longer land here.)
+ *
+ * Routed through the SAME dedupe shape as the map so a fallback id can never
+ * collide with an assigned one. It stays PURE — `taken` is derived from the
+ * map, not from render order — which is why two position-less headings with
+ * IDENTICAL text still collide with each other: disambiguating those would
+ * require the shared mutable counter this module deleted.
+ */
+export declare function resolveFallbackHeadingId(base: string, taken: ReadonlySet<string>): string;
+/**
+ * The ids already assigned by the document's heading-id map. Cached per map
+ * IDENTITY, which `useHeadingIdMap` now keeps stable across heading-free
+ * token growth — so this is O(headings) once, not per heading per token.
+ */
+export declare function useAssignedHeadingIds(): ReadonlySet<string>;
+/** Extract plain text from React children (headings receive mixed nodes). */
+export declare function extractText(node: any): string;
+//# sourceMappingURL=heading-ids.d.ts.map

package/dist/components/ui/markdown/heading-ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heading-ids.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/heading-ids.ts"],"names":[],"mappings":"AAoCA,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,oDAAoD;AACpD,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAUtD;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,iCAAmB,CAAA;AAIxD;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,uCAAiD,CAAA;AAEjF,iEAAiE;AAEjE,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAK1D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,cAAc,EAAE,GAC5B,YAAY,CAoEd;AAYD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,cAAc,EAAE,GAC5B,YAAY,CAQd;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAMzF;AAKD;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,WAAW,CAAC,MAAM,CAAC,CAO3D;AAED,6EAA6E;AAE7E,wBAAgB,WAAW,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,CAK7C"}

package/dist/components/ui/markdown/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Unified markdown module — public surface.
+ *
+ * ONE engine (`MarkdownEngine`), two named compositions:
+ *   - `SimpleMarkdownRenderer` — chat/doc surfaces (embed-free bundle)
+ *   - `RichMarkdownRenderer`   — authored-content surfaces (shortcodes,
+ *     social embeds, Video SSOT, OG previews)
+ */
+export { MarkdownEngine, type MarkdownEngineProps } from './engine';
+export { SimpleMarkdownRenderer, type SimpleMarkdownRendererProps, type ResolveLinkResult, } from './simple-markdown-renderer';
+export { RichMarkdownRenderer, type RichMarkdownRendererProps, } from './rich/rich-markdown-renderer';
+export { processShortcodes } from './rich/shortcodes';
+export { SAFE_HTML_TAGS, SVG_TAGS, buildEffectiveTagSet, buildSanitizeSchema, cardAwareUrlTransform, escapeUnknownHtmlTags, rehypeStripUnsafe, } from './sanitize';
+export { TEXT_SIZE_PRESETS, resolveTextSizeConfig, type TextSizeConfig, type TextSizeClassMap, type TextSizeElement, type TextSizePreset, } from './text-size';
+export { MermaidDiagram } from './mermaid-diagram';
+export { buildHeadingIdMap, useHeadingIdMap, extractText, type HeadingSection, type HeadingIdMap, } from './heading-ids';
+export { splitStreamingBlocks, completeStreamingTail, type StreamingBlock } from './streaming';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/ui/markdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACpE,OAAO,EACL,sBAAsB,EACtB,KAAK,2BAA2B,EAChC,KAAK,iBAAiB,GACvB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,oBAAoB,EACpB,KAAK,yBAAyB,GAC/B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EACL,cAAc,EACd,QAAQ,EACR,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,cAAc,GACpB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,WAAW,EACX,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,eAAe,CAAC;AAKvB,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/dist/components/ui/markdown/mermaid-diagram.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Single MermaidDiagram for the unified markdown engine (dark theme only —
+ * the old RichMarkdownRenderer's light-theme branch was dead code behind a
+ * hardcoded `isDarkMode = true` and is deleted, not carried over).
+ *
+ * `mermaid` stays a dynamic import so neither chat nor content bundles pay
+ * for it unless a diagram is actually rendered.
+ */
+import React from 'react';
+/**
+ * SECURITY SSOT for the mermaid renderer — the ONLY place these knobs are
+ * written. `./__tests__/mermaid-security.test.ts` imports THIS constant and
+ * spreads it into its own `mermaid.initialize`, so the fixture and the
+ * component can no longer drift: flipping `securityLevel` to `'loose'` here
+ * fails the suite (verified by doing exactly that).
+ *
+ * This renderer sits on the CHAT path, so the diagram source is MODEL output
+ * — untrusted by construction — and the rendered SVG goes through
+ * `dangerouslySetInnerHTML`. The pre-unification renderer used `'loose'`,
+ * which permits raw HTML inside labels and enables mermaid's `click`
+ * interaction directive: a node label like `A["<img src=x onerror=...>"]`
+ * would have produced LIVE HTML.
+ *
+ *  - `securityLevel: 'strict'` encodes HTML tags in text and disables click
+ *    handlers.
+ *  - `htmlLabels: false` renders labels as SVG `<text>` instead of a
+ *    foreignObject HTML subtree, so there is no HTML surface at all. Verified:
+ *    no authored diagram in this repo or in the consuming hub's markdown uses
+ *    HTML labels (not even `<br/>`), so 'antiscript' (which still allows tags)
+ *    is not needed. (`htmlLabels` is set at the ROOT — `flowchart.htmlLabels`
+ *    is deprecated in mermaid 11 and the root value takes precedence.)
+ *  - `secure` is the allowlist of config keys a `%%{init}%%` directive in the
+ *    diagram SOURCE may NOT override. mermaid's default list covers
+ *    `securityLevel` but NOT `htmlLabels`, so model-authored source could
+ *    otherwise re-enable HTML labels while `securityLevel` stayed locked.
+ *    Adding `htmlLabels` (plus `secure` itself and the resource limits) closes
+ *    that hole.
+ *
+ * jsdom NOTE: with `htmlLabels` unlocked, a `%%{init: {"htmlLabels": true}}%%`
+ * directive was observed to make `mermaid.render` never settle under jsdom
+ * (>60s, against a passing two-render control). This was NOT reproduced in a
+ * real browser and may well be an artifact of jsdom having no layout — do not
+ * read it as a confirmed browser DoS. Either way the render below is wrapped
+ * in a timeout so a non-settling render surfaces the error state instead of
+ * sitting on "Rendering diagram…" forever.
+ */
+export declare const MERMAID_SECURITY_OPTIONS: {
+    htmlLabels: false;
+    securityLevel: "strict";
+    secure: string[];
+};
+/** Upper bound on a single `mermaid.render`. Generous enough that no honest
+ *  diagram hits it; short enough that a wedged render becomes a visible error
+ *  instead of a permanent skeleton. */
+export declare const MERMAID_RENDER_TIMEOUT_MS = 15000;
+/**
+ * ODS-TOKENS FLAG (ODS_TOKEN_RULES §Colors / §Typography / §General):
+ * `mermaidStyles` below and the `themeVariables` / `fontFamily` / `fontSize`
+ * block in `MermaidDiagram` carry RAW hex colors, a literal font-family and
+ * literal px font sizes.
+ *
+ * Reason: mermaid's configuration is not CSS — `themeVariables` is a
+ * JavaScript API whose values are baked into the generated SVG as literal
+ * attribute strings, so a `var(--color-…)` reference resolves to nothing
+ * there. On top of that, ODS has NO 10-step categorical color ramp, and
+ * mermaid's `cScale0…cScale9` requires exactly one. The palette is carried
+ * over VERBATIM from the pre-unification RichMarkdownRenderer, so this is
+ * parity, not new divergence; the missing categorical-ramp tokens are
+ * flagged here for addition to ODS.
+ *
+ * Scope: this exemption covers THIS file only, and only the mermaid config
+ * surface. Do NOT copy this pattern — every other style in the markdown
+ * module uses ODS semantic classes.
+ */
+export declare const mermaidStyles = "\n  .mermaid-svg-container svg {\n    max-width: 100% !important;\n    height: auto !important;\n    min-height: 200px;\n    font-family: 'DM Sans', sans-serif !important;\n    font-size: 14px !important;\n  }\n  @media (min-width: 1520px) {\n    .mermaid-svg-container svg {\n      max-width: 900px !important;\n      max-height: 700px !important;\n      min-height: 300px;\n      font-size: 16px !important;\n    }\n  }\n  @media (min-width: 768px) and (max-width: 1519px) {\n    .mermaid-svg-container svg {\n      max-width: 700px !important;\n      max-height: 600px !important;\n      min-height: 250px;\n      font-size: 15px !important;\n    }\n  }\n  @media (max-width: 767px) {\n    .mermaid-svg-container svg {\n      max-width: 90vw !important;\n      max-height: 400px !important;\n      min-height: 200px;\n      font-size: 13px !important;\n    }\n  }\n  .mermaid-svg-container svg[width] { width: 100% !important; }\n  .mermaid-svg-container .node rect,\n  .mermaid-svg-container .node circle,\n  .mermaid-svg-container .node ellipse,\n  .mermaid-svg-container .node polygon { stroke-width: 2px !important; }\n  .mermaid-svg-container .edgePath path { stroke-width: 2px !important; }\n  @media (min-width: 768px) {\n    .mermaid-svg-container .node text,\n    .mermaid-svg-container .edgeLabel text { font-size: 14px !important; }\n  }\n  @media (min-width: 1520px) {\n    .mermaid-svg-container .node text,\n    .mermaid-svg-container .edgeLabel text { font-size: 16px !important; }\n  }\n";
+export declare const MermaidDiagram: React.FC<{
+    chart: string;
+}>;
+//# sourceMappingURL=mermaid-diagram.d.ts.map

package/dist/components/ui/markdown/mermaid-diagram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mermaid-diagram.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/mermaid-diagram.tsx"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,OAAO,KAA8B,MAAM,OAAO,CAAC;AAInD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,wBAAwB;;;;CA6BqC,CAAC;AAE3E;;uCAEuC;AACvC,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAkBhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,u+CA8CzB,CAAC;AAQF,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAkJtD,CAAC"}

package/dist/components/ui/markdown/rich/embed-overrides.d.ts

@@ -0,0 +1,14 @@
+import type { Components } from 'react-markdown';
+import type { TextSizeElement } from '../text-size';
+export interface BuildRichEmbedOverridesOptions {
+    ogApiBaseUrl: string;
+    ogEndpointPath: string;
+    textSizes: Record<TextSizeElement, string>;
+}
+/**
+ * Overrides spread LAST onto the engine's base map: `code` (fence-language
+ * embeds), `div` (shortcode-expanded embeds), `img` (MarkdownImage with
+ * runtime transformImageSrc), `video` (raw tags → Video SSOT).
+ */
+export declare function buildRichEmbedOverrides({ ogApiBaseUrl, ogEndpointPath, textSizes, }: BuildRichEmbedOverridesOptions): Partial<Components>;
+//# sourceMappingURL=embed-overrides.d.ts.map

package/dist/components/ui/markdown/rich/embed-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed-overrides.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/markdown/rich/embed-overrides.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AASjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAiBpD,MAAM,WAAW,8BAA8B;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;CAC5C;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,YAAY,EACZ,cAAc,EACd,SAAS,GACV,EAAE,8BAA8B,GAAG,OAAO,CAAC,UAAU,CAAC,CAiJtD"}

package/dist/components/ui/markdown/rich/rich-markdown-renderer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * RichMarkdownRenderer — the content composition over the unified
+ * `MarkdownEngine`: RuntimeProvider + shortcodes + embed overrides +
+ * fetch-based internal-link resolver + `article` typography.
+ *
+ * This IS the real component (the old 1223-line standalone implementation
+ * was deleted in the unification). Public prop surface is unchanged, so
+ * every hub/app call site compiles untouched. Deltas vs the old
+ * implementation are the ones reviewed in the unification plan: the
+ * sanitize stack + tag-escape pre-pass now apply to content surfaces
+ * (`extraAllowedHtmlTags={['video','source']}` keeps authored video
+ * working), the engine is memoized, and the dead light-mode branches are
+ * gone.
+ */
+import React from 'react';
+import { type MarkdownEngineProps } from '../engine';
+import { type RichMarkdownRuntime } from '../../../embeds/rich-markdown-runtime';
+/**
+ * The engine props this composition OWNS and therefore does not forward:
+ * shortcode preprocessing, the embed component map, the `article` text
+ * preset, the fetch link resolver, the rich tag allowlist, and streaming
+ * (authored content is never streamed).
+ */
+type RichOwnedEngineProps = 'extraAllowedHtmlTags' | 'preprocessContent' | 'componentOverrides' | 'textSize' | 'onResolveLink' | 'additionalRemarkPlugins' | 'streaming';
+/**
+ * Derived from `MarkdownEngineProps` rather than hand-copied. The previous
+ * shape restated 7 engine props here and a THIRD time in `InnerProps`, so
+ * every engine prop doc/type change had to be mirrored in three places (and
+ * a missed mirror type-checks fine while silently dropping the prop).
+ */
+export interface RichMarkdownRendererProps extends Partial<RichMarkdownRuntime>, Omit<MarkdownEngineProps, RichOwnedEngineProps> {
+    /** Source for resolving internal links (default: 'openframe-docs'). Registry id from DOC_SOURCES. */
+    resolveSource?: string;
+    /** Path of the internal link-resolver endpoint. Default '/api/docs/resolve-link'. */
+    resolveLinkEndpointUrl?: string;
+}
+/** Memoized — see the engine's memo rationale. */
+export declare const RichMarkdownRenderer: React.NamedExoticComponent<RichMarkdownRendererProps>;
+export {};
+//# sourceMappingURL=rich-markdown-renderer.d.ts.map

package/dist/components/ui/markdown/rich/rich-markdown-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rich-markdown-renderer.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/markdown/rich/rich-markdown-renderer.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAqC,MAAM,OAAO,CAAC;AAC1D,OAAO,EAAmC,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEtF,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,uCAAuC,CAAC;AAQ/C;;;;;GAKG;AACH,KAAK,oBAAoB,GACrB,sBAAsB,GACtB,mBAAmB,GACnB,oBAAoB,GACpB,UAAU,GACV,eAAe,GACf,yBAAyB,GACzB,WAAW,CAAC;AAEhB;;;;;GAKG;AACH,MAAM,WAAW,yBACf,SAAQ,OAAO,CAAC,mBAAmB,CAAC,EAClC,IAAI,CAAC,mBAAmB,EAAE,oBAAoB,CAAC;IACjD,qGAAqG;IACrG,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qFAAqF;IACrF,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC;AA0HD,kDAAkD;AAClD,eAAO,MAAM,oBAAoB,uDAAiC,CAAC"}

package/dist/components/ui/markdown/rich/shortcodes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shortcode + auto-URL-embed preprocessing for the rich (content)
+ * composition. Moved verbatim from the old RichMarkdownRenderer — the
+ * `{{youtube:...}}` / `{% youtube %}` / thumbnail-link / auto-URL grammar
+ * is authored-content SSOT; chat surfaces never run this.
+ */
+export declare const processShortcodes: (content: string) => string;
+//# sourceMappingURL=shortcodes.d.ts.map

package/dist/components/ui/markdown/rich/shortcodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcodes.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/markdown/rich/shortcodes.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,KAAG,MAkKnD,CAAC"}

package/dist/components/ui/markdown/sanitize.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Tags the TEXT pre-pass forwards as raw HTML. Anything outside this set
+ * (plus per-composition `extraAllowedHtmlTags`) gets its angle brackets
+ * escaped and renders as plain text.
+ *
+ * `video` is deliberately NOT in the baseline: chat strips <video>
+ * server-side and playback goes through the <Video> SSOT. The rich
+ * composition opts back in via `extraAllowedHtmlTags={['video', 'source']}`
+ * so authored content (blog publisher video injection) keeps working.
+ */
+export declare const SAFE_HTML_TAGS: Set<string>;
+/**
+ * Inline SVG element set, in the CANONICAL case parse5 produces for SVG
+ * foreign content (`linearGradient`, `clipPath`, … are camelCase in the
+ * HTML parser's SVG adjustment table, so the sanitize schema must match
+ * that spelling; the text pre-pass lowercases before lookup).
+ *
+ * Inline `<svg>` renders in real published posts (hand-authored diagrams
+ * and inline icon markup — NOT `<use href>` sprite references, which are
+ * deliberately dropped; see SVG_ATTRIBUTES). The Rich renderer had NO pre-pass
+ * and NO sanitizer, so it always rendered; without this set the unified
+ * engine would escape it to visible source text.
+ *
+ * SEVERAL OF THESE NAMES ARE ALSO HTML ELEMENTS (`title`, `desc`, `text`,
+ * `g`, `line`, `use`, `symbol`, `marker`, `mask`, `pattern`) — admitting
+ * them UNCONSTRAINED let a post or a chat message emit a bare `<title>`,
+ * which React 19 hoists into `<head>` (browser-tab + SEO title hijack) and
+ * whose RAWTEXT content model swallows the rest of the document when
+ * unclosed. They are therefore pinned to an `svg` ancestor in
+ * `SVG_ONLY_ANCESTORS` below; outside `<svg>` the sanitizer drops them.
+ */
+export declare const SVG_TAGS: Set<string>;
+/** Effective pre-pass tag set for a composition (lowercased for lookup). */
+export declare function buildEffectiveTagSet(extraAllowedHtmlTags?: string[]): Set<string>;
+export interface BuildSanitizeSchemaOptions {
+    extraAllowedHtmlTags?: string[];
+}
+/**
+ * The engine's sanitize schema: defaultSchema ∪ SAFE_HTML_TAGS ∪ extras.
+ * - `extraAllowedHtmlTags` is unioned into tagNames here AND into the
+ *   pre-pass set (buildEffectiveTagSet) — the coupled-allowlist invariant.
+ * - `clobberPrefix: ''` + empty `clobber`: authored raw-HTML anchors
+ *   (`<h2 id="…">`) keep their ids so `[jump](#anchor)` deep-links work.
+ *   (The renderer's own heading ids are injected at the React layer,
+ *   post-rehype, and were never affected.)
+ * - `card`/`mention` protocols registered for href so chat markers survive
+ *   (the urlTransform below is the second gate).
+ */
+export declare function buildSanitizeSchema(options?: BuildSanitizeSchemaOptions): {
+    tagNames: string[];
+    attributes: Record<string, (string | [string, ...unknown[]])[]>;
+    ancestors: Record<string, string[]>;
+    required: Record<string, Record<string, unknown>>;
+    clobberPrefix: string;
+    clobber: never[];
+    protocols: {
+        href: string[];
+    };
+    allowComments?: boolean | null | undefined;
+    allowDoctypes?: boolean | null | undefined;
+    strip?: Array<string> | null | undefined;
+};
+export declare function rehypeStripUnsafe(): (tree: any) => void;
+/**
+ * PARAGRAPH SEGMENTS, NOT LINES (round 18 — SECURITY). A CommonMark code span
+ * CROSSES LINE BREAKS: `` `foo\n</textarea>` `` is one `inlineCode` node, so
+ * that `</textarea>` is a code sample and not a closer — yet this scan (and
+ * `PROTECTED_SPAN_RE`, whose body class is `[^\n]`) was strictly PER LINE, so
+ * the mask never saw the span, the closer stayed visible in the haystack,
+ * `hasLaterCloser` returned true, and a prose `<textarea>` above it stayed LIVE
+ * (`escapeUnknownHtmlTags` returned the input BYTE-IDENTICAL; the renderer
+ * emitted `<code>foo </textarea></code>` — proving the closer is a code sample
+ * — beside a live textarea swallowing the prose). This is the shape that is not
+ * a CONTAINER at all, so no container sweep could ever have reached it.
+ *
+ * A code span CANNOT cross a paragraph break, so the scan unit is a maximal run
+ * of non-blank lines. Blank lines still terminate a segment, which keeps the
+ * fail-CLOSED direction (an unterminated opener consumes at most its own
+ * paragraph, never the rest of the document) and keeps the bound linear — the
+ * `suffMax` / cursor structure is unchanged, `\n` is simply an ordinary
+ * character inside a segment.
+ *
+ * `PROTECTED_SPAN_RE` (the CARVE) is deliberately left per-line: it rounds the
+ * other way, so at worst a multi-line code sample renders as escaped text.
+ */
+declare function findInlineCodeRanges(source: string): Array<[number, number]>;
+/** Exported for the differential fuzz against the retired regex. */
+export declare const __findInlineCodeRangesForTest: typeof findInlineCodeRanges;
+/**
+ * Build the haystack `hasLaterCloser` searches: a LENGTH-PRESERVING lowercased
+ * copy of the document with every region that cannot contain a REAL closing
+ * tag blanked to spaces.
+ *
+ * Why this exists: the escaping pass carefully carves code out, but the
+ * closer search used to run over the RAW document. So a `</textarea>` sitting
+ * inside a code fence, an inline-code span, or another tag's attribute string
+ * satisfied "is closed later", the prose opener was left LIVE, and parse5's
+ * RAWTEXT span swallowed the rest of the message anyway — the whole fix was
+ * one code sample away from being bypassed, which is exactly what an LLM
+ * answer about HTML looks like.
+ *
+ * Masking (rather than deleting) keeps every index identical to the original
+ * string, so the caller's offset arithmetic is unchanged. THE LENGTH
+ * INVARIANT IS LOAD-BEARING — see `foldAsciiCase`.
+ *
+ * CARVE DECISION (deliberate, do not "unify"): these tracker-derived regions
+ * are NOT fed to the escaping carve, even though that would stop an authored
+ * EOF-terminated fence body from rendering as literal `&lt;their&gt;`.
+ *
+ * The genuine asymmetry is the EOF-TERMINATED fence, and only that one. The
+ * tracker protects an unclosed opener all the way to end of input, so a single
+ * stray ``` line — mid-stream, or inside an open raw-HTML block where a ```
+ * line is content rather than a fence — would carve the ENTIRE remainder of the
+ * document out of the escaping pass. `PROTECTED_SPAN_RE` protects nothing at
+ * all there (it only recognizes a fence CLOSED by a same-marker run), so its
+ * failure mode is bounded: a code sample renders as escaped text. In the carve
+ * an over-detected region is a region that is NOT escaped — a fail-OPEN, i.e.
+ * exactly the swallow this module exists to prevent — so the materially larger
+ * fail-open surface decides it.
+ *
+ * SHARED over-detection (e.g. a ``` line inside an HTML block — `<div>`,
+ * `<pre>`, `<details>` — where CommonMark says the line is HTML content, not a
+ * fence) was previously dismissed here as "not an argument either way". THAT
+ * WAS WRONG: it is precisely the residual fail-open. The intersection guard
+ * below only reconciles DISAGREEMENT, so when BOTH engines open the same bogus
+ * fence the guard is a no-op and a live `<textarea>` inside it is pushed
+ * verbatim, swallowing the rest of the message (reproduced for all three tags).
+ * What actually closes it is the CARVE BALANCE GUARD in
+ * `escapeUnknownHtmlTags`: a protected span may contain no UNBALANCED RAWTEXT
+ * opener. Neither engine needs to learn about HTML blocks for that to hold.
+ *
+ * What makes keeping two engines SAFE is therefore the pair of guards in
+ * `escapeUnknownHtmlTags`: a carve span the mask did not blank is escaped
+ * rather than pushed through verbatim, and a span carrying an unbalanced
+ * RAWTEXT opener is escaped even when both engines agree. Over-detection can
+ * then only cost cosmetics. Before the first guard the regex's info-string-tolerant
+ * closer let it desync and open a span from a line CommonMark treats as
+ * ordinary text, sheltering a live `<textarea>` from escaping entirely
+ * (`mismatched-fence-carve-does-not-shelter-opener`). The remaining tradeoff is
+ * pinned by `unclosed-fence-body-renders-escaped` rather than left as prose.
+ */
+declare function buildCloserHaystack(text: string): string;
+/** Exported for the length-preservation invariant test only. */
+export declare const __buildCloserHaystackForTest: typeof buildCloserHaystack;
+export declare function escapeUnknownHtmlTags(text: string, allowedTags?: Set<string>): string;
+/**
+ * Extends react-markdown's default safe-protocol allowlist with the two
+ * internal schemes the chat remark plugins emit (`card://`, `mention://`),
+ * for `href` ONLY. All other URLs go through `defaultUrlTransform`.
+ */
+export declare function cardAwareUrlTransform(url: string, key: string): string;
+export {};
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/components/ui/markdown/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/sanitize.ts"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,aAqBzB,CAAA;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,QAAQ,aAKnB,CAAA;AAqDF,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAAC,oBAAoB,CAAC,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAEjF;AAkGD,MAAM,WAAW,0BAA0B;IACzC,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAA;CAChC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,0BAA+B;;;;;;;;;;;;;EAgG3E;AA2DD,wBAAgB,iBAAiB,KAEvB,MAAM,GAAG,UA6ElB;AA+HD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,iBAAS,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CA6ErE;AAED,oEAAoE;AACpE,eAAO,MAAM,6BAA6B,6BAAuB,CAAA;AA6/DjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,iBAAS,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA0DjD;AAED,gEAAgE;AAChE,eAAO,MAAM,4BAA4B,4BAAsB,CAAA;AAkgB/D,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,WAAW,GAAE,GAAG,CAAC,MAAM,CAAkB,GACxC,MAAM,CAgGR;AAoED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAItE"}

package/dist/components/ui/markdown/simple-markdown-renderer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * SimpleMarkdownRenderer — the chat/doc composition over the unified
+ * `MarkdownEngine`. This IS the real component (not a compat alias): the
+ * old 966-line standalone implementation was deleted in the unification;
+ * its entire prop surface maps 1:1 onto the engine. Chat consumers keep
+ * layering `additionalRemarkPlugins` (card/mention links) and
+ * `componentOverrides` exactly as before.
+ */
+import React from 'react';
+import { type MarkdownEngineProps } from './engine';
+import type { ResolveLinkResult } from '../../../types/doc-source';
+export type { ResolveLinkResult };
+export interface SimpleMarkdownRendererProps extends Omit<MarkdownEngineProps, 'extraAllowedHtmlTags'> {
+}
+/**
+ * A type-narrowed ALIAS of the engine, not a wrapper: the composition adds
+ * no behavior (it only hides `extraAllowedHtmlTags` from the prop surface),
+ * and `MarkdownEngine` is already `memo`'d. Wrapping it in a second `memo`
+ * bought nothing and cost an extra shallow-compare pass plus a fiber per
+ * chat segment.
+ */
+export declare const SimpleMarkdownRenderer: React.NamedExoticComponent<SimpleMarkdownRendererProps>;
+//# sourceMappingURL=simple-markdown-renderer.d.ts.map

package/dist/components/ui/markdown/simple-markdown-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-markdown-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/simple-markdown-renderer.tsx"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAkB,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,YAAY,EAAE,iBAAiB,EAAE,CAAC;AAElC,MAAM,WAAW,2BACf,SAAQ,IAAI,CAAC,mBAAmB,EAAE,sBAAsB,CAAC;CAAG;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EACf,KAAK,CAAC,oBAAoB,CAAC,2BAA2B,CAAC,CAAC"}