@runtypelabs/persona 4.7.0 → 4.8.0

package/src/components/pill-composer-builder.test.ts

@@ -26,9 +26,13 @@ describe("buildPillComposer (single-row pill composer)", () => {
     expect(elements.sendButton.getAttribute("data-persona-composer-submit")).toBe("");
   });
 
-  it("hides suggestions and status text by default in pill mode", () => {
+  it("keeps suggestions available above the pill and hides status text", () => {
     const elements = buildPillComposer({ config: { apiUrl: "/api" } });
-    expect(elements.suggestions.style.display).toBe("none");
+    const footerChildren = Array.from(elements.footer.children);
+    expect(elements.suggestions.style.display).toBe("");
+    expect(footerChildren.indexOf(elements.suggestions)).toBeLessThan(
+      footerChildren.indexOf(elements.composerForm)
+    );
     expect(elements.statusText.style.display).toBe("none");
   });
 

package/src/components/pill-composer-builder.ts

@@ -72,9 +72,10 @@ export const buildPillPeekBanner = (): PillPeekBanner => {
  * Returns the same `ComposerElements` shape as `buildComposer` so panel.ts
  * and ui.ts plumbing is unconditional past the choice of builder.
  *
- * Suggestions row + status text are built (so plugin code that mutates
- * them keeps working and `bindComposerRefsFromFooter` finds them) but are
- * `display: none` by default: pill UX is just textarea + 3 buttons.
+ * Suggestions row + status text are built so plugin code that mutates them
+ * keeps working and `bindComposerRefsFromFooter` finds them. CSS hides the
+ * suggestions while collapsed and reveals them above the pill when expanded;
+ * status text stays hidden because the pill UX has no room for it.
  *
  * Attachment previews float ABOVE the pill in their own row when
  * AttachmentManager toggles the previews container's `display` property
@@ -89,7 +90,6 @@ export const buildPillComposer = (context: ComposerBuildContext): ComposerElemen
   });
 
   const suggestions = createSuggestionsRow();
-  suggestions.style.display = "none";
   const statusText = createStatusText(config);
   statusText.style.display = "none";
 
@@ -150,11 +150,11 @@ export const buildPillComposer = (context: ComposerBuildContext): ComposerElemen
 
   // Footer assembly:
   //   [previews row, hidden until attachments exist]
+  //   [suggestions, visible only while expanded]
   //   [pill form]
-  //   [hidden suggestions]
   //   [hidden status]
   if (attachment) footer.append(attachment.previewsContainer);
-  footer.append(composerForm, suggestions, statusText);
+  footer.append(suggestions, composerForm, statusText);
 
   // The pill flattens left/right into the form's grid; there's no separate
   // wrapper. Surface the form itself as `actionsRow` to satisfy the

package/src/components/reasoning-bubble.ts

@@ -2,6 +2,7 @@ import { createElement } from "../utils/dom";
 import { AgentWidgetConfig, AgentWidgetMessage } from "../types";
 import { describeReasonStatus, computeReasoningElapsed, parseFormattedTemplate } from "../utils/formatting";
 import { renderLucideIcon } from "../utils/icons";
+import { appendCharSpans } from "../utils/tool-loading-animation";
 
 // Expansion state per widget instance
 export const reasoningExpansionState = new Set<string>();
@@ -156,19 +157,6 @@ export const createReasoningBubble = (message: AgentWidgetMessage, config?: Agen
   const currentTemplate = isActive ? activeTemplate : completeTemplate;
   const skipCustomElement = customSummary instanceof HTMLElement;
 
-  // Helper: append text as individual animated character spans
-  const appendCharSpans = (container: HTMLElement, text: string, startIndex: number): number => {
-    let idx = startIndex;
-    for (const char of text) {
-      const span = createElement("span", "persona-tool-char");
-      span.style.setProperty("--char-index", String(idx));
-      span.textContent = char === " " ? "\u00A0" : char;
-      container.appendChild(span);
-      idx++;
-    }
-    return idx;
-  };
-
   /**
    * Renders a template into the title element, handling:
    * - Inline formatting markers: **bold**, *italic*, ~dim~

package/src/components/registry.ts

@@ -1,5 +1,6 @@
 import { AgentWidgetConfig, AgentWidgetMessage } from "../types";
 import { PersonaArtifactCard } from "./artifact-card";
+import { PersonaArtifactInline } from "./artifact-inline";
 
 /**
  * Context provided to component renderers
@@ -21,20 +22,42 @@ export type ComponentRenderer = (
   context: ComponentContext
 ) => HTMLElement;
 
+/**
+ * Per-component registration options
+ */
+export interface ComponentRegistrationOptions {
+  /**
+   * When false, the component directive renders bare in the thread (no
+   * persona-message-bubble chrome).
+   * @default true
+   */
+  bubbleChrome?: boolean;
+}
+
 /**
  * Component registry for managing custom components
  */
 class ComponentRegistry {
   private components: Map<string, ComponentRenderer> = new Map();
+  private options: Map<string, ComponentRegistrationOptions> = new Map();
 
   /**
    * Register a custom component
    */
-  register(name: string, renderer: ComponentRenderer): void {
+  register(
+    name: string,
+    renderer: ComponentRenderer,
+    options?: ComponentRegistrationOptions
+  ): void {
     if (this.components.has(name)) {
       console.warn(`[ComponentRegistry] Component "${name}" is already registered. Overwriting.`);
     }
     this.components.set(name, renderer);
+    if (options) {
+      this.options.set(name, options);
+    } else {
+      this.options.delete(name);
+    }
   }
 
   /**
@@ -42,6 +65,7 @@ class ComponentRegistry {
    */
   unregister(name: string): void {
     this.components.delete(name);
+    this.options.delete(name);
   }
 
   /**
@@ -58,6 +82,13 @@ class ComponentRegistry {
     return this.components.has(name);
   }
 
+  /**
+   * Get the registration options for a component, if any were supplied
+   */
+  getOptions(name: string): ComponentRegistrationOptions | undefined {
+    return this.options.get(name);
+  }
+
   /**
    * Get all registered component names
    */
@@ -70,6 +101,7 @@ class ComponentRegistry {
    */
   clear(): void {
     this.components.clear();
+    this.options.clear();
   }
 
   /**
@@ -87,5 +119,8 @@ class ComponentRegistry {
  */
 export const componentRegistry = new ComponentRegistry();
 
-// Register built-in components
-componentRegistry.register("PersonaArtifactCard", PersonaArtifactCard);
+// Register built-in components. The artifact card and inline block carry
+// their own border and surface, so they render bare in the thread to avoid
+// double-boxing.
+componentRegistry.register("PersonaArtifactCard", PersonaArtifactCard, { bubbleChrome: false });
+componentRegistry.register("PersonaArtifactInline", PersonaArtifactInline, { bubbleChrome: false });

package/src/components/tool-bubble.ts

@@ -2,6 +2,7 @@ import { createElement } from "../utils/dom";
 import { AgentWidgetMessage, AgentWidgetConfig } from "../types";
 import { formatUnknownValue, describeToolTitle, resolveToolHeaderText, computeToolElapsed, parseFormattedTemplate } from "../utils/formatting";
 import { renderLucideIcon } from "../utils/icons";
+import { appendCharSpans } from "../utils/tool-loading-animation";
 
 // Expansion state per widget instance
 export const toolExpansionState = new Set<string>();
@@ -259,19 +260,6 @@ export const createToolBubble = (message: AgentWidgetMessage, config?: AgentWidg
   const currentTemplate = isActive ? activeTemplate : completeTemplate;
   const skipCustomElement = customSummary instanceof HTMLElement;
 
-  // Helper: append text as individual animated character spans
-  const appendCharSpans = (container: HTMLElement, text: string, startIndex: number): number => {
-    let idx = startIndex;
-    for (const char of text) {
-      const span = createElement("span", "persona-tool-char");
-      span.style.setProperty("--char-index", String(idx));
-      span.textContent = char === " " ? "\u00A0" : char;
-      container.appendChild(span);
-      idx++;
-    }
-    return idx;
-  };
-
   /**
    * Renders a template into the title element, handling:
    * - Inline formatting markers: **bold**, *italic*, ~dim~

package/src/defaults.ts

@@ -144,6 +144,7 @@ export const DEFAULT_WIDGET_CONFIG: Partial<AgentWidgetConfig> = {
       collapsedMode: "tool-call",
       activePreview: false,
       grouped: false,
+      groupedMode: "stack",
       previewMaxLines: 3,
       expandable: true,
       loadingAnimation: "none",

package/src/generated/runtype-openapi-contract.ts

@@ -22,6 +22,7 @@ export type RuntypeExecutionStreamEvent = ({
   totalSteps?: number;
   type: "execution_start";
 }) | ({
+  claudeManagedAgentId?: string;
   completedAt?: string;
   durationMs?: number;
   executionId: string;
@@ -66,6 +67,15 @@ export type RuntypeExecutionStreamEvent = ({
   completedAt?: string;
   content?: string;
   cost?: number;
+  estimatedContextBreakdown?: {
+  categories: Record<string, {
+  chars: number;
+  estimatedTokens: number;
+}>;
+  contextWindowSize?: number;
+  estimatedTotalTokens: number;
+  estimatedUtilizationPercent?: number;
+};
   executionId: string;
   fallback?: {
   attempts: Array<{
@@ -103,6 +113,7 @@ export type RuntypeExecutionStreamEvent = ({
   type: "step_start";
 } | ({
   completedAt?: string;
+  cost?: number;
   durationMs?: number;
   error?: string;
   executionId: string;
@@ -208,6 +219,11 @@ export type RuntypeExecutionStreamEvent = ({
   artifactType: "markdown" | "component";
   component?: string;
   executionId?: string;
+  file?: {
+  language?: string;
+  mimeType: string;
+  path: string;
+};
   id: string;
   seq?: number;
   title?: string;
@@ -316,6 +332,14 @@ export type RuntypeExecutionStreamEvent = ({
   awaitReason?: string;
   awaitedAt?: string;
   crawlId?: string;
+  elicitation?: {
+  message: string;
+  mode: "form" | "url";
+  pauseCount?: number;
+  requestedSchema?: Record<string, unknown>;
+  serverName?: string;
+  url?: string;
+};
   executionId: string;
   origin?: "webmcp" | "sdk";
   pageOrigin?: string;
@@ -416,6 +440,14 @@ export type RuntypeFlowSSEEvent = {
   awaitReason?: string;
   awaitedAt: string;
   crawlId?: string;
+  elicitation?: {
+  message: string;
+  mode: "form" | "url";
+  pauseCount?: number;
+  requestedSchema?: Record<string, unknown>;
+  serverName?: string;
+  url?: string;
+};
   executionId?: string;
   flowId: string;
   origin?: "webmcp" | "sdk";
@@ -466,7 +498,7 @@ export type RuntypeFlowSSEEvent = {
   completedAt?: string;
   duration?: number;
   durationMs?: number;
-  error?: string;
+  error?: string | null;
   executionId?: string;
   executionTime?: number;
   id?: string;
@@ -510,13 +542,21 @@ export type RuntypeFlowSSEEvent = {
   totalSteps: number;
   type: "step_skip";
   when: string;
-} | {
+} | ({
+  elicitation?: {
+  message: string;
+  mode: "form" | "url";
+  pauseCount?: number;
+  requestedSchema?: Record<string, unknown>;
+  serverName?: string;
+  url?: string;
+};
   executionId?: string;
   reason?: string;
   seq?: number;
   type: "step_await";
   [key: string]: unknown;
-} | ({
+}) | ({
   agentContext?: {
   executionId: string;
   iteration: number;
@@ -735,6 +775,18 @@ export type RuntypeClientChatRequest = {
 export type RuntypeClientChatStreamEvent = RuntypeExecutionStreamEvent;
 
 export type RuntypeClientResumeRequest = {
+  clientTools?: Array<{
+  description: string;
+  name: string;
+  origin?: "webmcp" | "sdk";
+  pageOrigin?: string;
+  parametersSchema: {
+  type: "object";
+  [key: string]: unknown;
+};
+  untrustedContentHint?: boolean;
+}>;
+  clientToolsFingerprint?: string;
   executionId: string;
   messages?: Array<{
   content: string | (Array<{

package/src/index-core.ts

@@ -10,8 +10,12 @@ export type {
   AgentWidgetFeatureFlags,
   AgentWidgetArtifactsFeature,
   AgentWidgetArtifactsLayoutConfig,
+  PersonaArtifactDisplayMode,
   PersonaArtifactKind,
   PersonaArtifactRecord,
+  PersonaArtifactActionContext,
+  PersonaArtifactStatusLabelContext,
+  PersonaArtifactCustomAction,
   PersonaArtifactManualUpsert,
   ArtifactConfigPayload,
   AgentWidgetInitOptions,
@@ -188,6 +192,17 @@ export {
   createDirectivePostprocessor
 } from "./postprocessors";
 export type { MarkdownProcessorOptions } from "./postprocessors";
+// Markdown parser-readiness escape hatch. On the IIFE/CDN build `marked` +
+// `DOMPurify` load lazily, so content injected right after init can render as
+// escaped plain text until the chunk resolves. Hosts can `await
+// loadMarkdownParsers()` before injecting, or `onMarkdownParsersReady(cb)` to be
+// told when they land (both resolve/no-op instantly on the npm build, where the
+// parsers are bundled eagerly).
+export {
+  loadMarkdownParsers,
+  onMarkdownParsersReady
+} from "./markdown-parsers-loader";
+export type { MarkdownParsersModule } from "./markdown-parsers-loader";
 export {
   createDefaultSanitizer,
   resolveSanitizer
@@ -361,7 +376,11 @@ export type {
 
 // Component system exports
 export { componentRegistry } from "./components/registry";
-export type { ComponentRenderer, ComponentContext } from "./components/registry";
+export type {
+  ComponentRenderer,
+  ComponentContext,
+  ComponentRegistrationOptions
+} from "./components/registry";
 export {
   createComponentStreamParser,
   isComponentDirectiveType

package/src/index.ts

@@ -37,3 +37,11 @@ export type {
   DemoCarouselOptions,
   DemoCarouselHandle
 } from "./components/demo-carousel";
+
+// Accessible roving-tabindex tablist helper for custom artifact tab bars
+// (features.artifacts.renderTabBar).
+export { createRovingTablist } from "./utils/roving-tablist";
+export type {
+  RovingTablistController,
+  RovingTablistOptions
+} from "./utils/roving-tablist";

package/src/markdown-parsers-loader.test.ts

@@ -0,0 +1,158 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { MarkdownParsersModule } from "./markdown-parsers-loader";
+
+/**
+ * Tests for the parser-ready subscription registry.
+ *
+ * The loader holds module-level singleton state (`moduleCache`, subscribers), and
+ * `vitest.setup.ts` eager-provides parsers into the shared graph — which would make
+ * `onMarkdownParsersReady` no-op everywhere. So each test imports a FRESH copy of
+ * the loader via `vi.resetModules()` + dynamic import, starting from the unloaded
+ * (IIFE/CDN) state, and drives the transition itself.
+ */
+
+// A stand-in parsers module; the registry never touches its fields.
+const FAKE_PARSERS = {} as unknown as MarkdownParsersModule;
+
+const freshLoader = async () => {
+  vi.resetModules();
+  return import("./markdown-parsers-loader");
+};
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("onMarkdownParsersReady", () => {
+  it("fires a pending subscriber once when the lazy chunk resolves", async () => {
+    const loader = await freshLoader();
+    loader.setMarkdownParsersLoader(() => Promise.resolve(FAKE_PARSERS));
+
+    const cb = vi.fn();
+    loader.onMarkdownParsersReady(cb);
+    expect(cb).not.toHaveBeenCalled(); // not yet: chunk not loaded
+
+    await loader.loadMarkdownParsers();
+    expect(cb).toHaveBeenCalledTimes(1);
+  });
+
+  it("kicks the load itself so a lone surface still heals", async () => {
+    const loader = await freshLoader();
+    const load = vi.fn(() => Promise.resolve(FAKE_PARSERS));
+    loader.setMarkdownParsersLoader(load);
+
+    const cb = vi.fn();
+    // No explicit loadMarkdownParsers() call — subscribing must trigger it.
+    loader.onMarkdownParsersReady(cb);
+    await vi.waitFor(() => expect(cb).toHaveBeenCalledTimes(1));
+    expect(load).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not fire (and returns a no-op) when parsers are already loaded", async () => {
+    const loader = await freshLoader();
+    loader.provideMarkdownParsers(FAKE_PARSERS); // eager/ESM steady state
+
+    const cb = vi.fn();
+    const unsub = loader.onMarkdownParsersReady(cb);
+    await Promise.resolve();
+    expect(cb).not.toHaveBeenCalled();
+    expect(() => unsub()).not.toThrow();
+  });
+
+  it("unsubscribe prevents the callback from firing", async () => {
+    const loader = await freshLoader();
+    loader.setMarkdownParsersLoader(() => Promise.resolve(FAKE_PARSERS));
+
+    const cb = vi.fn();
+    const unsub = loader.onMarkdownParsersReady(cb);
+    unsub();
+
+    await loader.loadMarkdownParsers();
+    expect(cb).not.toHaveBeenCalled();
+  });
+
+  it("fires each subscriber exactly once (no re-fire on a later load call)", async () => {
+    const loader = await freshLoader();
+    loader.setMarkdownParsersLoader(() => Promise.resolve(FAKE_PARSERS));
+
+    const cb = vi.fn();
+    loader.onMarkdownParsersReady(cb);
+
+    await loader.loadMarkdownParsers();
+    await loader.loadMarkdownParsers(); // cached; must not re-notify
+    expect(cb).toHaveBeenCalledTimes(1);
+  });
+
+  it("provideMarkdownParsers (eager) flushes pending subscribers", async () => {
+    const loader = await freshLoader();
+    // Subscribe while still unloaded, then have the eager path provide.
+    loader.setMarkdownParsersLoader(() => new Promise(() => {})); // never resolves
+    const cb = vi.fn();
+    loader.onMarkdownParsersReady(cb);
+
+    loader.provideMarkdownParsers(FAKE_PARSERS);
+    expect(cb).toHaveBeenCalledTimes(1);
+  });
+
+  it("keeps pending subscribers across a failed chunk load so a successful retry heals them", async () => {
+    const loader = await freshLoader();
+    let attempt = 0;
+    loader.setMarkdownParsersLoader(() => {
+      attempt += 1;
+      return attempt === 1
+        ? Promise.reject(new Error("chunk 404"))
+        : Promise.resolve(FAKE_PARSERS);
+    });
+
+    const cb = vi.fn();
+    loader.onMarkdownParsersReady(cb);
+    await expect(loader.loadMarkdownParsers()).rejects.toThrow("chunk 404");
+    // Failed attempt: not fired, but still registered.
+    expect(cb).not.toHaveBeenCalled();
+
+    // A later subscribe re-triggers the load (rejected promise was not cached)
+    // and the retry heals BOTH the new subscriber and the one that rendered
+    // escaped during the failed attempt.
+    const cb2 = vi.fn();
+    loader.onMarkdownParsersReady(cb2);
+    await vi.waitFor(() => expect(cb2).toHaveBeenCalledTimes(1));
+    expect(cb).toHaveBeenCalledTimes(1);
+    expect(attempt).toBe(2);
+  });
+
+  it("unsubscribing after a failed load still prevents firing on the retry", async () => {
+    const loader = await freshLoader();
+    let attempt = 0;
+    loader.setMarkdownParsersLoader(() => {
+      attempt += 1;
+      return attempt === 1
+        ? Promise.reject(new Error("chunk 404"))
+        : Promise.resolve(FAKE_PARSERS);
+    });
+
+    const cb = vi.fn();
+    const unsub = loader.onMarkdownParsersReady(cb);
+    await expect(loader.loadMarkdownParsers()).rejects.toThrow("chunk 404");
+    unsub();
+
+    await loader.loadMarkdownParsers();
+    expect(cb).not.toHaveBeenCalled();
+    expect(attempt).toBe(2);
+  });
+
+  it("one throwing subscriber does not starve the others", async () => {
+    const loader = await freshLoader();
+    loader.setMarkdownParsersLoader(() => Promise.resolve(FAKE_PARSERS));
+
+    const boom = vi.fn(() => {
+      throw new Error("subscriber blew up");
+    });
+    const ok = vi.fn();
+    loader.onMarkdownParsersReady(boom);
+    loader.onMarkdownParsersReady(ok);
+
+    await loader.loadMarkdownParsers();
+    expect(boom).toHaveBeenCalledTimes(1);
+    expect(ok).toHaveBeenCalledTimes(1);
+  });
+});

package/src/markdown-parsers-loader.ts

@@ -10,10 +10,66 @@ let loader: (() => Promise<MarkdownParsersModule>) | null = null;
 let moduleCache: MarkdownParsersModule | null = null;
 let loadPromise: Promise<MarkdownParsersModule> | null = null;
 
+// Surfaces that want to self-heal when the lazy `markdown-parsers.js` chunk
+// lands. See `onMarkdownParsersReady` below for why this is centralized.
+const readySubscribers = new Set<() => void>();
+
+// Flip `moduleCache` and fan out to everyone waiting to re-render, exactly once
+// per subscriber. Called from BOTH the eager (`provideMarkdownParsers`) and lazy
+// (`loadMarkdownParsers`) paths so a subscriber can't miss the transition.
+const markParsersReady = (mod: MarkdownParsersModule): MarkdownParsersModule => {
+  moduleCache = mod;
+  // Snapshot + clear first: fire-once semantics, and a callback that re-subscribes
+  // (it won't — `onMarkdownParsersReady` no-ops once ready) can't loop.
+  const subs = [...readySubscribers];
+  readySubscribers.clear();
+  for (const cb of subs) {
+    // One bad subscriber must not starve the others (or leave messages escaped).
+    try {
+      cb();
+    } catch {
+      /* subscriber threw: swallow so the remaining re-renders still run */
+    }
+  }
+  return mod;
+};
+
 export const setMarkdownParsersLoader = (l: () => Promise<MarkdownParsersModule>) => {
   loader = l;
 };
 
+/**
+ * Register `cb` to run once the markdown parsers (marked + DOMPurify) become
+ * available, i.e. when the lazy `markdown-parsers.js` chunk resolves on the
+ * IIFE/CDN build. Returns an unsubscribe function.
+ *
+ * This exists so every markdown render surface (chat messages, artifact pane,
+ * and any future one) shares a SINGLE self-heal path instead of each wiring its
+ * own `loadMarkdownParsers().then(reRender)`. Before this, a new surface that
+ * forgot to do that rendered escaped plain text until a user interaction forced
+ * a re-render — the recurring first-render bug (chat messages, then the artifact
+ * pane) this centralizes away.
+ *
+ * If the parsers are ALREADY loaded, `cb` is not scheduled and a no-op
+ * unsubscribe is returned: the caller's first render already used real markdown,
+ * so there is nothing to heal (this is the ESM/CJS build's steady state, and the
+ * CDN build's state after the first chunk load). Registering also kicks the load
+ * so a surface that renders before anything else triggers it still heals.
+ * Fires at most once per subscription.
+ */
+export const onMarkdownParsersReady = (cb: () => void): (() => void) => {
+  if (moduleCache) return () => {};
+  readySubscribers.add(cb);
+  // Ensure the chunk is actually being fetched; harmless if already in flight.
+  // Swallow rejection here — on failure the subscriber stays registered (see
+  // `onLoadFailure`) and the surface keeps its escaped fallback until a retry
+  // succeeds; this catch only avoids an unhandled rejection.
+  void loadMarkdownParsers().catch(() => {});
+  return () => {
+    readySubscribers.delete(cb);
+  };
+};
+
 /**
  * Register the parsers synchronously. Used by the ESM/CJS build (where `marked`
  * and `dompurify` are bundled directly via `markdown-parsers-eager.ts`), so
@@ -23,7 +79,22 @@ export const setMarkdownParsersLoader = (l: () => Promise<MarkdownParsersModule>
  * it lazy-loads the `markdown-parsers.js` chunk instead.
  */
 export const provideMarkdownParsers = (mod: MarkdownParsersModule): void => {
-  moduleCache = mod;
+  markParsersReady(mod);
+};
+
+// On a failed chunk load (404, ad blocker, offline), don't cache the rejected
+// promise: reset it so a later subscribe/load call can retry. Pending
+// subscribers are KEPT — a surface that rendered escaped during the failed
+// attempt must still heal when a retry (kicked by a new subscriber or an
+// explicit loadMarkdownParsers() call) succeeds; dropping them here left that
+// surface escaped forever after a transient failure. They're only retained
+// while the parsers stay unloaded — success releases them (fire-once in
+// `markParsersReady`), and callers can unsubscribe. On a permanently failing
+// setup they persist for the page's life, which is the price of healing.
+// Re-throw so awaiters of loadMarkdownParsers() still observe the rejection.
+const onLoadFailure = (err: unknown): never => {
+  loadPromise = null;
+  throw err;
 };
 
 export const loadMarkdownParsers = (): Promise<MarkdownParsersModule> => {
@@ -31,16 +102,10 @@ export const loadMarkdownParsers = (): Promise<MarkdownParsersModule> => {
   if (loadPromise) return loadPromise;
   if (!loader) {
     // Fallback for regular ESM/CJS consumers (they import directly)
-    loadPromise = import("./markdown-parsers-entry").then((mod) => {
-      moduleCache = mod;
-      return mod;
-    });
+    loadPromise = import("./markdown-parsers-entry").then(markParsersReady, onLoadFailure);
     return loadPromise;
   }
-  loadPromise = loader().then((mod) => {
-    moduleCache = mod;
-    return mod;
-  });
+  loadPromise = loader().then(markParsersReady, onLoadFailure);
   return loadPromise;
 };