feat(storybook): add a process-isolated block-memo comparison

- BlockMemoCompareIsolated renders each side in a cross-site iframe
  with a THREE-WAY split — host on localhost, memo side on 127.0.0.1,
  legacy side on [::1] — so Chrome's site isolation gives every party
  its own renderer process: no shared main thread, GC, or frame loop
  between the sides, and fps / slow frames / long tasks become
  genuinely per-side metrics.
- three-way is load-bearing, not decoration: with a two-way split the
  side sharing the host page's process absorbs the host UI's work,
  measured as a stable ~330 ms penalty (~60% of a small-payload run)
  whose sign flipped exactly when the side hosts were swapped. [::1]
  availability is probed at mount with a degraded, explicitly flagged
  two-way fallback; the host also quiesces during runs (snapshots
  buffer in refs, flushed at 500 ms) so its own rendering stays out of
  the measurement window.
- BlockMemoSide is the addressable single-side story (configured via
  bmcMode/bmcSpy/bmcScheme URL params, driven over postMessage);
  isolatedProtocol.ts documents the message contract and the
  cross-site rationale. The verdict/summary/history UI is shared with
  the same-page story — keep both: same-page is the fairest JS-layer
  A/B, isolated answers per-side browser-level questions, and
  disagreement between them measures the coupling itself.

Author: AIEPhoenix

packages/core/stories/AIMarkdown.stories.tsx

@@ -7,6 +7,8 @@ import { withThemedBackground } from './decorators';
 import { useStreamedContent } from './streamingHelpers';
 import { StreamingPlayground } from './streaming/StreamingPlayground';
 import { BlockMemoComparison } from './streaming/BlockMemoComparison';
+import { IsolatedComparison } from './streaming/IsolatedComparison';
+import { IsolatedSide } from './streaming/IsolatedSide';
 import { DEFAULT_PAYLOAD } from './streaming/scenarios';
 import { getStreamingTheme } from './streaming/theme';
 
@@ -188,6 +190,58 @@ export const BlockMemoCompare: Story = {
   },
 };
 
+/**
+ * Process-ISOLATED variant of {@link BlockMemoCompare}: each side runs in a
+ * cross-site iframe (`localhost` vs `127.0.0.1`), which Chrome's Site
+ * Isolation places in separate renderer processes — no shared main thread,
+ * GC, or frame loop between the sides, so fps / slow frames / long tasks
+ * become genuinely per-side. See IsolatedComparison.tsx for the full
+ * tradeoff notes. Keep both stories: same-page = fairest JS-layer A/B;
+ * isolated = the only shape that answers per-side browser-level questions.
+ */
+export const BlockMemoCompareIsolated: Story = {
+  args: {
+    content: DEFAULT_PAYLOAD,
+  },
+  argTypes: {
+    content: {
+      control: 'text',
+      description: 'Markdown payload streamed by every scenario. Edit to test your own content.',
+    },
+    streaming: { table: { disable: true } },
+  },
+  parameters: {
+    controls: { exclude: ['streaming'] },
+    layout: 'fullscreen',
+  },
+  render: (args, context) => {
+    const currentTheme = context.globals.theme === 'dark' ? 'dark' : 'light';
+    return (
+      <IsolatedComparison
+        colorScheme={currentTheme}
+        initialScenario="randomTokens"
+        payload={args.content ?? DEFAULT_PAYLOAD}
+      />
+    );
+  },
+};
+
+/**
+ * One SIDE of {@link BlockMemoCompareIsolated} — loaded by that story's
+ * iframes with config in the URL (`bmcMode` / `bmcSpy` / `bmcScheme`).
+ * Also usable standalone to profile a single render path in isolation.
+ */
+export const BlockMemoSide: Story = {
+  args: {
+    content: '',
+  },
+  parameters: {
+    controls: { disable: true },
+    layout: 'fullscreen',
+  },
+  render: () => <IsolatedSide />,
+};
+
 export const CJKRenderErrorFix: Story = {
   args: {
     content: