@flamingo-stack/openframe-frontend-core 0.0.488 → 0.0.490-1506.3944.1

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;;;;;;;;;;;;;EAyD3E;AAgDD,wBAAgB,iBAAiB,KAEvB,MAAM,GAAG,UA0ClB;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"}

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

@@ -0,0 +1,78 @@
+/**
+ * Streaming helpers for the unified markdown engine (pure, no React).
+ *
+ * Design contract (unification plan §D1 "Streaming rendering performance"):
+ * - Markdown is NOT context-free across blocks. The splitter only cuts at
+ *   boundaries it can PROVE are atomic; when atomicity is unprovable the
+ *   content is left in one unit (unmemoized) — correctness beats cache hits.
+ * - Blocks containing `card://` / `mention://` markers are never memoized:
+ *   their text is identical before/after the entity ref resolves, so a
+ *   text-keyed cache would serve the stale unresolved card mid-stream.
+ * - On stream completion the engine discards all of this and does ONE
+ *   authoritative whole-document parse — streaming can never permanently
+ *   diverge (late reference defs, footnotes, list renumbering self-heal).
+ * - Tail completion auto-closes ONLY unterminated fenced code blocks
+ *   (fence-count based — unambiguous). Inline emphasis/links are NOT
+ *   auto-closed: a stray `*` in "2 * 3" or a non-link `[` would be
+ *   mis-wrapped, which is worse than the brief flicker it prevents.
+ */
+export interface StreamingBlock {
+    /** Raw markdown source of this unit (including trailing blank lines). */
+    text: string;
+    /** Position index — cache key component so identical blocks never alias. */
+    index: number;
+    /**
+     * 1-based line of this unit's first line WITHIN the whole document.
+     * Each unit is parsed by its own `ReactMarkdown`, so hast positions are
+     * unit-relative; the engine adds `startLine - 1` back to look ids up in
+     * the document-wide heading-id map (see ./heading-ids.ts).
+     */
+    startLine: number;
+    /**
+     * True when this unit may be render-cached: it is complete (not the
+     * trailing unit), atomic, and free of cross-block / late-resolving
+     * constructs (card/mention markers, reference definitions/uses,
+     * footnotes).
+     */
+    memoizable: boolean;
+}
+/**
+ * Split streaming markdown into atomic units at blank lines that are
+ * provably block boundaries. A blank line does NOT split when:
+ *  - inside a fenced code block,
+ *  - the next non-blank line is indented (loose-list / blockquote
+ *    continuation cannot be ruled out),
+ *  - the next non-blank line starts a list item or blockquote AND the
+ *    previous unit ended in a list item or blockquote (loose list /
+ *    multi-paragraph quote continuation).
+ * The FINAL unit is always the live tail (never memoizable).
+ *
+ * BLANK LINES COME FROM `isBlankLine` (utils/markdown-fences), never from
+ * `String.prototype.trim()`. This file is the THIRD consumer of that module
+ * (it already instantiates `createFenceTracker`) and makes exactly the
+ * CommonMark blank-line decision the helper was minted for, yet it kept four
+ * hand-rolled `trim() === ''` tests — so the module's "every blank-line test"
+ * SSOT claim was false here. `trim()` strips the full Unicode White_Space set
+ * (U+00A0 NBSP, U+000B VT, U+000C FF, U+FEFF BOM), none of which CommonMark
+ * treats as blank: `splitStreamingBlocks('foo\n<NBSP>\nbar\n\ntail')` returned
+ * THREE units where the non-blank filler control (`foo\nx\nbar\n\ntail`)
+ * returns TWO — one NBSP line cut a paragraph into two `ReactMarkdown` units on
+ * the STREAMING path, rendering two `<p>` where the non-streaming and SEO twins
+ * render one. Not a security hole (the fence tracker and `htmlBlocksCut` still
+ * gate the cut), but a live divergence. It survived because the swallow sweep
+ * drove only `SimpleMarkdownRenderer`; the sweep now drives this splitter too,
+ * in both the exotic-blank and CRLF spellings.
+ */
+export declare function splitStreamingBlocks(content: string): StreamingBlock[];
+/**
+ * Auto-close an unterminated fenced code block at the streaming tail so the
+ * half-open fence doesn't flip the rest of the message into code while
+ * tokens arrive.
+ *
+ * Uses the SAME scanner as `splitStreamingBlocks` (never a parallel
+ * fence-count heuristic — a naive count treats ``` and ~~~ as
+ * interchangeable and appends a spurious closer to `` ```\n~~~\n``` ``),
+ * and appends the RECORDED opener so a `~~~` block is closed with `~~~`.
+ */
+export declare function completeStreamingTail(content: string): string;
+//# sourceMappingURL=streaming.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/streaming.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAA;IACZ,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAA;IACb;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB;;;;;OAKG;IACH,UAAU,EAAE,OAAO,CAAA;CACpB;AA2LD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE,CAwFtE;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAO7D"}

