@ai-gui/core 0.21.1 → 0.22.1

package/README.md

@@ -110,12 +110,16 @@ const runtime = createActionRuntime({ registry: actions, cardStore })
 
 ## Exports
 
-- `Renderer` — `push(chunk)`, `feed(AsyncIterable | ReadableStream)`, `reset()`; constructor `{ registry?, plugins?, sanitize?, onPatch?(patches, nodes) }`.
+- `Renderer` — `push(chunk)`, `feed(AsyncIterable | ReadableStream)`, `reset()`, `setPlugins(plugins)`; constructor `{ registry?, plugins?, sanitize?, rawHtml?, onPatch?(patches, nodes) }`.
+  - `setPlugins` swaps the grammar and reparses the buffered source, so plugins deferred behind a dynamic import can arrive mid-answer without the host replaying what it pushed.
+  - `rawHtml: false` escapes raw HTML the model wrote instead of interpreting it — a stray `<code>` in prose otherwise swallows the rest of the line.
+  - Emphasis is parsed CJK-friendly, one deliberate deviation from CommonMark. CommonMark will not let `**` close when it follows punctuation and precedes a character that is neither whitespace nor punctuation, so `**严格单调（单射）**的函数` renders its asterisks literally. ASCII is unaffected: `a * b * c` and `snake_case_word` parse exactly as before.
 - `StreamRouter` — demultiplex one stream into named channels: `.channel(name, sink)`, `.on(name, cb)`, `.feed(source)`.
 - `CardRegistry` — `register(def)`, `parse(type, rawJson)`, `getRender(type)`, `toPromptSpec()`, `toJSONSchema()`.
 - `CardStore` — `register`, `get`, `list`, `subscribe`, `apply`, `applyAll`, `delete`, `clear`, `snapshot`, and `restore` for Cards with stable IDs.
 - `ActionRegistry`, `ActionRuntime`, `createActionRuntime`, `getActionKey`, `getIdleActionState` — validated application-owned action execution and observable lifecycle state.
-- `buildSystemPrompt({ base?, registry?, plugins? })`.
+- `buildSystemPrompt({ base?, registry?, plugins?, locale? })` — collects the card specs and every plugin's `promptSpec`. Pass `plugins`: installing a plugin teaches the renderer to draw a block, not the model to ask for one.
+- `loadPlugins(source)` / `samePlugins(a, b)` — normalize `AIGuiPlugin[] | (() => Promise<AIGuiPlugin[]>)` and compare two lists by members.
 - Utilities: `parsePartialJSON`, `repairMarkdown`, `sanitizeHtml`, `createParser`, `diffAst`, `collectNodeRenderers`.
 - Types: `ASTNode`, `Patch`, `RenderOutput` (`html | element | card | mount`), `CardDef`, `AIGuiPlugin`, `NodeRenderer`, `RendererOptions`, `JSONSchema`.
 

package/dist/index.cjs

@@ -24,6 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 const dompurify = __toESM(require("dompurify"));
 const markdown_it = __toESM(require("markdown-it"));