package/dist/components/ui/markdown/text-size.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Text-size presets for the unified markdown engine.
+ *
+ * `default` / `compact` / `large` are carried over verbatim from the old
+ * `SimpleMarkdownRenderer`. `article` is NEW — it reproduces the exact
+ * typography the old `RichMarkdownRenderer` hardcoded per element, so
+ * content surfaces (blog, case studies, releases, legal, docs) keep
+ * byte-identical classes through the unification.
+ *
+ * ODS-TOKENS FLAG (ODS_TOKEN_RULES §Typography / §General): the `article`
+ * preset carries raw px classes (`text-[32px] md:text-[40px] …`) because
+ * ODS currently has NO composite tokens for long-form prose — `text-h1`/
+ * `text-h2` are Azeret Mono UI-label scale and `text-h5` is uppercase,
+ * so mapping prose headings onto them would visibly regress articles.
+ * The `code` entry of EVERY preset (`text-[13px]` / `text-[14px]` /
+ * `text-[16px]`), not just `article`'s, is raw px for the same reason: ODS
+ * has no code/mono type scale. `base-components.tsx` carries the matching
+ * flag for inline code's `text-[0.9em]` (the mono FAMILY is no longer an
+ * exemption — both code surfaces now use `font-mono`).
+ * Per the unification plan, the missing prose- and code-typography tokens
+ * are FLAGGED here for addition to ODS; the raw-px carry-over is the
+ * documented, review-gated exemption recorded in the unification PR.
+ * Do NOT copy these px classes anywhere else.
+ */
+export type TextSizeElement = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'li' | 'blockquote' | 'code' | 'th' | 'td';
+export type TextSizeClassMap = Partial<Record<TextSizeElement, string>>;
+export type TextSizePreset = 'default' | 'compact' | 'large' | 'article';
+export type TextSizeConfig = TextSizePreset | TextSizeClassMap | {
+    preset: TextSizePreset;
+    overrides: TextSizeClassMap;
+};
+export declare const TEXT_SIZE_PRESETS: Record<TextSizePreset, Record<TextSizeElement, string>>;
+export declare function resolveTextSizeConfig(config?: TextSizeConfig): Record<TextSizeElement, string>;
+//# sourceMappingURL=text-size.d.ts.map

package/dist/components/ui/markdown/text-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-size.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/text-size.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,MAAM,eAAe,GACvB,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GACvC,GAAG,GAAG,IAAI,GAAG,YAAY,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;AAErD,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC;AACxE,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AACzE,MAAM,MAAM,cAAc,GACtB,cAAc,GACd,gBAAgB,GAChB;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,SAAS,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE5D,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CA6DrF,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAM9F"}

package/dist/contexts/chat-runtime-context.d.ts