+const markdown_it_cjk_friendly = __toESM(require("markdown-it-cjk-friendly"));
 
 //#region src/partial-json.ts
 /**
@@ -1443,6 +1444,28 @@ function settleCardAction(settle) {
 
 //#endregion
 //#region src/plugins.ts
+/**
+* Resolve a plugin source to what the caller can act on now: the array itself, or a promise of it.
+*
+* The array form must stay synchronous. Deferring it by a microtask would render the first chunk
+* of every answer under the plain-markdown grammar and then redraw it, which is a visible flash
+* for a host that had its plugins all along.
+*/
+function loadPlugins(source) {
+	if (!source) return [];
+	return Array.isArray(source) ? source : source();
+}
+/**
+* Whether two lists hold the same plugins in the same order.
+*
+* `plugins={[chart, katex]}` is a new array on every render and the same two plugins every time.
+* What matters is the members, not the array.
+*/
+function samePlugins(a, b) {
+	if (a === b) return true;
+	if (!a || !b || a.length !== b.length) return false;
+	return a.every((plugin, index) => plugin === b[index]);
+}
 /** Merge every plugin's `nodeRenderers` into a single map (later plugins win). */
 function collectNodeRenderers(plugins = [], debugOptions = {}) {
 	const map = {};
@@ -1529,9 +1552,10 @@ function createParser(options = {}) {
 /** Build a parser that also reports the source range for each top-level block. */
 function createParserWithMetadata(options = {}) {
 	const md = new markdown_it.default({
-		html: true,
+		html: options.rawHtml !== false,
 		linkify: true
 	});
+	md.use(markdown_it_cjk_friendly.default);
 	options.configureMd?.(md);
 	for (const plugin of options.plugins ?? []) plugin.extendParser?.(md);
 	const hasParserExtensions = Boolean(options.configureMd || options.plugins?.some((plugin) => plugin.extendParser));
@@ -2047,12 +2071,51 @@ var Renderer = class {
 		this.options = options;
 		this.debug = new DebugEmitter(this.debugSource, options);
 		this.sanitize = options.sanitize === false ? false : typeof options.sanitize === "object" ? options.sanitize : {};
-		if (options.registry) for (const plugin of options.plugins ?? []) for (const card of plugin.cards ?? []) options.registry.register(card);
+		this.registerPluginCards(options.plugins);
 		this.parse = createParserWithMetadata({
 			registry: options.registry,
-			plugins: options.plugins
+			plugins: options.plugins,
+			rawHtml: options.rawHtml
 		});
 	}
+	/** The plugins currently parsing and rendering this renderer's output. */
+	get plugins() {
+		return this.options.plugins ?? [];
+	}
+	/**
+	* Swap the plugins in and redraw the answer already buffered.
+	*
+	* A plugin bundle is worth deferring — diagrams, maths and charts together outweigh everything
+	* else a page loads — but the stream does not wait for the import, so whatever arrived meanwhile
+	* was parsed under the plain-markdown grammar. Reparsing the buffer this renderer still holds is
+	* what turns that text into diagrams, which is why a host does not have to remember what it
+	* pushed and replay it once the chunk lands.
+	*
+	* Passing the same plugins again is a no-op, so a host may call this on every render.
+	*/
+	setPlugins(plugins) {
+		if (samePlugins(this.options.plugins, plugins)) return;
+		this.options = {
+			...this.options,
+			plugins
+		};
+		this.registerPluginCards(plugins);
+		this.parse = createParserWithMetadata({
+			registry: this.options.registry,
+			plugins,
+			rawHtml: this.options.rawHtml
+		});
+		this.parsed = void 0;
+		this.renderScheduled = false;
+		this.scheduleGeneration++;
+		if (this.debug.active) this.debug.emit("plugins-changed", { plugins: (plugins ?? []).map((plugin) => plugin.name) });
+		this.render();
+	}
+	registerPluginCards(plugins) {
+		const registry = this.options.registry;
+		if (!registry) return;
+		for (const plugin of plugins ?? []) for (const card of plugin.cards ?? []) registry.register(card);
+	}
 	get debugEnabled() {
 		return this.debug.available;
 	}
@@ -2844,6 +2907,7 @@ exports.getIdleActionState = getIdleActionState
 exports.injectPluginStyles = injectPluginStyles
 exports.isCardPatchResult = isCardPatchResult
 exports.jsonLines = jsonLines
+exports.loadPlugins = loadPlugins
 exports.mockModelStream = mockModelStream
 exports.ndjson = ndjson
 exports.parsePartialJSON = parsePartialJSON
@@ -2853,6 +2917,7 @@ exports.readableBytes = readableBytes
 exports.repairMarkdown = repairMarkdown
 exports.resolveMessages = resolveMessages
 exports.safeDebugValue = safeDebugValue
+exports.samePlugins = samePlugins
 exports.sanitizeHtml = sanitizeHtml
 exports.sanitizeRenderedHtml = sanitizeRenderedHtml
 exports.textLines = textLines

package/dist/index.d.cts

@@ -265,6 +265,17 @@ interface RendererOptions extends DebugOptions {
   registry?: CardRegistry;
   plugins?: AIGuiPlugin[];
   sanitize?: boolean | SanitizeHtmlOptions;
+  /**
+   * Whether raw HTML in the model's output is interpreted as markup. On by default.
+   *
+   * A tag a model wrote inside prose is usually text it is describing, not markup it means: one
+   * stray `<code>` in a sentence about code swallows the rest of the line into an element. Turning
+   * this off escapes every tag the model writes and shows the characters instead, which is what a
+   * product wants when the model is meant to produce markdown and nothing else. It is not a
+   * substitute for `sanitize` — a plugin's own markup and the host's cards are unaffected either
+   * way.
+   */
+  rawHtml?: boolean;
   /** Coalesce multiple pushes by scheduling one render callback. */
   scheduler?: (render: () => void) => void;
   onPatch?: (patches: Patch[], nodes: ASTNode[]) => void;
@@ -614,6 +625,17 @@ interface ParserOptions {
   registry?: CardRegistry;
   plugins?: AIGuiPlugin[];
   configureMd?: (md: MarkdownIt) => void;
+  /**
+   * Whether raw HTML in the model's output is interpreted as markup. On by default.
+   *
+   * A model writing *about* code emits tags in prose it never meant as markup — a line like
+   * `return "done\n<code>"` is text, but interpreting it swallows everything after the tag into an
+   * element and the rest of the sentence lands outside it. Sanitizing does not help: `<code>` is a
+   * tag any allowlist keeps. Turn this off and every tag the model writes is escaped and shown as
+   * the characters it wrote, so a model that gets HTML wrong produces an ugly line rather than a
+   * mangled answer.
+   */
+  rawHtml?: boolean;
 }
 interface SourceBlock {
   start: number;
@@ -636,6 +658,32 @@ declare function createParserWithMetadata(options?: ParserOptions): (src: string
 interface CollectNodeRendererOptions extends DebugOptions {
   debugTarget?: DebugInstrumentationTarget;
 }
+/** A function that produces the plugins, loading them first if they are not in the bundle yet. */
+type PluginsLoader = () => AIGuiPlugin[] | Promise<AIGuiPlugin[]>;
+/**
+ * Either the plugins themselves or a function that loads them.
+ *
+ * Diagrams, maths and charts are the heaviest thing a page carrying them loads, and an answer that
+ * never draws one should not pay for them. A loader lets the host defer the import: the renderer
+ * shows plain markdown until it resolves and reparses what has arrived by then, so the host does
+ * not have to hold the stream or replay it.
+ */
+type PluginSource = AIGuiPlugin[] | PluginsLoader;
+/**
+ * Resolve a plugin source to what the caller can act on now: the array itself, or a promise of it.
+ *
+ * The array form must stay synchronous. Deferring it by a microtask would render the first chunk
+ * of every answer under the plain-markdown grammar and then redraw it, which is a visible flash
+ * for a host that had its plugins all along.
+ */
+declare function loadPlugins(source?: PluginSource): AIGuiPlugin[] | Promise<AIGuiPlugin[]>;
+/**
+ * Whether two lists hold the same plugins in the same order.
+ *
+ * `plugins={[chart, katex]}` is a new array on every render and the same two plugins every time.
+ * What matters is the members, not the array.
+ */
+declare function samePlugins(a?: AIGuiPlugin[], b?: AIGuiPlugin[]): boolean;
 /** Merge every plugin's `nodeRenderers` into a single map (later plugins win). */
 declare function collectNodeRenderers(plugins?: AIGuiPlugin[], debugOptions?: CollectNodeRendererOptions): Record<string, NodeRenderer>;
 /** The set of node types claimed by the given plugins. */
@@ -798,6 +846,21 @@ declare class Renderer {
   private scheduleGeneration;
   private readonly debug;
   constructor(options?: RendererOptions);
+  /** The plugins currently parsing and rendering this renderer's output. */
+  get plugins(): readonly AIGuiPlugin[];
+  /**
+   * Swap the plugins in and redraw the answer already buffered.
+   *
+   * A plugin bundle is worth deferring — diagrams, maths and charts together outweigh everything
+   * else a page loads — but the stream does not wait for the import, so whatever arrived meanwhile
+   * was parsed under the plain-markdown grammar. Reparsing the buffer this renderer still holds is
+   * what turns that text into diagrams, which is why a host does not have to remember what it
+   * pushed and replay it once the chunk lands.
+   *
+   * Passing the same plugins again is a no-op, so a host may call this on every render.
+   */
+  setPlugins(plugins: AIGuiPlugin[] | undefined): void;
+  private registerPluginCards;
   get debugEnabled(): boolean;
   emitDebug(type: string, data?: Record<string, unknown>): void;
   push(chunk: string): void;
@@ -922,4 +985,4 @@ declare function mockModelStream(events: Iterable<ModelStreamEvent> | AsyncItera
 declare function readableBytes(chunks: Iterable<string | Uint8Array> | AsyncIterable<string | Uint8Array>): ReadableStream<Uint8Array>;
 
 //#endregion
-export { AIGuiPlugin, ASTNode, ActionAbortedError, ActionAlreadyRegisteredError, ActionContext, ActionDefinition, ActionDestroyedError, ActionDispatchOptions, ActionErrorEvent, ActionEventBase, ActionExecutionError, ActionNotFoundError, ActionOutcome, ActionRegisterOptions, ActionRegistry, ActionRequest, ActionRuntime, ActionRuntimeError, ActionRuntimeOptions, ActionStartEvent, ActionState, ActionStateListener, ActionStatus, ActionSuccessEvent, ActionTimeoutError, ActionValidationError, BuildSystemPromptOptions, ByteStreamSource, CARD_ID_MAX_LENGTH, CARD_JSON_MAX_DEPTH, CARD_JSON_MAX_NODES, CARD_PATCH_BATCH_MAX_SIZE, CardAction, CardActionError, CardDef, CardJSONError, CardLimitError, CardListener, CardNotFoundError, CardParseResult, CardPatch, CardPatchBatch, CardPatchResult, CardRecord, CardRegistry, CardRevisionConflictError, CardSnapshot, CardSnapshotError, CardStore, CardStoreError, CardStoreListener, CardStoreOptions, CardTypeConflictError, CardValidationError, ChannelSink, Citation, CollectNodeRendererOptions, DEFAULT_LOCALE, DebugEmitter, DebugEvent, DebugEventListener, DebugEventTarget, DebugInstrumentationTarget, DebugOptions, DebugRedactContext, DebugSource, ExportImageOptions, ExportedImage, FeedChunk, FeedOptions, FeedSource, JSONSchema, JSONSchemaValidationResult, Locale, MessageBundle, Messages, ModelStreamEvent, MountCardSlotRequest, MountedCardSlot, NodeRenderContext, NodeRenderer, OutcomeTone, ParseResult, ParserOptions, PartialJSONResult, Patch, PluginCommitContext, PluginStyle, RenderMountContext, RenderOutput, Renderer, RendererOptions, SSEEvent, SSEOptions, SafeDebugValueOptions, SanitizeHtmlOptions, SanitizeSetting, SourceBlock, StreamParseOptions, StreamRouter, Usage, actionOutcome, applyPatches, availableLocales, baseCss, buildSystemPrompt, collectNodeRenderers, collectPluginStyles, contentDeltas, createActionRuntime, createParser, createParserWithMetadata, diffAst, downloadImage, exportRenderedImages, exportSVGToImage, getActionKey, getIdleActionState, injectPluginStyles, isCardPatchResult, jsonLines, mockModelStream, ndjson, parsePartialJSON, parseSSE, pluginNodeTypes, readableBytes, repairMarkdown, resolveMessages, safeDebugValue, sanitizeHtml, sanitizeRenderedHtml, textLines, translate, translator, validateJSONSchema };
+export { AIGuiPlugin, ASTNode, ActionAbortedError, ActionAlreadyRegisteredError, ActionContext, ActionDefinition, ActionDestroyedError, ActionDispatchOptions, ActionErrorEvent, ActionEventBase, ActionExecutionError, ActionNotFoundError, ActionOutcome, ActionRegisterOptions, ActionRegistry, ActionRequest, ActionRuntime, ActionRuntimeError, ActionRuntimeOptions, ActionStartEvent, ActionState, ActionStateListener, ActionStatus, ActionSuccessEvent, ActionTimeoutError, ActionValidationError, BuildSystemPromptOptions, ByteStreamSource, CARD_ID_MAX_LENGTH, CARD_JSON_MAX_DEPTH, CARD_JSON_MAX_NODES, CARD_PATCH_BATCH_MAX_SIZE, CardAction, CardActionError, CardDef, CardJSONError, CardLimitError, CardListener, CardNotFoundError, CardParseResult, CardPatch, CardPatchBatch, CardPatchResult, CardRecord, CardRegistry, CardRevisionConflictError, CardSnapshot, CardSnapshotError, CardStore, CardStoreError, CardStoreListener, CardStoreOptions, CardTypeConflictError, CardValidationError, ChannelSink, Citation, CollectNodeRendererOptions, DEFAULT_LOCALE, DebugEmitter, DebugEvent, DebugEventListener, DebugEventTarget, DebugInstrumentationTarget, DebugOptions, DebugRedactContext, DebugSource, ExportImageOptions, ExportedImage, FeedChunk, FeedOptions, FeedSource, JSONSchema, JSONSchemaValidationResult, Locale, MessageBundle, Messages, ModelStreamEvent, MountCardSlotRequest, MountedCardSlot, NodeRenderContext, NodeRenderer, OutcomeTone, ParseResult, ParserOptions, PartialJSONResult, Patch, PluginCommitContext, PluginSource, PluginStyle, PluginsLoader, RenderMountContext, RenderOutput, Renderer, RendererOptions, SSEEvent, SSEOptions, SafeDebugValueOptions, SanitizeHtmlOptions, SanitizeSetting, SourceBlock, StreamParseOptions, StreamRouter, Usage, actionOutcome, applyPatches, availableLocales, baseCss, buildSystemPrompt, collectNodeRenderers, collectPluginStyles, contentDeltas, createActionRuntime, createParser, createParserWithMetadata, diffAst, downloadImage, exportRenderedImages, exportSVGToImage, getActionKey, getIdleActionState, injectPluginStyles, isCardPatchResult, jsonLines, loadPlugins, mockModelStream, ndjson, parsePartialJSON, parseSSE, pluginNodeTypes, readableBytes, repairMarkdown, resolveMessages, safeDebugValue, samePlugins, sanitizeHtml, sanitizeRenderedHtml, textLines, translate, translator, validateJSONSchema };

package/dist/index.d.ts

@@ -265,6 +265,17 @@ interface RendererOptions extends DebugOptions {
   registry?: CardRegistry;
   plugins?: AIGuiPlugin[];
   sanitize?: boolean | SanitizeHtmlOptions;
+  /**
+   * Whether raw HTML in the model's output is interpreted as markup. On by default.
+   *
+   * A tag a model wrote inside prose is usually text it is describing, not markup it means: one
+   * stray `<code>` in a sentence about code swallows the rest of the line into an element. Turning
+   * this off escapes every tag the model writes and shows the characters instead, which is what a
+   * product wants when the model is meant to produce markdown and nothing else. It is not a
+   * substitute for `sanitize` — a plugin's own markup and the host's cards are unaffected either
+   * way.
+   */
+  rawHtml?: boolean;
   /** Coalesce multiple pushes by scheduling one render callback. */
   scheduler?: (render: () => void) => void;
   onPatch?: (patches: Patch[], nodes: ASTNode[]) => void;
@@ -614,6 +625,17 @@ interface ParserOptions {
   registry?: CardRegistry;
   plugins?: AIGuiPlugin[];
   configureMd?: (md: MarkdownIt) => void;
+  /**
+   * Whether raw HTML in the model's output is interpreted as markup. On by default.
+   *
+   * A model writing *about* code emits tags in prose it never meant as markup — a line like
+   * `return "done\n<code>"` is text, but interpreting it swallows everything after the tag into an
+   * element and the rest of the sentence lands outside it. Sanitizing does not help: `<code>` is a
+   * tag any allowlist keeps. Turn this off and every tag the model writes is escaped and shown as
+   * the characters it wrote, so a model that gets HTML wrong produces an ugly line rather than a
+   * mangled answer.
+   */
+  rawHtml?: boolean;
 }
 interface SourceBlock {
   start: number;
@@ -636,6 +658,32 @@ declare function createParserWithMetadata(options?: ParserOptions): (src: string
 interface CollectNodeRendererOptions extends DebugOptions {
   debugTarget?: DebugInstrumentationTarget;
 }
+/** A function that produces the plugins, loading them first if they are not in the bundle yet. */
+type PluginsLoader = () => AIGuiPlugin[] | Promise<AIGuiPlugin[]>;
+/**
+ * Either the plugins themselves or a function that loads them.
+ *
+ * Diagrams, maths and charts are the heaviest thing a page carrying them loads, and an answer that
+ * never draws one should not pay for them. A loader lets the host defer the import: the renderer
+ * shows plain markdown until it resolves and reparses what has arrived by then, so the host does
+ * not have to hold the stream or replay it.
+ */
+type PluginSource = AIGuiPlugin[] | PluginsLoader;
+/**
+ * Resolve a plugin source to what the caller can act on now: the array itself, or a promise of it.
+ *
+ * The array form must stay synchronous. Deferring it by a microtask would render the first chunk
+ * of every answer under the plain-markdown grammar and then redraw it, which is a visible flash
+ * for a host that had its plugins all along.
+ */
+declare function loadPlugins(source?: PluginSource): AIGuiPlugin[] | Promise<AIGuiPlugin[]>;
+/**
+ * Whether two lists hold the same plugins in the same order.
+ *
+ * `plugins={[chart, katex]}` is a new array on every render and the same two plugins every time.
+ * What matters is the members, not the array.
+ */
+declare function samePlugins(a?: AIGuiPlugin[], b?: AIGuiPlugin[]): boolean;
 /** Merge every plugin's `nodeRenderers` into a single map (later plugins win). */
 declare function collectNodeRenderers(plugins?: AIGuiPlugin[], debugOptions?: CollectNodeRendererOptions): Record<string, NodeRenderer>;
 /** The set of node types claimed by the given plugins. */
@@ -798,6 +846,21 @@ declare class Renderer {
   private scheduleGeneration;
   private readonly debug;
   constructor(options?: RendererOptions);
+  /** The plugins currently parsing and rendering this renderer's output. */
+  get plugins(): readonly AIGuiPlugin[];
+  /**
+   * Swap the plugins in and redraw the answer already buffered.
+   *
+   * A plugin bundle is worth deferring — diagrams, maths and charts together outweigh everything
+   * else a page loads — but the stream does not wait for the import, so whatever arrived meanwhile
+   * was parsed under the plain-markdown grammar. Reparsing the buffer this renderer still holds is
+   * what turns that text into diagrams, which is why a host does not have to remember what it
+   * pushed and replay it once the chunk lands.
+   *
+   * Passing the same plugins again is a no-op, so a host may call this on every render.
+   */
+  setPlugins(plugins: AIGuiPlugin[] | undefined): void;
+  private registerPluginCards;
   get debugEnabled(): boolean;
   emitDebug(type: string, data?: Record<string, unknown>): void;
   push(chunk: string): void;
@@ -922,4 +985,4 @@ declare function mockModelStream(events: Iterable<ModelStreamEvent> | AsyncItera
 declare function readableBytes(chunks: Iterable<string | Uint8Array> | AsyncIterable<string | Uint8Array>): ReadableStream<Uint8Array>;
 
 //#endregion
-export { AIGuiPlugin, ASTNode, ActionAbortedError, ActionAlreadyRegisteredError, ActionContext, ActionDefinition, ActionDestroyedError, ActionDispatchOptions, ActionErrorEvent, ActionEventBase, ActionExecutionError, ActionNotFoundError, ActionOutcome, ActionRegisterOptions, ActionRegistry, ActionRequest, ActionRuntime, ActionRuntimeError, ActionRuntimeOptions, ActionStartEvent, ActionState, ActionStateListener, ActionStatus, ActionSuccessEvent, ActionTimeoutError, ActionValidationError, BuildSystemPromptOptions, ByteStreamSource, CARD_ID_MAX_LENGTH, CARD_JSON_MAX_DEPTH, CARD_JSON_MAX_NODES, CARD_PATCH_BATCH_MAX_SIZE, CardAction, CardActionError, CardDef, CardJSONError, CardLimitError, CardListener, CardNotFoundError, CardParseResult, CardPatch, CardPatchBatch, CardPatchResult, CardRecord, CardRegistry, CardRevisionConflictError, CardSnapshot, CardSnapshotError, CardStore, CardStoreError, CardStoreListener, CardStoreOptions, CardTypeConflictError, CardValidationError, ChannelSink, Citation, CollectNodeRendererOptions, DEFAULT_LOCALE, DebugEmitter, DebugEvent, DebugEventListener, DebugEventTarget, DebugInstrumentationTarget, DebugOptions, DebugRedactContext, DebugSource, ExportImageOptions, ExportedImage, FeedChunk, FeedOptions, FeedSource, JSONSchema, JSONSchemaValidationResult, Locale, MessageBundle, Messages, ModelStreamEvent, MountCardSlotRequest, MountedCardSlot, NodeRenderContext, NodeRenderer, OutcomeTone, ParseResult, ParserOptions, PartialJSONResult, Patch, PluginCommitContext, PluginStyle, RenderMountContext, RenderOutput, Renderer, RendererOptions, SSEEvent, SSEOptions, SafeDebugValueOptions, SanitizeHtmlOptions, SanitizeSetting, SourceBlock, StreamParseOptions, StreamRouter, Usage, actionOutcome, applyPatches, availableLocales, baseCss, buildSystemPrompt, collectNodeRenderers, collectPluginStyles, contentDeltas, createActionRuntime, createParser, createParserWithMetadata, diffAst, downloadImage, exportRenderedImages, exportSVGToImage, getActionKey, getIdleActionState, injectPluginStyles, isCardPatchResult, jsonLines, mockModelStream, ndjson, parsePartialJSON, parseSSE, pluginNodeTypes, readableBytes, repairMarkdown, resolveMessages, safeDebugValue, sanitizeHtml, sanitizeRenderedHtml, textLines, translate, translator, validateJSONSchema };
+export { AIGuiPlugin, ASTNode, ActionAbortedError, ActionAlreadyRegisteredError, ActionContext, ActionDefinition, ActionDestroyedError, ActionDispatchOptions, ActionErrorEvent, ActionEventBase, ActionExecutionError, ActionNotFoundError, ActionOutcome, ActionRegisterOptions, ActionRegistry, ActionRequest, ActionRuntime, ActionRuntimeError, ActionRuntimeOptions, ActionStartEvent, ActionState, ActionStateListener, ActionStatus, ActionSuccessEvent, ActionTimeoutError, ActionValidationError, BuildSystemPromptOptions, ByteStreamSource, CARD_ID_MAX_LENGTH, CARD_JSON_MAX_DEPTH, CARD_JSON_MAX_NODES, CARD_PATCH_BATCH_MAX_SIZE, CardAction, CardActionError, CardDef, CardJSONError, CardLimitError, CardListener, CardNotFoundError, CardParseResult, CardPatch, CardPatchBatch, CardPatchResult, CardRecord, CardRegistry, CardRevisionConflictError, CardSnapshot, CardSnapshotError, CardStore, CardStoreError, CardStoreListener, CardStoreOptions, CardTypeConflictError, CardValidationError, ChannelSink, Citation, CollectNodeRendererOptions, DEFAULT_LOCALE, DebugEmitter, DebugEvent, DebugEventListener, DebugEventTarget, DebugInstrumentationTarget, DebugOptions, DebugRedactContext, DebugSource, ExportImageOptions, ExportedImage, FeedChunk, FeedOptions, FeedSource, JSONSchema, JSONSchemaValidationResult, Locale, MessageBundle, Messages, ModelStreamEvent, MountCardSlotRequest, MountedCardSlot, NodeRenderContext, NodeRenderer, OutcomeTone, ParseResult, ParserOptions, PartialJSONResult, Patch, PluginCommitContext, PluginSource, PluginStyle, PluginsLoader, RenderMountContext, RenderOutput, Renderer, RendererOptions, SSEEvent, SSEOptions, SafeDebugValueOptions, SanitizeHtmlOptions, SanitizeSetting, SourceBlock, StreamParseOptions, StreamRouter, Usage, actionOutcome, applyPatches, availableLocales, baseCss, buildSystemPrompt, collectNodeRenderers, collectPluginStyles, contentDeltas, createActionRuntime, createParser, createParserWithMetadata, diffAst, downloadImage, exportRenderedImages, exportSVGToImage, getActionKey, getIdleActionState, injectPluginStyles, isCardPatchResult, jsonLines, loadPlugins, mockModelStream, ndjson, parsePartialJSON, parseSSE, pluginNodeTypes, readableBytes, repairMarkdown, resolveMessages, safeDebugValue, samePlugins, sanitizeHtml, sanitizeRenderedHtml, textLines, translate, translator, validateJSONSchema };

package/dist/index.js

@@ -1,5 +1,6 @@
 import DOMPurify from "dompurify";
 import MarkdownIt from "markdown-it";
+import cjkFriendly from "markdown-it-cjk-friendly";
 
 //#region src/partial-json.ts
 /**
@@ -1419,6 +1420,28 @@ function settleCardAction(settle) {
 
 //#endregion
 //#region src/plugins.ts
+/**
+* Resolve a plugin source to what the caller can act on now: the array itself, or a promise of it.
+*
+* The array form must stay synchronous. Deferring it by a microtask would render the first chunk
+* of every answer under the plain-markdown grammar and then redraw it, which is a visible flash
+* for a host that had its plugins all along.
+*/
+function loadPlugins(source) {
+	if (!source) return [];
+	return Array.isArray(source) ? source : source();
+}
+/**
+* Whether two lists hold the same plugins in the same order.
+*
+* `plugins={[chart, katex]}` is a new array on every render and the same two plugins every time.
+* What matters is the members, not the array.
+*/
+function samePlugins(a, b) {
+	if (a === b) return true;
+	if (!a || !b || a.length !== b.length) return false;
+	return a.every((plugin, index) => plugin === b[index]);
+}
 /** Merge every plugin's `nodeRenderers` into a single map (later plugins win). */
 function collectNodeRenderers(plugins = [], debugOptions = {}) {
 	const map = {};
@@ -1505,9 +1528,10 @@ function createParser(options = {}) {
 /** Build a parser that also reports the source range for each top-level block. */
 function createParserWithMetadata(options = {}) {
 	const md = new MarkdownIt({
-		html: true,
+		html: options.rawHtml !== false,
 		linkify: true
 	});
+	md.use(cjkFriendly);
 	options.configureMd?.(md);
 	for (const plugin of options.plugins ?? []) plugin.extendParser?.(md);
 	const hasParserExtensions = Boolean(options.configureMd || options.plugins?.some((plugin) => plugin.extendParser));
@@ -2023,12 +2047,51 @@ var Renderer = class {
 		this.options = options;
 		this.debug = new DebugEmitter(this.debugSource, options);
 		this.sanitize = options.sanitize === false ? false : typeof options.sanitize === "object" ? options.sanitize : {};
-		if (options.registry) for (const plugin of options.plugins ?? []) for (const card of plugin.cards ?? []) options.registry.register(card);
+		this.registerPluginCards(options.plugins);
 		this.parse = createParserWithMetadata({
 			registry: options.registry,
-			plugins: options.plugins
+			plugins: options.plugins,
+			rawHtml: options.rawHtml
 		});
 	}
+	/** The plugins currently parsing and rendering this renderer's output. */
+	get plugins() {
+		return this.options.plugins ?? [];
+	}
+	/**
+	* Swap the plugins in and redraw the answer already buffered.
+	*
+	* A plugin bundle is worth deferring — diagrams, maths and charts together outweigh everything
+	* else a page loads — but the stream does not wait for the import, so whatever arrived meanwhile
+	* was parsed under the plain-markdown grammar. Reparsing the buffer this renderer still holds is
+	* what turns that text into diagrams, which is why a host does not have to remember what it
+	* pushed and replay it once the chunk lands.
+	*
+	* Passing the same plugins again is a no-op, so a host may call this on every render.
+	*/
+	setPlugins(plugins) {
+		if (samePlugins(this.options.plugins, plugins)) return;
+		this.options = {
+			...this.options,
+			plugins
+		};
+		this.registerPluginCards(plugins);
+		this.parse = createParserWithMetadata({
+			registry: this.options.registry,
+			plugins,
+			rawHtml: this.options.rawHtml
+		});
+		this.parsed = void 0;
+		this.renderScheduled = false;
+		this.scheduleGeneration++;
+		if (this.debug.active) this.debug.emit("plugins-changed", { plugins: (plugins ?? []).map((plugin) => plugin.name) });
+		this.render();
+	}
+	registerPluginCards(plugins) {
+		const registry = this.options.registry;
+		if (!registry) return;
+		for (const plugin of plugins ?? []) for (const card of plugin.cards ?? []) registry.register(card);
+	}
 	get debugEnabled() {
 		return this.debug.available;
 	}
@@ -2772,4 +2835,4 @@ function delay(ms, signal) {
 }
 
 //#endregion
-export { ActionAbortedError, ActionAlreadyRegisteredError, ActionDestroyedError, ActionExecutionError, ActionNotFoundError, ActionRegistry, ActionRuntime, ActionRuntimeError, ActionTimeoutError, ActionValidationError, CARD_ID_MAX_LENGTH, CARD_JSON_MAX_DEPTH, CARD_JSON_MAX_NODES, CARD_PATCH_BATCH_MAX_SIZE, CardJSONError, CardLimitError, CardNotFoundError, CardRegistry, CardRevisionConflictError, CardSnapshotError, CardStore, CardStoreError, CardTypeConflictError, CardValidationError, DEFAULT_LOCALE, DebugEmitter, Renderer, StreamRouter, actionOutcome, applyPatches, availableLocales, baseCss, buildSystemPrompt, collectNodeRenderers, collectPluginStyles, contentDeltas, createActionRuntime, createParser, createParserWithMetadata, diffAst, downloadImage, exportRenderedImages, exportSVGToImage, getActionKey, getIdleActionState, injectPluginStyles, isCardPatchResult, jsonLines, mockModelStream, ndjson, parsePartialJSON, parseSSE, pluginNodeTypes, readableBytes, repairMarkdown, resolveMessages, safeDebugValue, sanitizeHtml, sanitizeRenderedHtml, textLines, translate, translator, validateJSONSchema };
+export { ActionAbortedError, ActionAlreadyRegisteredError, ActionDestroyedError, ActionExecutionError, ActionNotFoundError, ActionRegistry, ActionRuntime, ActionRuntimeError, ActionTimeoutError, ActionValidationError, CARD_ID_MAX_LENGTH, CARD_JSON_MAX_DEPTH, CARD_JSON_MAX_NODES, CARD_PATCH_BATCH_MAX_SIZE, CardJSONError, CardLimitError, CardNotFoundError, CardRegistry, CardRevisionConflictError, CardSnapshotError, CardStore, CardStoreError, CardTypeConflictError, CardValidationError, DEFAULT_LOCALE, DebugEmitter, Renderer, StreamRouter, actionOutcome, applyPatches, availableLocales, baseCss, buildSystemPrompt, collectNodeRenderers, collectPluginStyles, contentDeltas, createActionRuntime, createParser, createParserWithMetadata, diffAst, downloadImage, exportRenderedImages, exportSVGToImage, getActionKey, getIdleActionState, injectPluginStyles, isCardPatchResult, jsonLines, loadPlugins, mockModelStream, ndjson, parsePartialJSON, parseSSE, pluginNodeTypes, readableBytes, repairMarkdown, resolveMessages, safeDebugValue, samePlugins, sanitizeHtml, sanitizeRenderedHtml, textLines, translate, translator, validateJSONSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-gui/core",
-  "version": "0.21.1",
+  "version": "0.22.1",
   "description": "Headless streaming renderer core for LLM-generated UI — markdown/JSON repair, card registry, AST diff, plugin engine, sanitizer.",
   "keywords": [
     "llm",
@@ -52,7 +52,8 @@
   },
   "dependencies": {
     "dompurify": "^3.4.12",
-    "markdown-it": "^14.1.0"
+    "markdown-it": "^14.1.0",
+    "markdown-it-cjk-friendly": "^2.0.2"
   },
   "devDependencies": {
     "@types/markdown-it": "^14.1.2",