@@ -19,6 +19,14 @@ export interface ChatRuntime {
         listEngagementsUrl?: string;
         /** GET slash-command catalog. Hub: '/api/docs/commands'. */
         commandsUrl: string;
+        /** GET server-side conversation history (`?conversationId=<id>`) — the
+         *  chat panel's mount-time hydration read against the server transcript
+         *  store (localStorage keeps only the server-issued conversation id).
+         *  OPTIONAL — defaults to `<chatStreamUrl>/history`, which is correct for
+         *  same-origin hosts AND for reverse-proxy embedders (the proxied chat
+         *  prefix covers it). Set explicitly only when the history route lives
+         *  elsewhere. */
+        chatHistoryUrl?: string;
         /** GET RAG-search endpoint behind `<DocSearchBar>` (the in-source search
          *  bar mounted by `<DocViewer>` / `<DocsHubPage>` when `showAIChat` is on).
          *  Hub: '/api/docs/search'. OPTIONAL — falls back to the hub path so

package/dist/contexts/chat-runtime-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat-runtime-context.d.ts","sourceRoot":"","sources":["../../src/contexts/chat-runtime-context.tsx"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE9D;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE;QACT,kDAAkD;QAClD,aAAa,EAAE,MAAM,CAAA;QACrB,sEAAsE;QACtE,eAAe,EAAE,MAAM,CAAA;QACvB;;;;;+DAKuD;QACvD,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB,eAAe,CAAC,EAAE,MAAM,CAAA;QACxB,kBAAkB,CAAC,EAAE,MAAM,CAAA;QAC3B,4DAA4D;QAC5D,WAAW,EAAE,MAAM,CAAA;QACnB;;;;;iFAKyE;QACzE,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB;;;;;qFAK6E;QAC7E,kBAAkB,CAAC,EAAE,MAAM,CAAA;QAC3B;;;;;;;;qFAQ6E;QAC7E,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB;;;;;;;6DAOqD;QACrD,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;QAC3C;;;sEAG8D;QAC9D,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,MAAM,GAAG,IAAI,CAAA;QAC5D;;;;;;;;;;;;;;;;2EAgBmE;QACnE,mBAAmB,EAAE,MAAM,CAAA;QAC3B,uBAAuB,EAAE,MAAM,CAAA;QAC/B,WAAW,EAAE,MAAM,CAAA;QACnB;;;;uDAI+C;QAC/C,mBAAmB,CAAC,EAAE,MAAM,CAAA;QAC5B;;;oCAG4B;QAC5B,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAA;QAChC;;;;;;;;;;;;;;;kFAe0E;QAC1E,gBAAgB,CAAC,EAAE,MAAM,CAAA;QACzB;;;;;+CAKuC;QACvC,qBAAqB,CAAC,EAAE,MAAM,CAAA;KAC/B,CAAA;IACD,UAAU,EAAE;QACV;;;;;2CAKmC;QACnC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;QACtB;;;;;kEAK0D;QAC1D,oBAAoB,CAAC,EAAE,MAAM,CAAA;QAC7B;;2EAEmE;QACnE,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;QACrC;;;;;2DAKmD;QACnD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;YAAC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,KAAK,OAAO,GAAG,IAAI,CAAA;QAC5G;;;;kEAI0D;QAC1D,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,KAAK,OAAO,CAAA;KACnF,CAAA;IACD;;;;;;;;;;;;;;;;;;4CAkBwC;IACxC,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;IACrC;;;;;;;;uFAQmF;IACnF,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC3E;;;;;;;;;;qCAUiC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAA;CAQhB;AAED,eAAO,MAAM,kBAAkB,6CAA0C,CAAA;AAEzE;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,WAAW,GAAG,IAAI,CAEnD;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,IAAI,WAAW,CAapD"}
+{"version":3,"file":"chat-runtime-context.d.ts","sourceRoot":"","sources":["../../src/contexts/chat-runtime-context.tsx"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE9D;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE;QACT,kDAAkD;QAClD,aAAa,EAAE,MAAM,CAAA;QACrB,sEAAsE;QACtE,eAAe,EAAE,MAAM,CAAA;QACvB;;;;;+DAKuD;QACvD,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB,eAAe,CAAC,EAAE,MAAM,CAAA;QACxB,kBAAkB,CAAC,EAAE,MAAM,CAAA;QAC3B,4DAA4D;QAC5D,WAAW,EAAE,MAAM,CAAA;QACnB;;;;;;yBAMiB;QACjB,cAAc,CAAC,EAAE,MAAM,CAAA;QACvB;;;;;iFAKyE;QACzE,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB;;;;;qFAK6E;QAC7E,kBAAkB,CAAC,EAAE,MAAM,CAAA;QAC3B;;;;;;;;qFAQ6E;QAC7E,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB;;;;;;;6DAOqD;QACrD,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;QAC3C;;;sEAG8D;QAC9D,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,MAAM,GAAG,IAAI,CAAA;QAC5D;;;;;;;;;;;;;;;;2EAgBmE;QACnE,mBAAmB,EAAE,MAAM,CAAA;QAC3B,uBAAuB,EAAE,MAAM,CAAA;QAC/B,WAAW,EAAE,MAAM,CAAA;QACnB;;;;uDAI+C;QAC/C,mBAAmB,CAAC,EAAE,MAAM,CAAA;QAC5B;;;oCAG4B;QAC5B,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAA;QAChC;;;;;;;;;;;;;;;kFAe0E;QAC1E,gBAAgB,CAAC,EAAE,MAAM,CAAA;QACzB;;;;;+CAKuC;QACvC,qBAAqB,CAAC,EAAE,MAAM,CAAA;KAC/B,CAAA;IACD,UAAU,EAAE;QACV;;;;;2CAKmC;QACnC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;QACtB;;;;;kEAK0D;QAC1D,oBAAoB,CAAC,EAAE,MAAM,CAAA;QAC7B;;2EAEmE;QACnE,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;QACrC;;;;;2DAKmD;QACnD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;YAAC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,KAAK,OAAO,GAAG,IAAI,CAAA;QAC5G;;;;kEAI0D;QAC1D,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,KAAK,OAAO,CAAA;KACnF,CAAA;IACD;;;;;;;;;;;;;;;;;;4CAkBwC;IACxC,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;IACrC;;;;;;;;uFAQmF;IACnF,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC3E;;;;;;;;;;qCAUiC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAA;CAQhB;AAED,eAAO,MAAM,kBAAkB,6CAA0C,CAAA;AAEzE;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,WAAW,GAAG,IAAI,CAEnD;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,IAAI,WAAW,CAapD"}

package/dist/contexts/index.cjs

@@ -6,7 +6,7 @@
 
 
 
-var _chunk2B6773QMcjs = require('../chunk-2B6773QM.cjs');
+var _chunkLILQJ3UZcjs = require('../chunk-LILQJ3UZ.cjs');
 require('../chunk-VRHGVLSL.cjs');
 
 // src/contexts/use-outer-or-default.ts
@@ -24,5 +24,5 @@ function useOuterOrDefault(context, factory, deps = []) {
 
 
 
-exports.ChatRuntimeContext = _chunk2B6773QMcjs.ChatRuntimeContext; exports.EndpointsRuntimeContext = _chunk2B6773QMcjs.EndpointsRuntimeContext; exports.useChatRuntime = _chunk2B6773QMcjs.useChatRuntime; exports.useEndpointsRuntime = _chunk2B6773QMcjs.useEndpointsRuntime; exports.useOuterOrDefault = useOuterOrDefault; exports.useRequiredChatRuntime = _chunk2B6773QMcjs.useRequiredChatRuntime; exports.useRequiredEndpointsRuntime = _chunk2B6773QMcjs.useRequiredEndpointsRuntime;
+exports.ChatRuntimeContext = _chunkLILQJ3UZcjs.ChatRuntimeContext; exports.EndpointsRuntimeContext = _chunkLILQJ3UZcjs.EndpointsRuntimeContext; exports.useChatRuntime = _chunkLILQJ3UZcjs.useChatRuntime; exports.useEndpointsRuntime = _chunkLILQJ3UZcjs.useEndpointsRuntime; exports.useOuterOrDefault = useOuterOrDefault; exports.useRequiredChatRuntime = _chunkLILQJ3UZcjs.useRequiredChatRuntime; exports.useRequiredEndpointsRuntime = _chunkLILQJ3UZcjs.useRequiredEndpointsRuntime;
 //# sourceMappingURL=index.cjs.map

package/dist/contexts/index.js

@@ -6,7 +6,7 @@ import {
   useEndpointsRuntime,
   useRequiredChatRuntime,
   useRequiredEndpointsRuntime
-} from "../chunk-KFQXO7QB.js";
+} from "../chunk-6GT557KN.js";
 import "../chunk-GGWZFCYS.js";
 
 // src/contexts/use-outer-or-default.ts

package/dist/hooks/index.cjs

@@ -68,9 +68,9 @@
 
 
 
-var _chunkA7IPON2Vcjs = require('../chunk-A7IPON2V.cjs');
+var _chunkBIKOJ4FHcjs = require('../chunk-BIKOJ4FH.cjs');
 require('../chunk-BGD345ZV.cjs');
-require('../chunk-2B6773QM.cjs');
+require('../chunk-LILQJ3UZ.cjs');
 require('../chunk-SSJNN5BS.cjs');
 require('../chunk-WZW7C7TF.cjs');
 require('../chunk-OB7YDOTK.cjs');
@@ -147,5 +147,5 @@ require('../chunk-VRHGVLSL.cjs');
 
 
 
-exports.GraphQLIntrospector = _chunkA7IPON2Vcjs.GraphQLIntrospector; exports.NEAR_VIEWPORT_ROOT_MARGIN = _chunkA7IPON2Vcjs.NEAR_VIEWPORT_ROOT_MARGIN; exports.batchFetchAuthenticatedImages = _chunkA7IPON2Vcjs.batchFetchAuthenticatedImages; exports.breakpoints = _chunkA7IPON2Vcjs.breakpoints; exports.clearAuthedImageCache = _chunkA7IPON2Vcjs.clearAuthedImageCache; exports.clearVariablesParams = _chunkA7IPON2Vcjs.clearParams; exports.coerceValue = _chunkA7IPON2Vcjs.coerceValue; exports.configureAuthenticatedImage = _chunkA7IPON2Vcjs.configureAuthenticatedImage; exports.configureBatchImageFetch = _chunkA7IPON2Vcjs.configureBatchImageFetch; exports.createSearchParams = _chunkA7IPON2Vcjs.createSearchParams; exports.extractVariablesFromQuery = _chunkA7IPON2Vcjs.extractVariablesFromQuery; exports.flattenQueryVariables = _chunkA7IPON2Vcjs.flattenQueryVariables; exports.getArrayParams = _chunkA7IPON2Vcjs.getArrayParams; exports.getNestedValue = _chunkA7IPON2Vcjs.getNestedValue; exports.getRequiredParams = _chunkA7IPON2Vcjs.getRequiredParams; exports.introspector = _chunkA7IPON2Vcjs.introspector; exports.isInputObjectType = _chunkA7IPON2Vcjs.isInputObjectType; exports.isScalarType = _chunkA7IPON2Vcjs.isScalarType; exports.mergeDefaults = _chunkA7IPON2Vcjs.mergeDefaults; exports.mergeVariables = _chunkA7IPON2Vcjs.mergeVariables; exports.setNestedValue = _chunkA7IPON2Vcjs.setNestedValue; exports.shouldIncludeInUrl = _chunkA7IPON2Vcjs.shouldIncludeInUrl; exports.toast = _chunkA7IPON2Vcjs.toast; exports.urlParamsToVariables = _chunkA7IPON2Vcjs.urlParamsToVariables; exports.useAccessCodeIntegration = _chunkA7IPON2Vcjs.useAccessCodeIntegration; exports.useApiParams = _chunkA7IPON2Vcjs.useApiParams; exports.useAuthedImageSrc = _chunkA7IPON2Vcjs.useAuthedImageSrc; exports.useAuthenticatedImage = _chunkA7IPON2Vcjs.useAuthenticatedImage; exports.useAutoLimitTags = _chunkA7IPON2Vcjs.useAutoLimitTags; exports.useBatchImages = _chunkA7IPON2Vcjs.useBatchImages; exports.useContactSubmission = _chunkA7IPON2Vcjs.useContactSubmission; exports.useCopyToClipboard = _chunkA7IPON2Vcjs.useCopyToClipboard; exports.useCursorPaginationState = _chunkA7IPON2Vcjs.useCursorPaginationState; exports.useDebounce = _chunkA7IPON2Vcjs.useDebounce; exports.useDeferredError = _chunkA7IPON2Vcjs.useDeferredError; exports.useFocusTrap = _chunkA7IPON2Vcjs.useFocusTrap; exports.useHeaderHeight = _chunkA7IPON2Vcjs.useHeaderHeight; exports.useHorizontalScrollbar = _chunkA7IPON2Vcjs.useHorizontalScrollbar; exports.useHumanitySignals = _chunkA7IPON2Vcjs.useHumanitySignals; exports.useImageEdgeColor = _chunkA7IPON2Vcjs.useImageEdgeColor; exports.useLgUp = _chunkA7IPON2Vcjs.useLgUp; exports.useLocalStorage = _chunkA7IPON2Vcjs.useLocalStorage; exports.useMarqueeEngine = _chunkA7IPON2Vcjs.useMarqueeEngine; exports.useMdUp = _chunkA7IPON2Vcjs.useMdUp; exports.useMediaQuery = _chunkA7IPON2Vcjs.useMediaQuery; exports.useMemoizedCallback = _chunkA7IPON2Vcjs.useMemoizedCallback; exports.useNatsClient = _chunkA7IPON2Vcjs.useNatsClient; exports.useNearViewport = _chunkA7IPON2Vcjs.useNearViewport; exports.useNotificationPermission = _chunkA7IPON2Vcjs.useNotificationPermission; exports.useOgPlaceholderUrl = _chunkA7IPON2Vcjs.useOgPlaceholderUrl; exports.useOnboardingState = _chunkA7IPON2Vcjs.useOnboardingState; exports.usePlatformByValue = _chunkA7IPON2Vcjs.usePlatformByValue; exports.usePlatformConfig = _chunkA7IPON2Vcjs.usePlatformConfig; exports.usePreventScroll = _chunkA7IPON2Vcjs.usePreventScroll; exports.useQueryParams = _chunkA7IPON2Vcjs.useQueryParams; exports.useResetOnPageHidden = _chunkA7IPON2Vcjs.useResetOnPageHidden; exports.useScrollToHash = _chunkA7IPON2Vcjs.useScrollToHash; exports.useSearch = _chunkA7IPON2Vcjs.useSearch; exports.useSmUp = _chunkA7IPON2Vcjs.useSmUp; exports.useSuppressCloneFocus = _chunkA7IPON2Vcjs.useSuppressCloneFocus; exports.useTablePagination = _chunkA7IPON2Vcjs.useTablePagination; exports.useThrottle = _chunkA7IPON2Vcjs.useThrottle; exports.useToast = _chunkA7IPON2Vcjs.useToast; exports.useValidatePlatform = _chunkA7IPON2Vcjs.useValidatePlatform; exports.useWindowSize = _chunkA7IPON2Vcjs.useWindowSize; exports.validateSchema = _chunkA7IPON2Vcjs.validateSchema; exports.validateVariables = _chunkA7IPON2Vcjs.validateVariables; exports.variablesToUrlParams = _chunkA7IPON2Vcjs.variablesToUrlParams;
+exports.GraphQLIntrospector = _chunkBIKOJ4FHcjs.GraphQLIntrospector; exports.NEAR_VIEWPORT_ROOT_MARGIN = _chunkBIKOJ4FHcjs.NEAR_VIEWPORT_ROOT_MARGIN; exports.batchFetchAuthenticatedImages = _chunkBIKOJ4FHcjs.batchFetchAuthenticatedImages; exports.breakpoints = _chunkBIKOJ4FHcjs.breakpoints; exports.clearAuthedImageCache = _chunkBIKOJ4FHcjs.clearAuthedImageCache; exports.clearVariablesParams = _chunkBIKOJ4FHcjs.clearParams; exports.coerceValue = _chunkBIKOJ4FHcjs.coerceValue; exports.configureAuthenticatedImage = _chunkBIKOJ4FHcjs.configureAuthenticatedImage; exports.configureBatchImageFetch = _chunkBIKOJ4FHcjs.configureBatchImageFetch; exports.createSearchParams = _chunkBIKOJ4FHcjs.createSearchParams; exports.extractVariablesFromQuery = _chunkBIKOJ4FHcjs.extractVariablesFromQuery; exports.flattenQueryVariables = _chunkBIKOJ4FHcjs.flattenQueryVariables; exports.getArrayParams = _chunkBIKOJ4FHcjs.getArrayParams; exports.getNestedValue = _chunkBIKOJ4FHcjs.getNestedValue; exports.getRequiredParams = _chunkBIKOJ4FHcjs.getRequiredParams; exports.introspector = _chunkBIKOJ4FHcjs.introspector; exports.isInputObjectType = _chunkBIKOJ4FHcjs.isInputObjectType; exports.isScalarType = _chunkBIKOJ4FHcjs.isScalarType; exports.mergeDefaults = _chunkBIKOJ4FHcjs.mergeDefaults; exports.mergeVariables = _chunkBIKOJ4FHcjs.mergeVariables; exports.setNestedValue = _chunkBIKOJ4FHcjs.setNestedValue; exports.shouldIncludeInUrl = _chunkBIKOJ4FHcjs.shouldIncludeInUrl; exports.toast = _chunkBIKOJ4FHcjs.toast; exports.urlParamsToVariables = _chunkBIKOJ4FHcjs.urlParamsToVariables; exports.useAccessCodeIntegration = _chunkBIKOJ4FHcjs.useAccessCodeIntegration; exports.useApiParams = _chunkBIKOJ4FHcjs.useApiParams; exports.useAuthedImageSrc = _chunkBIKOJ4FHcjs.useAuthedImageSrc; exports.useAuthenticatedImage = _chunkBIKOJ4FHcjs.useAuthenticatedImage; exports.useAutoLimitTags = _chunkBIKOJ4FHcjs.useAutoLimitTags; exports.useBatchImages = _chunkBIKOJ4FHcjs.useBatchImages; exports.useContactSubmission = _chunkBIKOJ4FHcjs.useContactSubmission; exports.useCopyToClipboard = _chunkBIKOJ4FHcjs.useCopyToClipboard; exports.useCursorPaginationState = _chunkBIKOJ4FHcjs.useCursorPaginationState; exports.useDebounce = _chunkBIKOJ4FHcjs.useDebounce; exports.useDeferredError = _chunkBIKOJ4FHcjs.useDeferredError; exports.useFocusTrap = _chunkBIKOJ4FHcjs.useFocusTrap; exports.useHeaderHeight = _chunkBIKOJ4FHcjs.useHeaderHeight; exports.useHorizontalScrollbar = _chunkBIKOJ4FHcjs.useHorizontalScrollbar; exports.useHumanitySignals = _chunkBIKOJ4FHcjs.useHumanitySignals; exports.useImageEdgeColor = _chunkBIKOJ4FHcjs.useImageEdgeColor; exports.useLgUp = _chunkBIKOJ4FHcjs.useLgUp; exports.useLocalStorage = _chunkBIKOJ4FHcjs.useLocalStorage; exports.useMarqueeEngine = _chunkBIKOJ4FHcjs.useMarqueeEngine; exports.useMdUp = _chunkBIKOJ4FHcjs.useMdUp; exports.useMediaQuery = _chunkBIKOJ4FHcjs.useMediaQuery; exports.useMemoizedCallback = _chunkBIKOJ4FHcjs.useMemoizedCallback; exports.useNatsClient = _chunkBIKOJ4FHcjs.useNatsClient; exports.useNearViewport = _chunkBIKOJ4FHcjs.useNearViewport; exports.useNotificationPermission = _chunkBIKOJ4FHcjs.useNotificationPermission; exports.useOgPlaceholderUrl = _chunkBIKOJ4FHcjs.useOgPlaceholderUrl; exports.useOnboardingState = _chunkBIKOJ4FHcjs.useOnboardingState; exports.usePlatformByValue = _chunkBIKOJ4FHcjs.usePlatformByValue; exports.usePlatformConfig = _chunkBIKOJ4FHcjs.usePlatformConfig; exports.usePreventScroll = _chunkBIKOJ4FHcjs.usePreventScroll; exports.useQueryParams = _chunkBIKOJ4FHcjs.useQueryParams; exports.useResetOnPageHidden = _chunkBIKOJ4FHcjs.useResetOnPageHidden; exports.useScrollToHash = _chunkBIKOJ4FHcjs.useScrollToHash; exports.useSearch = _chunkBIKOJ4FHcjs.useSearch; exports.useSmUp = _chunkBIKOJ4FHcjs.useSmUp; exports.useSuppressCloneFocus = _chunkBIKOJ4FHcjs.useSuppressCloneFocus; exports.useTablePagination = _chunkBIKOJ4FHcjs.useTablePagination; exports.useThrottle = _chunkBIKOJ4FHcjs.useThrottle; exports.useToast = _chunkBIKOJ4FHcjs.useToast; exports.useValidatePlatform = _chunkBIKOJ4FHcjs.useValidatePlatform; exports.useWindowSize = _chunkBIKOJ4FHcjs.useWindowSize; exports.validateSchema = _chunkBIKOJ4FHcjs.validateSchema; exports.validateVariables = _chunkBIKOJ4FHcjs.validateVariables; exports.variablesToUrlParams = _chunkBIKOJ4FHcjs.variablesToUrlParams;
 //# sourceMappingURL=index.cjs.map

package/dist/hooks/index.js

@@ -68,9 +68,9 @@ import {
   validateSchema,
   validateVariables,
   variablesToUrlParams
-} from "../chunk-KLYHZRAD.js";
+} from "../chunk-PB3BTZDU.js";
 import "../chunk-OYGFWWLQ.js";
-import "../chunk-KFQXO7QB.js";
+import "../chunk-6GT557KN.js";
 import "../chunk-ZJJERZUA.js";
 import "../chunk-6U3IUD57.js";
 import "../chunk-SZMA65OW.js";