diff --git a/CHANGELOG.prerelease.md b/CHANGELOG.prerelease.md
index dd71a1667da1..b622e4db4249 100644
--- a/CHANGELOG.prerelease.md
+++ b/CHANGELOG.prerelease.md
@@ -1,3 +1,14 @@
+## 10.4.0-alpha.17
+
+- Agentic Setup: Keep sample content if users want onboarding - [#34704](https://github.com/storybookjs/storybook/pull/34704), thanks @Sidnioulz!
+- Fix ArgsTable borders not visible in Windows High Contrast Mode - [#34264](https://github.com/storybookjs/storybook/pull/34264), thanks @TheSeydiCharyyev!
+- MDX: Replace `@storybook/docs-mdx` with inline implementation - [#34611](https://github.com/storybookjs/storybook/pull/34611), thanks @copilot-swe-agent!
+- Maintenance: Enhance ghost stories internal tests - [#34707](https://github.com/storybookjs/storybook/pull/34707), thanks @yannbf!
+- ReactNative: Add Metro config AST codemod for init - [#34660](https://github.com/storybookjs/storybook/pull/34660), thanks @ndelangen!
+- ReactNative: New init setup - [#34665](https://github.com/storybookjs/storybook/pull/34665), thanks @ndelangen!
+- Tanstack: Add `@storybook/tanstack-react` package - [#34403](https://github.com/storybookjs/storybook/pull/34403), thanks @huang-julien!
+- UI: Fix showing and hiding copy prompt in the correct scenarios - [#34706](https://github.com/storybookjs/storybook/pull/34706), thanks @yannbf!
+
 ## 10.4.0-alpha.16
 
 - Automigration: Move RN on-device addons to `deviceAddons` - [#34659](https://github.com/storybookjs/storybook/pull/34659), thanks @ndelangen!
diff --git a/code/addons/docs/src/blocks/components/ArgsTable/ArgsTable.tsx b/code/addons/docs/src/blocks/components/ArgsTable/ArgsTable.tsx
index 1f1dfc4394a5..11e0325d6460 100644
--- a/code/addons/docs/src/blocks/components/ArgsTable/ArgsTable.tsx
+++ b/code/addons/docs/src/blocks/components/ArgsTable/ArgsTable.tsx
@@ -160,6 +160,17 @@ export const TableWrapper = styled.table<{
             },
           }),
     },
+    // High contrast mode: ensure borders are visible with system colors
+    '@media (forced-colors: active)': {
+      tbody: {
+        filter: 'none',
+
+        '> tr > *': {
+          borderColor: 'CanvasText',
+        },
+      },
+    },
+
     // End awesome table styling
   },
 }));
diff --git a/code/builders/builder-vite/src/change-detection-adapter/index.test.ts b/code/builders/builder-vite/src/change-detection-adapter/index.test.ts
new file mode 100644
index 000000000000..e81ad59504cb
--- /dev/null
+++ b/code/builders/builder-vite/src/change-detection-adapter/index.test.ts
@@ -0,0 +1,143 @@
+// Tests the Vite implementation of ChangeDetectionAdapter — wiring of resolve config
+// snapshot and chokidar event normalisation.
+import { EventEmitter } from 'node:events';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { ViteDevServer } from 'vite';
+
+import { createViteChangeDetectionAdapter } from './index.ts';
+
+vi.mock('vite', { spy: true });
+
+interface FakeViteDevServer {
+  config: {
+    root: string;
+    resolve?: {
+      alias?: unknown;
+      conditions?: string[];
+      tsconfig?: string;
+    };
+  };
+  watcher: EventEmitter;
+}
+
+function createFakeServer(overrides: Partial<FakeViteDevServer['config']> = {}): {
+  server: ViteDevServer;
+  watcher: EventEmitter;
+} {
+  const watcher = new EventEmitter();
+  const server: FakeViteDevServer = {
+    config: {
+      root: '/repo',
+      ...overrides,
+    },
+    watcher,
+  };
+  return { server: server as unknown as ViteDevServer, watcher };
+}
+
+describe('createViteChangeDetectionAdapter', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('snapshots projectRoot, alias and conditions from server.config in getResolveConfig()', async () => {
+    const alias = [{ find: '@', replacement: '/repo/src' }];
+    const conditions = ['import', 'module', 'default'];
+    const { server } = createFakeServer({
+      root: '/repo',
+      resolve: { alias, conditions },
+    });
+
+    const adapter = createViteChangeDetectionAdapter(server);
+    const config = await adapter.getResolveConfig();
+
+    expect(config).toEqual({
+      projectRoot: '/repo',
+      alias,
+      conditions,
+    });
+  });
+
+  it('forwards chokidar `add` events as kind: "add"', () => {
+    const { server, watcher } = createFakeServer();
+    const adapter = createViteChangeDetectionAdapter(server);
+    const handler = vi.fn();
+    adapter.onFileChange(handler);
+
+    watcher.emit('all', 'add', '/repo/src/A.tsx');
+
+    expect(handler).toHaveBeenCalledWith({ kind: 'add', path: '/repo/src/A.tsx' });
+  });
+
+  it('forwards chokidar `change` events as kind: "change"', () => {
+    const { server, watcher } = createFakeServer();
+    const adapter = createViteChangeDetectionAdapter(server);
+    const handler = vi.fn();
+    adapter.onFileChange(handler);
+
+    watcher.emit('all', 'change', '/repo/src/A.tsx');
+
+    expect(handler).toHaveBeenCalledWith({ kind: 'change', path: '/repo/src/A.tsx' });
+  });
+
+  it('forwards chokidar `unlink` events as kind: "unlink"', () => {
+    const { server, watcher } = createFakeServer();
+    const adapter = createViteChangeDetectionAdapter(server);
+    const handler = vi.fn();
+    adapter.onFileChange(handler);
+
+    watcher.emit('all', 'unlink', '/repo/src/A.tsx');
+
+    expect(handler).toHaveBeenCalledWith({ kind: 'unlink', path: '/repo/src/A.tsx' });
+  });
+
+  it('does NOT forward `addDir`, `unlinkDir`, `ready`, `raw`, or `error` chokidar events', () => {
+    const { server, watcher } = createFakeServer();
+    const adapter = createViteChangeDetectionAdapter(server);
+    const handler = vi.fn();
+    adapter.onFileChange(handler);
+
+    watcher.emit('all', 'addDir', '/repo/src/some-dir');
+    watcher.emit('all', 'unlinkDir', '/repo/src/some-dir');
+    watcher.emit('all', 'ready');
+    watcher.emit('all', 'raw', '/repo/src/A.tsx');
+    watcher.emit('all', 'error', new Error('boom'));
+
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('normalises chokidar paths via pathe.normalize before forwarding', () => {
+    const { server, watcher } = createFakeServer();
+    const adapter = createViteChangeDetectionAdapter(server);
+    const handler = vi.fn();
+    adapter.onFileChange(handler);
+
+    // Path with `/./` and mixed-case noise that pathe.normalize collapses.
+    watcher.emit('all', 'change', '/repo/src/./A.tsx');
+
+    expect(handler).toHaveBeenCalledWith({
+      kind: 'change',
+      path: '/repo/src/A.tsx',
+    });
+  });
+
+  it('returns an unsubscribe function that removes the listener', () => {
+    const { server, watcher } = createFakeServer();
+    const adapter = createViteChangeDetectionAdapter(server);
+    const handler = vi.fn();
+    const unsubscribe = adapter.onFileChange(handler);
+
+    watcher.emit('all', 'change', '/repo/src/A.tsx');
+    expect(handler).toHaveBeenCalledTimes(1);
+
+    unsubscribe();
+    watcher.emit('all', 'change', '/repo/src/B.tsx');
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/code/builders/builder-vite/src/change-detection-adapter/index.ts b/code/builders/builder-vite/src/change-detection-adapter/index.ts
new file mode 100644
index 000000000000..edbc4812ad10
--- /dev/null
+++ b/code/builders/builder-vite/src/change-detection-adapter/index.ts
@@ -0,0 +1,53 @@
+import type {
+  ChangeDetectionAdapter,
+  FileChangeEvent,
+  ModuleResolveConfig,
+} from 'storybook/internal/core-server';
+
+import { normalize } from 'pathe';
+import type { ViteDevServer } from 'vite';
+
+/**
+ * Vite implementation of {@link ChangeDetectionAdapter}.
+ *
+ * - `getResolveConfig()` snapshots `server.config.resolve.alias`, `server.config.resolve.conditions`
+ *   and `server.config.root` once at startup. The detector caches the result.
+ * - `onFileChange()` subscribes to `server.watcher` (chokidar) and forwards `add`/`change`/`unlink`
+ *   events with normalised absolute paths. Other chokidar event names (`addDir`, `unlinkDir`,
+ *   `ready`, `raw`, `error`) are intentionally filtered out.
+ */
+export function createViteChangeDetectionAdapter(server: ViteDevServer): ChangeDetectionAdapter {
+  return {
+    async getResolveConfig(): Promise<ModuleResolveConfig> {
+      const resolveOpts = server.config.resolve;
+      // Vite normalises `resolve.alias` to its array form (`Array<{find, replacement, ...}>`)
+      // before we ever see it. The detector accepts both Record and Array shapes, so we pass
+      // the array through unchanged.
+      const alias = resolveOpts?.alias as ModuleResolveConfig['alias'];
+      const conditions = resolveOpts?.conditions;
+
+      return {
+        projectRoot: server.config.root,
+        alias,
+        conditions,
+      };
+    },
+
+    onFileChange(handler) {
+      const FORWARDED_EVENTS = new Set<FileChangeEvent['kind']>(['add', 'change', 'unlink']);
+      const isForwardedEvent = (name: string): name is FileChangeEvent['kind'] =>
+        FORWARDED_EVENTS.has(name as FileChangeEvent['kind']);
+
+      const onAll = (eventName: string, path: string) => {
+        if (!isForwardedEvent(eventName)) {
+          return;
+        }
+        handler({ kind: eventName, path: normalize(path) });
+      };
+      server.watcher.on('all', onAll);
+      return () => {
+        server.watcher.off('all', onAll);
+      };
+    },
+  };
+}
diff --git a/code/builders/builder-vite/src/index.test.ts b/code/builders/builder-vite/src/index.test.ts
deleted file mode 100644
index 714ce9dddece..000000000000
--- a/code/builders/builder-vite/src/index.test.ts
+++ /dev/null
@@ -1,414 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { logger } from 'storybook/internal/node-logger';
-import type { ModuleNode as StorybookModuleNode, Options } from 'storybook/internal/types';
-import type { ViteDevServer } from 'vite';
-
-import { bail, onModuleGraphChange, start } from './index.ts';
-import { createViteServer } from './vite-server.ts';
-
-vi.mock('storybook/internal/node-logger', { spy: true });
-vi.mock('./vite-server', { spy: true });
-
-type ViteModuleNodeLike = {
-  file: string | null;
-  type: StorybookModuleNode['type'];
-  importers: Set<ViteModuleNodeLike>;
-  importedModules: Set<ViteModuleNodeLike>;
-};
-
-function createViteModuleNode(
-  file: string | null,
-  type: StorybookModuleNode['type'] = 'js'
-): ViteModuleNodeLike {
-  return {
-    file,
-    type,
-    importers: new Set(),
-    importedModules: new Set(),
-  };
-}
-
-function createFileToModulesMap(...entries: Array<[string, Set<ViteModuleNodeLike>]>) {
-  return new Map(entries) as ViteDevServer['moduleGraph']['fileToModulesMap'];
-}
-
-type WatcherHandler = (...args: unknown[]) => void;
-type FakeWatcher = {
-  on: ReturnType<typeof vi.fn>;
-  off: ReturnType<typeof vi.fn>;
-  emit: (event: string, ...args: unknown[]) => void;
-  listenerCount: (event: string) => number;
-};
-
-function createFakeViteServer() {
-  const watcherListeners = new Map<string, Set<WatcherHandler>>();
-  const watcher = {} as FakeWatcher;
-
-  watcher.on = vi.fn((event: string, handler: WatcherHandler) => {
-    const handlers = watcherListeners.get(event) ?? new Set<WatcherHandler>();
-    handlers.add(handler);
-    watcherListeners.set(event, handlers);
-    return watcher;
-  });
-  watcher.off = vi.fn((event: string, handler: WatcherHandler) => {
-    watcherListeners.get(event)?.delete(handler);
-    return watcher;
-  });
-  watcher.emit = (event: string, ...args: unknown[]) => {
-    watcherListeners.get(event)?.forEach((handler) => {
-      handler(...args);
-    });
-    watcherListeners.get('all')?.forEach((handler) => {
-      handler(event, ...args);
-    });
-  };
-  watcher.listenerCount = (event: string) => watcherListeners.get(event)?.size ?? 0;
-
-  return {
-    watcher,
-    moduleGraph: {
-      fileToModulesMap: createFileToModulesMap(),
-    },
-    middlewares: {
-      handle: vi.fn(),
-    },
-    warmupRequest: vi.fn().mockResolvedValue(undefined),
-    transformIndexHtml: vi.fn().mockResolvedValue(''),
-    waitForRequestsIdle: vi.fn().mockResolvedValue(undefined),
-    close: vi.fn().mockResolvedValue(undefined),
-  } as unknown as ViteDevServer & {
-    watcher: typeof watcher;
-  };
-}
-
-function createStartArgs(storyImportPaths: string[] = []): Parameters<typeof start>[0] {
-  const indexGenerator = {
-    getIndex: vi.fn().mockResolvedValue({
-      entries: Object.fromEntries(
-        storyImportPaths.map((importPath, index) => [`story-${index}`, { importPath }])
-      ),
-    }),
-  };
-
-  return {
-    startTime: process.hrtime(),
-    options: {
-      presets: {
-        apply: vi.fn().mockResolvedValue(indexGenerator),
-      },
-    } as unknown as Options,
-    router: {
-      get: vi.fn(),
-      use: vi.fn(),
-    } as unknown as Parameters<typeof start>[0]['router'],
-    server: {} as Parameters<typeof start>[0]['server'],
-    channel: {} as Parameters<typeof start>[0]['channel'],
-  };
-}
-
-describe('onModuleGraphChange', () => {
-  let fakeViteServer: ReturnType<typeof createFakeViteServer>;
-
-  async function startChangeDetection(
-    fileToModulesMap = createFileToModulesMap([
-      '/src/Button.tsx',
-      new Set([createViteModuleNode('/src/Button.tsx')]),
-    ])
-  ) {
-    fakeViteServer.moduleGraph.fileToModulesMap = fileToModulesMap;
-    await start(createStartArgs([...fileToModulesMap.keys()]));
-    await vi.advanceTimersByTimeAsync(1000);
-  }
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    fakeViteServer = createFakeViteServer();
-    vi.mocked(createViteServer).mockResolvedValue(fakeViteServer);
-    vi.mocked(logger.error).mockImplementation(() => undefined);
-  });
-
-  afterEach(async () => {
-    await bail();
-    vi.useRealTimers();
-    vi.clearAllMocks();
-  });
-
-  it('registers callbacks and unsubscribes them', async () => {
-    const cb = vi.fn();
-    const unsubscribe = onModuleGraphChange(cb);
-
-    expect(unsubscribe).toEqual(expect.any(Function));
-
-    await startChangeDetection();
-    cb.mockClear();
-
-    fakeViteServer.watcher.emit('change', '/src/Button.tsx');
-
-    await vi.advanceTimersByTimeAsync(100);
-
-    expect(cb).toHaveBeenCalledTimes(1);
-
-    unsubscribe();
-
-    fakeViteServer.watcher.emit('change', '/src/Button.tsx');
-    await vi.advanceTimersByTimeAsync(100);
-
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-
-  it('passes the module graph payload to listeners', async () => {
-    const entry = createViteModuleNode('/src/Button.tsx');
-    const fileToModulesMap = createFileToModulesMap(['/src/Button.tsx', new Set([entry])]);
-
-    const cb = vi.fn();
-    onModuleGraphChange(cb);
-
-    await startChangeDetection(fileToModulesMap);
-    cb.mockClear();
-
-    fakeViteServer.watcher.emit('change', '/src/Button.tsx');
-
-    await vi.advanceTimersByTimeAsync(100);
-
-    const event = cb.mock.calls[0]?.[0];
-    const moduleGraph = event?.moduleGraph;
-
-    expect(cb).toHaveBeenCalledWith({
-      type: 'moduleGraph',
-      moduleGraph: expect.any(Map),
-    });
-    expect(moduleGraph?.has('/src/Button.tsx')).toBe(true);
-  });
-
-  it('triggers change events after the debounce delay', async () => {
-    const cb = vi.fn();
-    onModuleGraphChange(cb);
-
-    await startChangeDetection();
-    cb.mockClear();
-
-    fakeViteServer.watcher.emit('change', '/src/Button.tsx');
-
-    await vi.advanceTimersByTimeAsync(50);
-    expect(cb).not.toHaveBeenCalled();
-
-    await vi.advanceTimersByTimeAsync(50);
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-
-  it('triggers add events after the debounce delay', async () => {
-    const cb = vi.fn();
-    onModuleGraphChange(cb);
-
-    await startChangeDetection();
-    cb.mockClear();
-
-    fakeViteServer.watcher.emit('add', '/src/Button.tsx');
-
-    await vi.advanceTimersByTimeAsync(100);
-
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-
-  it('triggers unlink events after the debounce delay', async () => {
-    const cb = vi.fn();
-    onModuleGraphChange(cb);
-
-    await startChangeDetection();
-    cb.mockClear();
-
-    fakeViteServer.watcher.emit('unlink', '/src/Button.tsx');
-
-    await vi.advanceTimersByTimeAsync(100);
-
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-
-  it('debounces multiple rapid events into a single callback', async () => {
-    const cb = vi.fn();
-    onModuleGraphChange(cb);
-
-    await startChangeDetection();
-    cb.mockClear();
-
-    fakeViteServer.watcher.emit('change', '/src/Button.tsx');
-    fakeViteServer.watcher.emit('add', '/src/Button.tsx');
-    fakeViteServer.watcher.emit('change', '/src/Button.tsx');
-
-    await vi.advanceTimersByTimeAsync(100);
-
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-
-  it('notifies multiple listeners', async () => {
-    const cb1 = vi.fn();
-    const cb2 = vi.fn();
-
-    onModuleGraphChange(cb1);
-    onModuleGraphChange(cb2);
-
-    await startChangeDetection();
-    cb1.mockClear();
-    cb2.mockClear();
-
-    fakeViteServer.watcher.emit('change', '/src/Button.tsx');
-
-    await vi.advanceTimersByTimeAsync(100);
-
-    expect(cb1).toHaveBeenCalledTimes(1);
-    expect(cb2).toHaveBeenCalledTimes(1);
-  });
-
-  it('removes the all-event watcher during bail to avoid leaks across restarts', async () => {
-    const cb = vi.fn();
-    onModuleGraphChange(cb);
-
-    await startChangeDetection();
-    expect(fakeViteServer.watcher.listenerCount('all')).toBe(1);
-
-    await bail();
-    expect(fakeViteServer.watcher.listenerCount('all')).toBe(0);
-
-    await start(createStartArgs(['/src/Button.tsx']));
-    await vi.advanceTimersByTimeAsync(1000);
-    expect(fakeViteServer.watcher.listenerCount('all')).toBe(0);
-
-    fakeViteServer.watcher.emit('change', '/src/Button.tsx');
-    await vi.advanceTimersByTimeAsync(100);
-
-    expect(cb).not.toHaveBeenCalled();
-    expect(fakeViteServer.watcher.off).toHaveBeenCalledWith('all', expect.any(Function));
-  });
-
-  it('clears the module-graph polling interval during bail', async () => {
-    onModuleGraphChange(vi.fn());
-
-    await start(createStartArgs());
-    await vi.advanceTimersByTimeAsync(0);
-
-    expect(vi.getTimerCount()).toBe(1);
-
-    await bail();
-
-    fakeViteServer.moduleGraph.fileToModulesMap = createFileToModulesMap([
-      '/src/Button.tsx',
-      new Set([createViteModuleNode('/src/Button.tsx')]),
-    ]);
-
-    await vi.advanceTimersByTimeAsync(1000);
-
-    expect(vi.getTimerCount()).toBe(0);
-    expect(fakeViteServer.waitForRequestsIdle).not.toHaveBeenCalled();
-  });
-
-  it('allows listeners registered after start and runs change detection', async () => {
-    await start(createStartArgs(['/src/Button.tsx']));
-    await vi.advanceTimersByTimeAsync(1000);
-
-    fakeViteServer.moduleGraph.fileToModulesMap = createFileToModulesMap([
-      '/src/Button.tsx',
-      new Set([createViteModuleNode('/src/Button.tsx')]),
-    ]);
-
-    const cb = vi.fn();
-    onModuleGraphChange(cb);
-    await vi.advanceTimersByTimeAsync(1000);
-
-    cb.mockClear();
-    fakeViteServer.watcher.emit('change', '/src/Button.tsx');
-    await vi.advanceTimersByTimeAsync(100);
-
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not reattach the watcher if bail runs while waiting for idle requests', async () => {
-    const cb = vi.fn();
-    onModuleGraphChange(cb);
-
-    let resolveIdle: (() => void) | undefined;
-    fakeViteServer.moduleGraph.fileToModulesMap = createFileToModulesMap([
-      '/src/Button.tsx',
-      new Set([createViteModuleNode('/src/Button.tsx')]),
-    ]);
-    fakeViteServer.waitForRequestsIdle = vi.fn().mockImplementation(
-      () =>
-        new Promise<void>((resolve) => {
-          resolveIdle = resolve;
-        })
-    );
-
-    await start(createStartArgs(['/src/Button.tsx']));
-    await vi.advanceTimersByTimeAsync(1000);
-
-    await bail();
-    resolveIdle?.();
-    await Promise.resolve();
-    await Promise.resolve();
-
-    expect(fakeViteServer.watcher.listenerCount('all')).toBe(0);
-    expect(fakeViteServer.watcher.on).not.toHaveBeenCalledWith('all', expect.any(Function));
-    expect(cb).not.toHaveBeenCalled();
-  });
-
-  it('logs and swallows rejected startup work', async () => {
-    const cb = vi.fn();
-    onModuleGraphChange(cb);
-
-    const args = createStartArgs();
-    vi.mocked(args.options.presets.apply).mockResolvedValue({
-      getIndex: vi.fn().mockRejectedValue(new Error('index failed')),
-    } as never);
-
-    await expect(start(args)).resolves.toBeDefined();
-    await Promise.resolve();
-
-    expect(logger.error).toHaveBeenCalledWith('Failed to initialize Vite change detection');
-    expect(logger.error).toHaveBeenCalledWith(expect.objectContaining({ message: 'index failed' }));
-    expect(cb).toHaveBeenCalledWith({
-      type: 'error',
-      error: expect.objectContaining({ message: 'index failed' }),
-    });
-    expect(vi.getTimerCount()).toBe(0);
-  });
-
-  it('logs polling failures and clears the interval', async () => {
-    const cb = vi.fn();
-    onModuleGraphChange(cb);
-    fakeViteServer.moduleGraph.fileToModulesMap = createFileToModulesMap([
-      '/src/Button.tsx',
-      new Set([createViteModuleNode('/src/Button.tsx')]),
-    ]);
-    fakeViteServer.waitForRequestsIdle = vi.fn().mockRejectedValue(new Error('idle failed'));
-
-    await start(createStartArgs(['/src/Button.tsx']));
-    await vi.advanceTimersByTimeAsync(1000);
-
-    expect(logger.error).toHaveBeenCalledWith('Failed to complete Vite change detection startup');
-    expect(logger.error).toHaveBeenCalledWith(expect.objectContaining({ message: 'idle failed' }));
-    expect(cb).toHaveBeenCalledWith({
-      type: 'error',
-      error: expect.objectContaining({ message: 'idle failed' }),
-    });
-    expect(vi.getTimerCount()).toBe(0);
-    expect(fakeViteServer.watcher.listenerCount('all')).toBe(0);
-  });
-
-  it('notifies listeners when module graph startup times out', async () => {
-    const cb = vi.fn();
-    onModuleGraphChange(cb);
-
-    await start(createStartArgs(['/src/Button.tsx']));
-    await vi.advanceTimersByTimeAsync(31_000);
-
-    expect(logger.error).toHaveBeenCalledWith('Failed to complete Vite change detection startup');
-    expect(cb).toHaveBeenCalledWith({
-      type: 'unavailable',
-      reason: 'Timed out while waiting for the Vite module graph to initialize',
-      error: expect.objectContaining({
-        message: 'Timed out while waiting for the Vite module graph to initialize',
-      }),
-    });
-    expect(vi.getTimerCount()).toBe(0);
-  });
-});
diff --git a/code/builders/builder-vite/src/index.ts b/code/builders/builder-vite/src/index.ts
index 13634fd352da..028c344674c0 100644
--- a/code/builders/builder-vite/src/index.ts
+++ b/code/builders/builder-vite/src/index.ts
@@ -2,23 +2,15 @@
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 
-import { logger } from 'storybook/internal/node-logger';
 import { NoStatsForViteDevError } from 'storybook/internal/server-errors';
-import type { StoryIndexGenerator } from 'storybook/internal/core-server';
-import type {
-  Builder,
-  Middleware,
-  ModuleGraph,
-  ModuleGraphChangeEvent,
-  Options,
-} from 'storybook/internal/types';
+import type { Builder, Middleware, Options } from 'storybook/internal/types';
 
 import type { ViteDevServer } from 'vite';
 
 import { build as viteBuild } from './build.ts';
+import { createViteChangeDetectionAdapter } from './change-detection-adapter/index.ts';
 import type { ViteBuilder } from './types.ts';
 import { createViteServer } from './vite-server.ts';
-import { buildModuleGraph } from './utils/build-module-graph.ts';
 
 export { withoutVitePlugins } from './utils/without-vite-plugins.ts';
 export { hasVitePlugins } from './utils/has-vite-plugins.ts';
@@ -42,142 +34,25 @@ function iframeHandler(options: Options, server: ViteDevServer): Middleware {
 }
 
 let server: ViteDevServer;
-let lastBuilderOptions: Options | undefined;
-const listeners = new Set<(event: ModuleGraphChangeEvent) => void>();
-let debounce: ReturnType<typeof setTimeout> | undefined;
-let watcherChangeHandler: (() => void) | undefined;
-let waitForModuleGraph: ReturnType<typeof setInterval> | undefined;
-let moduleGraphTrackingStarted = false;
-
-function clearModuleGraphPolling(): void {
-  if (waitForModuleGraph) {
-    clearInterval(waitForModuleGraph);
-    waitForModuleGraph = undefined;
-  }
-}
-
-function notifyListeners(moduleGraph: ModuleGraph): void {
-  listeners.forEach((listener) => {
-    listener({ type: 'moduleGraph', moduleGraph });
-  });
-}
-
-function notifyListenersOfStartupFailure(
-  event: Extract<ModuleGraphChangeEvent, { type: 'unavailable' | 'error' }>
-): void {
-  listeners.forEach((listener) => {
-    listener(event);
-  });
-}
 
 export async function bail(): Promise<void> {
-  if (watcherChangeHandler) {
-    server?.watcher.off('all', watcherChangeHandler);
-    watcherChangeHandler = undefined;
-  }
-
-  clearModuleGraphPolling();
-
-  if (debounce) {
-    clearTimeout(debounce);
-    debounce = undefined;
-  }
-
-  moduleGraphTrackingStarted = false;
-  lastBuilderOptions = undefined;
-  listeners.clear();
   return server?.close();
 }
 
-function startModuleGraphTracking(): void {
-  if (moduleGraphTrackingStarted || listeners.size === 0 || !server || !lastBuilderOptions) {
-    return;
+/**
+ * Returns a {@link ChangeDetectionAdapter} bound to the Vite dev server created by `start()`.
+ *
+ * Throws if called before `start()` has resolved (i.e. before the Vite dev server exists).
+ */
+export const changeDetectionAdapter: NonNullable<
+  Builder<Options>['changeDetectionAdapter']
+> = () => {
+  if (!server) {
+    throw new Error(
+      'builder-vite: changeDetectionAdapter() called before start(); the Vite dev server is not ready yet.'
+    );
   }
-
-  moduleGraphTrackingStarted = true;
-
-  // Debounce handler to prevent multiple callback invocations when multiple files are edited
-  watcherChangeHandler = () => {
-    clearTimeout(debounce);
-    debounce = setTimeout(() => {
-      notifyListeners(buildModuleGraph(server.moduleGraph.fileToModulesMap));
-    }, 100);
-  };
-
-  startChangeDetection(lastBuilderOptions).catch((error) => {
-    clearModuleGraphPolling();
-    logger.error('Failed to initialize Vite change detection');
-    logger.error(error instanceof Error ? error : String(error));
-    notifyListenersOfStartupFailure({
-      type: 'error',
-      error: error instanceof Error ? error : new Error(String(error)),
-    });
-  });
-}
-
-export const onModuleGraphChange: NonNullable<Builder<Options>['onModuleGraphChange']> = (cb) => {
-  listeners.add(cb);
-  startModuleGraphTracking();
-
-  return () => {
-    listeners.delete(cb);
-  };
-};
-
-const startChangeDetection = async (options: Options) => {
-  const startTime = process.hrtime();
-  const indexGenerator = await options.presets.apply<StoryIndexGenerator>('storyIndexGenerator');
-  const storyIndex = await indexGenerator.getIndex();
-  const importPaths = new Set(Object.values(storyIndex.entries).map((entry) => entry.importPath));
-
-  // Warm up the module graph for all story files
-  await Promise.all(Array.from(importPaths, (importPath) => server.warmupRequest(importPath)));
-
-  // Wait for the module graph to be ready by polling for it to be non-empty
-  waitForModuleGraph = setInterval(() => {
-    void (async () => {
-      try {
-        if (!watcherChangeHandler) {
-          clearModuleGraphPolling();
-          return;
-        }
-
-        if (process.hrtime(startTime)[0] > 30) {
-          clearModuleGraphPolling();
-          const error = new Error(
-            'Timed out while waiting for the Vite module graph to initialize'
-          );
-          logger.error('Failed to complete Vite change detection startup');
-          logger.error(error);
-          notifyListenersOfStartupFailure({
-            type: 'unavailable',
-            reason: error.message,
-            error,
-          });
-          return;
-        }
-
-        if (server.moduleGraph.fileToModulesMap.size > 0) {
-          clearModuleGraphPolling();
-          await server.waitForRequestsIdle();
-          if (!watcherChangeHandler) {
-            return;
-          }
-
-          server.watcher.on('all', watcherChangeHandler);
-          watcherChangeHandler();
-        }
-      } catch (error) {
-        clearModuleGraphPolling();
-        logger.error('Failed to complete Vite change detection startup');
-        logger.error(error instanceof Error ? error : String(error));
-        notifyListenersOfStartupFailure({
-          type: 'error',
-          error: error instanceof Error ? error : new Error(String(error)),
-        });
-      }
-    })();
-  }, 1000);
+  return createViteChangeDetectionAdapter(server);
 };
 
 export const start: ViteBuilder['start'] = async ({
@@ -186,14 +61,11 @@ export const start: ViteBuilder['start'] = async ({
   router,
   server: devServer,
 }) => {
-  lastBuilderOptions = options as Options;
   server = await createViteServer(options as Options, devServer);
 
   router.get('/iframe.html', iframeHandler(options as Options, server));
   router.use(server.middlewares);
 
-  startModuleGraphTracking();
-
   return {
     bail,
     stats: {
diff --git a/code/builders/builder-vite/src/utils/build-module-graph.test.ts b/code/builders/builder-vite/src/utils/build-module-graph.test.ts
deleted file mode 100644
index 9545b7b434e8..000000000000
--- a/code/builders/builder-vite/src/utils/build-module-graph.test.ts
+++ /dev/null
@@ -1,153 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import type { ModuleNode as StorybookModuleNode } from 'storybook/internal/types';
-import type { ViteDevServer } from 'vite';
-
-import { buildModuleGraph } from './build-module-graph.ts';
-
-vi.mock('./vite-server', () => ({
-  createViteServer: vi.fn(),
-}));
-
-type ViteModuleNodeLike = {
-  file: string | null;
-  type: StorybookModuleNode['type'];
-  importers: Set<ViteModuleNodeLike>;
-  importedModules: Set<ViteModuleNodeLike>;
-};
-
-function createViteModuleNode(
-  file: string | null,
-  type: StorybookModuleNode['type'] = 'js'
-): ViteModuleNodeLike {
-  return {
-    file,
-    type,
-    importers: new Set(),
-    importedModules: new Set(),
-  };
-}
-
-function createFileToModulesMap(...entries: Array<[string, Set<ViteModuleNodeLike>]>) {
-  return new Map(entries) as ViteDevServer['moduleGraph']['fileToModulesMap'];
-}
-
-function getFirstNode(
-  file: string,
-  moduleGraph: ReturnType<typeof buildModuleGraph>
-): StorybookModuleNode {
-  const moduleNode = moduleGraph.get(file)?.values().next().value;
-  if (!moduleNode) {
-    throw new Error(`Expected module node for ${file}`);
-  }
-  return moduleNode;
-}
-
-describe('buildModuleGraph', () => {
-  it('converts vite module nodes into the shared module graph shape', () => {
-    const entry = createViteModuleNode('/src/entry.ts');
-    const component = createViteModuleNode('/src/component.ts');
-    const styles = createViteModuleNode('/src/component.css', 'css');
-
-    entry.importedModules.add(component);
-    component.importers.add(entry);
-    component.importedModules.add(styles);
-    styles.importers.add(component);
-
-    const moduleGraph = buildModuleGraph(
-      createFileToModulesMap(
-        ['/src/entry.ts', new Set([entry])],
-        ['/src/component.ts', new Set([component])],
-        ['/src/component.css', new Set([styles])]
-      )
-    );
-
-    const entryNode = getFirstNode('/src/entry.ts', moduleGraph);
-    const componentNode = getFirstNode('/src/component.ts', moduleGraph);
-    const styleNode = getFirstNode('/src/component.css', moduleGraph);
-
-    expect(entryNode.file).toBe('/src/entry.ts');
-    expect(componentNode.type).toBe('js');
-    expect(styleNode.type).toBe('css');
-
-    expect(entryNode.importedModules).toEqual(new Set([componentNode]));
-    expect(componentNode.importers).toEqual(new Set([entryNode]));
-    expect(componentNode.importedModules).toEqual(new Set([styleNode]));
-    expect(styleNode.importers).toEqual(new Set([componentNode]));
-  });
-
-  it('reuses the same converted node identity across relationships', () => {
-    const shared = createViteModuleNode('/src/shared.ts');
-    const importerA = createViteModuleNode('/src/a.ts');
-    const importerB = createViteModuleNode('/src/b.ts');
-
-    importerA.importedModules.add(shared);
-    importerB.importedModules.add(shared);
-    shared.importers.add(importerA);
-    shared.importers.add(importerB);
-
-    const moduleGraph = buildModuleGraph(
-      createFileToModulesMap(
-        ['/src/shared.ts', new Set([shared])],
-        ['/src/a.ts', new Set([importerA])],
-        ['/src/b.ts', new Set([importerB])]
-      )
-    );
-
-    const sharedNode = getFirstNode('/src/shared.ts', moduleGraph);
-    const importerANode = getFirstNode('/src/a.ts', moduleGraph);
-    const importerBNode = getFirstNode('/src/b.ts', moduleGraph);
-
-    expect(importerANode.importedModules.has(sharedNode)).toBe(true);
-    expect(importerBNode.importedModules.has(sharedNode)).toBe(true);
-    expect(sharedNode.importers).toEqual(new Set([importerANode, importerBNode]));
-  });
-
-  it('skips related vite module nodes without a file', () => {
-    const entry = createViteModuleNode('/src/entry.ts');
-    const virtualModule = createViteModuleNode(null);
-
-    entry.importedModules.add(virtualModule);
-    virtualModule.importers.add(entry);
-
-    const moduleGraph = buildModuleGraph(
-      createFileToModulesMap(['/src/entry.ts', new Set([entry])])
-    );
-    const entryNode = getFirstNode('/src/entry.ts', moduleGraph);
-
-    expect(moduleGraph.size).toBe(1);
-    expect(entryNode.importedModules.size).toBe(0);
-  });
-
-  it('preserves edges for related vite module nodes discovered before their file path is known', () => {
-    const entry = createViteModuleNode('/src/entry.ts');
-    const component = createViteModuleNode(null);
-
-    entry.importedModules.add(component);
-    component.importers.add(entry);
-
-    const moduleGraph = buildModuleGraph(
-      createFileToModulesMap(
-        ['/src/entry.ts', new Set([entry])],
-        ['/src/component.ts', new Set([component])]
-      )
-    );
-
-    const entryNode = getFirstNode('/src/entry.ts', moduleGraph);
-    const componentNode = getFirstNode('/src/component.ts', moduleGraph);
-
-    expect(entryNode.importedModules).toEqual(new Set([componentNode]));
-    expect(componentNode.importers).toEqual(new Set([entryNode]));
-  });
-
-  it('keeps multiple module identities for the same file', () => {
-    const clientModule = createViteModuleNode('/src/shared.ts');
-    const ssrModule = createViteModuleNode('/src/shared.ts');
-
-    const moduleGraph = buildModuleGraph(
-      createFileToModulesMap(['/src/shared.ts', new Set([clientModule, ssrModule])])
-    );
-
-    expect(moduleGraph.get('/src/shared.ts')?.size).toBe(2);
-  });
-});
diff --git a/code/builders/builder-vite/src/utils/build-module-graph.ts b/code/builders/builder-vite/src/utils/build-module-graph.ts
deleted file mode 100644
index 4d14235bd88e..000000000000
--- a/code/builders/builder-vite/src/utils/build-module-graph.ts
+++ /dev/null
@@ -1,82 +0,0 @@
-import type { ModuleGraph, ModuleNode } from 'storybook/internal/types';
-
-import type { ViteDevServer, ModuleNode as ViteModuleNode } from 'vite';
-
-export function buildModuleGraph(
-  fileToModulesMap: ViteDevServer['moduleGraph']['fileToModulesMap']
-): ModuleGraph {
-  const moduleGraph: ModuleGraph = new Map();
-  const moduleNodeMap = new WeakMap<object, ModuleNode>();
-  const getModuleFileFromMap = (viteModuleNode: {
-    file: string | null;
-    type: ViteModuleNode['type'];
-    importers: Set<ViteModuleNode>;
-    importedModules: Set<ViteModuleNode>;
-  }): string | undefined => {
-    for (const [filePath, viteModuleSet] of fileToModulesMap.entries()) {
-      if (viteModuleSet.has(viteModuleNode as ViteModuleNode)) {
-        return filePath;
-      }
-    }
-  };
-
-  const getOrCreateModuleNode = (
-    viteModuleNode: {
-      file: string | null;
-      type: ViteModuleNode['type'];
-      importers: Set<ViteModuleNode>;
-      importedModules: Set<ViteModuleNode>;
-    },
-    fallbackFile?: string
-  ): ModuleNode | undefined => {
-    const file = viteModuleNode.file ?? fallbackFile;
-    if (!file) {
-      return undefined;
-    }
-
-    const existingNode = moduleNodeMap.get(viteModuleNode);
-    if (existingNode) {
-      return existingNode;
-    }
-
-    const moduleNode: ModuleNode = {
-      file,
-      type: viteModuleNode.type,
-      importers: new Set(),
-      importedModules: new Set(),
-    };
-    moduleNodeMap.set(viteModuleNode, moduleNode);
-
-    const moduleSet = moduleGraph.get(file) ?? new Set<ModuleNode>();
-    moduleSet.add(moduleNode);
-    moduleGraph.set(file, moduleSet);
-
-    return moduleNode;
-  };
-
-  fileToModulesMap.forEach((viteModuleSet, filePath) => {
-    viteModuleSet.forEach((viteModuleNode) => {
-      const moduleNode = getOrCreateModuleNode(viteModuleNode, filePath);
-      if (moduleNode) {
-        viteModuleNode.importers.forEach((importer) => {
-          const importerNode =
-            getOrCreateModuleNode(importer) ??
-            getOrCreateModuleNode(importer, getModuleFileFromMap(importer));
-          if (importerNode) {
-            moduleNode.importers.add(importerNode);
-          }
-        });
-        viteModuleNode.importedModules.forEach((importedModule) => {
-          const importedModuleNode =
-            getOrCreateModuleNode(importedModule) ??
-            getOrCreateModuleNode(importedModule, getModuleFileFromMap(importedModule));
-          if (importedModuleNode) {
-            moduleNode.importedModules.add(importedModuleNode);
-          }
-        });
-      }
-    });
-  });
-
-  return moduleGraph;
-}
diff --git a/code/builders/builder-webpack5/src/change-detection-adapter/index.test.ts b/code/builders/builder-webpack5/src/change-detection-adapter/index.test.ts
new file mode 100644
index 000000000000..d20e2330d026
--- /dev/null
+++ b/code/builders/builder-webpack5/src/change-detection-adapter/index.test.ts
@@ -0,0 +1,215 @@
+// Tests the webpack implementation of ChangeDetectionAdapter — resolve-config extraction
+// and watchRun-based file-change event normalisation.
+import { describe, expect, it, vi } from 'vitest';
+
+import { createWebpackChangeDetectionAdapter } from './index.ts';
+
+interface FakeTapable {
+  tap(pluginName: string, fn: (compiler: FakeCompiler) => void): void;
+}
+
+interface FakeCompiler {
+  context: string;
+  options: {
+    resolve: {
+      alias?: unknown;
+      conditionNames?: string[];
+    };
+  };
+  hooks: {
+    watchRun: FakeTapable;
+  };
+  modifiedFiles?: ReadonlySet<string>;
+  removedFiles?: ReadonlySet<string>;
+}
+
+function createFakeCompiler(overrides: Partial<FakeCompiler> = {}): {
+  compiler: FakeCompiler;
+  triggerWatchRun: (modifiedFiles?: string[], removedFiles?: string[]) => void;
+} {
+  let watchRunCallback: ((c: FakeCompiler) => void) | undefined;
+
+  const compiler: FakeCompiler = {
+    context: '/repo',
+    options: {
+      resolve: {},
+    },
+    hooks: {
+      watchRun: {
+        tap(_pluginName, fn) {
+          watchRunCallback = fn;
+        },
+      },
+    },
+    ...overrides,
+  };
+
+  function triggerWatchRun(modifiedFiles: string[] = [], removedFiles: string[] = []): void {
+    const ctx: FakeCompiler = {
+      ...compiler,
+      modifiedFiles: new Set(modifiedFiles),
+      removedFiles: new Set(removedFiles),
+    };
+    watchRunCallback?.(ctx);
+  }
+
+  return { compiler, triggerWatchRun };
+}
+
+describe('createWebpackChangeDetectionAdapter', () => {
+  describe('getResolveConfig()', () => {
+    it('returns projectRoot from compiler.context', async () => {
+      const { compiler } = createFakeCompiler({ context: '/my/project' });
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const config = await adapter.getResolveConfig();
+      expect(config.projectRoot).toBe('/my/project');
+    });
+
+    it('returns conditions from resolve.conditionNames', async () => {
+      const { compiler } = createFakeCompiler({
+        options: { resolve: { conditionNames: ['import', 'module'] } },
+      });
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const config = await adapter.getResolveConfig();
+      expect(config.conditions).toEqual(['import', 'module']);
+    });
+
+    it('normalises object-form alias to Record<string, string>', async () => {
+      const { compiler } = createFakeCompiler({
+        options: {
+          resolve: {
+            alias: {
+              '@': '/repo/src',
+              utils: '/repo/utils',
+              disabled: false,
+              multi: ['/repo/multi-a', '/repo/multi-b'],
+            },
+          },
+        },
+      });
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const config = await adapter.getResolveConfig();
+      expect(config.alias).toEqual({
+        '@': '/repo/src',
+        utils: '/repo/utils',
+        multi: '/repo/multi-a',
+        // `disabled: false` is skipped
+      });
+    });
+
+    it('normalises array-form alias to Array<{ find, replacement }>', async () => {
+      const { compiler } = createFakeCompiler({
+        options: {
+          resolve: {
+            alias: [
+              { name: '@', alias: '/repo/src' },
+              { name: 'utils', alias: ['/repo/utils-a'] },
+              { name: 'gone', alias: false },
+            ],
+          },
+        },
+      });
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const config = await adapter.getResolveConfig();
+      expect(config.alias).toEqual([
+        { find: '@', replacement: '/repo/src' },
+        { find: 'utils', replacement: '/repo/utils-a' },
+        // `gone: false` is skipped
+      ]);
+    });
+
+    it('returns undefined alias when resolve has no alias', async () => {
+      const { compiler } = createFakeCompiler({ options: { resolve: {} } });
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const config = await adapter.getResolveConfig();
+      expect(config.alias).toBeUndefined();
+    });
+  });
+
+  describe('onFileChange()', () => {
+    it('emits kind:"add" for first-seen paths in modifiedFiles', () => {
+      const { compiler, triggerWatchRun } = createFakeCompiler();
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const handler = vi.fn();
+      adapter.onFileChange(handler);
+
+      triggerWatchRun(['/repo/src/A.tsx']);
+
+      expect(handler).toHaveBeenCalledWith({ kind: 'add', path: '/repo/src/A.tsx' });
+    });
+
+    it('emits kind:"change" for paths seen in a previous watchRun', () => {
+      const { compiler, triggerWatchRun } = createFakeCompiler();
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const handler = vi.fn();
+      adapter.onFileChange(handler);
+
+      triggerWatchRun(['/repo/src/A.tsx']); // first time → add
+      triggerWatchRun(['/repo/src/A.tsx']); // second time → change
+
+      expect(handler).toHaveBeenNthCalledWith(1, { kind: 'add', path: '/repo/src/A.tsx' });
+      expect(handler).toHaveBeenNthCalledWith(2, { kind: 'change', path: '/repo/src/A.tsx' });
+    });
+
+    it('emits kind:"unlink" for removedFiles and forgets the path', () => {
+      const { compiler, triggerWatchRun } = createFakeCompiler();
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const handler = vi.fn();
+      adapter.onFileChange(handler);
+
+      triggerWatchRun(['/repo/src/A.tsx']); // add
+      triggerWatchRun([], ['/repo/src/A.tsx']); // unlink
+
+      expect(handler).toHaveBeenNthCalledWith(2, { kind: 'unlink', path: '/repo/src/A.tsx' });
+    });
+
+    it('emits kind:"add" again after a path was unlinked and re-added', () => {
+      const { compiler, triggerWatchRun } = createFakeCompiler();
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const handler = vi.fn();
+      adapter.onFileChange(handler);
+
+      triggerWatchRun(['/repo/src/A.tsx']); // add
+      triggerWatchRun([], ['/repo/src/A.tsx']); // unlink
+      triggerWatchRun(['/repo/src/A.tsx']); // add again
+
+      expect(handler).toHaveBeenNthCalledWith(3, { kind: 'add', path: '/repo/src/A.tsx' });
+    });
+
+    it('normalises paths via pathe.normalize before forwarding', () => {
+      const { compiler, triggerWatchRun } = createFakeCompiler();
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const handler = vi.fn();
+      adapter.onFileChange(handler);
+
+      triggerWatchRun(['/repo/src/./A.tsx']);
+
+      expect(handler).toHaveBeenCalledWith({ kind: 'add', path: '/repo/src/A.tsx' });
+    });
+
+    it('does not emit events after the unsubscribe function is called', () => {
+      const { compiler, triggerWatchRun } = createFakeCompiler();
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const handler = vi.fn();
+      const unsubscribe = adapter.onFileChange(handler);
+
+      triggerWatchRun(['/repo/src/A.tsx']);
+      expect(handler).toHaveBeenCalledTimes(1);
+
+      unsubscribe();
+      triggerWatchRun(['/repo/src/B.tsx']);
+      expect(handler).toHaveBeenCalledTimes(1);
+    });
+
+    it('emits no events when modifiedFiles and removedFiles are empty', () => {
+      const { compiler, triggerWatchRun } = createFakeCompiler();
+      const adapter = createWebpackChangeDetectionAdapter(compiler as any);
+      const handler = vi.fn();
+      adapter.onFileChange(handler);
+
+      triggerWatchRun([], []);
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+  });
+});
diff --git a/code/builders/builder-webpack5/src/change-detection-adapter/index.ts b/code/builders/builder-webpack5/src/change-detection-adapter/index.ts
new file mode 100644
index 000000000000..244e056d439e
--- /dev/null
+++ b/code/builders/builder-webpack5/src/change-detection-adapter/index.ts
@@ -0,0 +1,95 @@
+import type {
+  ChangeDetectionAdapter,
+  FileChangeEvent,
+  ModuleResolveConfig,
+} from 'storybook/internal/core-server';
+
+import { normalize } from 'pathe';
+import type { Compiler } from 'webpack';
+
+/**
+ * Webpack implementation of {@link ChangeDetectionAdapter}.
+ *
+ * - `getResolveConfig()` reads `compiler.options.resolve` and `compiler.context` once at startup.
+ * - `onFileChange()` taps `compiler.hooks.watchRun` and forwards `modifiedFiles` as `add`/`change`
+ *   and `removedFiles` as `unlink` events. File kind (add vs change) is inferred by tracking which
+ *   paths webpack has reported at least once.
+ *
+ * Note: on first watch run `modifiedFiles` may be undefined (initial full build). Events are only
+ * emitted for subsequent incremental runs where webpack populates the sets.
+ */
+export function createWebpackChangeDetectionAdapter(compiler: Compiler): ChangeDetectionAdapter {
+  return {
+    async getResolveConfig(): Promise<ModuleResolveConfig> {
+      const resolveOpts = compiler.options.resolve;
+      return {
+        projectRoot: compiler.context,
+        alias: normaliseWebpackAlias(resolveOpts.alias),
+        conditions: resolveOpts.conditionNames,
+      };
+    },
+
+    onFileChange(handler: (event: FileChangeEvent) => void): () => void {
+      let active = true;
+      const seenFiles = new Set<string>();
+
+      compiler.hooks.watchRun.tap('StorybookChangeDetection', (watchingCompiler) => {
+        if (!active) return;
+
+        for (const filePath of watchingCompiler.modifiedFiles ?? []) {
+          const path = normalize(filePath);
+          const kind: FileChangeEvent['kind'] = seenFiles.has(path) ? 'change' : 'add';
+          seenFiles.add(path);
+          handler({ kind, path });
+        }
+
+        for (const filePath of watchingCompiler.removedFiles ?? []) {
+          const path = normalize(filePath);
+          seenFiles.delete(path);
+          handler({ kind: 'unlink', path });
+        }
+      });
+
+      return () => {
+        active = false;
+      };
+    },
+  };
+}
+
+type WebpackResolveAlias = NonNullable<
+  NonNullable<import('webpack').Configuration['resolve']>['alias']
+>;
+
+function normaliseWebpackAlias(
+  alias: WebpackResolveAlias | undefined
+): ModuleResolveConfig['alias'] | undefined {
+  if (!alias) return undefined;
+
+  if (Array.isArray(alias)) {
+    const entries: Array<{ find: string; replacement: string }> = [];
+    for (const entry of alias) {
+      const replacement =
+        typeof entry.alias === 'string'
+          ? entry.alias
+          : Array.isArray(entry.alias) && entry.alias.length > 0
+            ? entry.alias[0]
+            : null;
+      if (replacement != null) {
+        entries.push({ find: entry.name, replacement });
+      }
+    }
+    return entries.length > 0 ? entries : undefined;
+  }
+
+  const record: Record<string, string> = {};
+  for (const [key, value] of Object.entries(alias as Record<string, string | false | string[]>)) {
+    if (typeof value === 'string') {
+      record[key] = value;
+    } else if (Array.isArray(value) && value.length > 0) {
+      record[key] = value[0];
+    }
+    // false = disabled alias, skip
+  }
+  return Object.keys(record).length > 0 ? record : undefined;
+}
diff --git a/code/builders/builder-webpack5/src/index.ts b/code/builders/builder-webpack5/src/index.ts
index f4312b4c0939..042ffc24ab9a 100644
--- a/code/builders/builder-webpack5/src/index.ts
+++ b/code/builders/builder-webpack5/src/index.ts
@@ -20,6 +20,8 @@ import webpackModule from 'webpack';
 import webpackDevMiddleware from 'webpack-dev-middleware';
 import webpackHotMiddleware from 'webpack-hot-middleware';
 
+import { createWebpackChangeDetectionAdapter } from './change-detection-adapter/index.ts';
+
 export * from './types.ts';
 export * from './preview/virtual-module-mapping.ts';
 
@@ -38,6 +40,7 @@ const corePath = dirname(fileURLToPath(import.meta.resolve('storybook/package.js
 
 let compilation: ReturnType<typeof webpackDevMiddleware> | undefined;
 let reject: (reason?: any) => void;
+let activeCompiler: import('webpack').Compiler | undefined;
 
 type WebpackBuilder = Builder<Configuration, Stats>;
 type Unpromise<T extends Promise<any>> = T extends Promise<infer U> ? U : never;
@@ -97,7 +100,7 @@ export const bail: WebpackBuilder['bail'] = async () => {
     reject();
   }
   // we wait for the compiler to finish it's work, so it's command-line output doesn't interfere
-  return new Promise((res, rej) => {
+  await new Promise<void>((res, rej) => {
     if (process && compilation) {
       try {
         compilation.close(() => res());
@@ -110,6 +113,21 @@ export const bail: WebpackBuilder['bail'] = async () => {
       res();
     }
   });
+  activeCompiler = undefined;
+};
+
+/**
+ * Returns a {@link ChangeDetectionAdapter} bound to the webpack compiler created by `start()`.
+ *
+ * Throws if called before `start()` has resolved (i.e. before the compiler exists).
+ */
+export const changeDetectionAdapter: NonNullable<WebpackBuilder['changeDetectionAdapter']> = () => {
+  if (!activeCompiler) {
+    throw new Error(
+      'builder-webpack5: changeDetectionAdapter() called before start(); the webpack compiler is not ready yet.'
+    );
+  }
+  return createWebpackChangeDetectionAdapter(activeCompiler);
 };
 
 /**
@@ -143,6 +161,8 @@ const starter: StarterFunction = async function* starterGeneratorFn({
     });
   }
 
+  activeCompiler = compiler;
+
   yield;
   const modulesCount = await options.cache?.get('modulesCount', 1000);
   let totalModules: number;
diff --git a/code/core/build-config.ts b/code/core/build-config.ts
index e12d7c7ceba0..3d09dd7b6020 100644
--- a/code/core/build-config.ts
+++ b/code/core/build-config.ts
@@ -37,6 +37,14 @@ const config: BuildEntries = {
         entryPoint: './src/core-server/presets/common-preset.ts',
         dts: false,
       },
+      {
+        exportEntries: ['./internal/oxc-parser'],
+        entryPoint: './src/oxc-parser/index.ts',
+      },
+      {
+        entryPoint: './src/oxc-parser/worker.ts',
+        dts: false,
+      },
       {
         entryPoint: './src/core-server/presets/common-override-preset.ts',
         exportEntries: ['./internal/core-server/presets/common-override-preset'],
diff --git a/code/core/package.json b/code/core/package.json
index 8942e5d14aba..9f7ba65dfb16 100644
--- a/code/core/package.json
+++ b/code/core/package.json
@@ -151,6 +151,11 @@
       "code": "./src/node-logger/index.ts",
       "default": "./dist/node-logger/index.js"
     },
+    "./internal/oxc-parser": {
+      "types": "./dist/oxc-parser/index.d.ts",
+      "code": "./src/oxc-parser/index.ts",
+      "default": "./dist/oxc-parser/index.js"
+    },
     "./internal/preview-api": {
       "types": "./dist/preview-api/index.d.ts",
       "code": "./src/preview-api/index.ts",
@@ -237,6 +242,8 @@
     "@webcontainer/env": "^1.1.1",
     "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0",
     "open": "^10.2.0",
+    "oxc-parser": "^0.127.0",
+    "oxc-resolver": "^11.19.1",
     "recast": "^0.23.5",
     "semver": "^7.7.3",
     "use-sync-external-store": "^1.5.0",
diff --git a/code/core/src/common/versions.ts b/code/core/src/common/versions.ts
index 884ccaaf099d..bffe67fc061a 100644
--- a/code/core/src/common/versions.ts
+++ b/code/core/src/common/versions.ts
@@ -22,6 +22,7 @@ export default {
   '@storybook/server-webpack5': '10.4.0-alpha.16',
   '@storybook/svelte-vite': '10.4.0-alpha.16',
   '@storybook/sveltekit': '10.4.0-alpha.16',
+  '@storybook/tanstack-react': '10.4.0-alpha.16',
   '@storybook/vue3-vite': '10.4.0-alpha.16',
   '@storybook/web-components-vite': '10.4.0-alpha.16',
   sb: '10.4.0-alpha.16',
@@ -37,7 +38,6 @@ export default {
   '@storybook/preset-server-webpack': '10.4.0-alpha.16',
   '@storybook/html': '10.4.0-alpha.16',
   '@storybook/preact': '10.4.0-alpha.16',
-  '@storybook/tanstack-react': '10.4.0-alpha.16',
   '@storybook/react': '10.4.0-alpha.16',
   '@storybook/server': '10.4.0-alpha.16',
   '@storybook/svelte': '10.4.0-alpha.16',
diff --git a/code/core/src/core-server/change-detection/ChangeDetectionService.test.ts b/code/core/src/core-server/change-detection/ChangeDetectionService.test.ts
index 639a4141cb71..23574f05816f 100644
--- a/code/core/src/core-server/change-detection/ChangeDetectionService.test.ts
+++ b/code/core/src/core-server/change-detection/ChangeDetectionService.test.ts
@@ -1,16 +1,7 @@
-import { join } from 'pathe';
-
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { logger } from 'storybook/internal/node-logger';
-import type {
-  Builder,
-  ModuleGraph,
-  ModuleGraphChangeEvent,
-  ModuleNode,
-  Status,
-  StoryIndex,
-} from 'storybook/internal/types';
+import type { Status, StoryIndex } from 'storybook/internal/types';
 import { CHANGE_DETECTION_STATUS_TYPE_ID } from 'storybook/internal/types';
 
 import {
@@ -18,6 +9,7 @@ import {
   UNIVERSAL_STATUS_STORE_OPTIONS,
 } from '../../shared/status-store/index.ts';
 import { MockUniversalStore } from '../../shared/universal-store/mock.ts';
+import type { ChangeDetectionAdapter, FileChangeEvent } from './adapters/index.ts';
 import { getChangeDetectionReadiness, internal_resetChangeDetectionReadiness } from './index.ts';
 import { ChangeDetectionFailureError, ChangeDetectionUnavailableError } from './errors.ts';
 import {
@@ -26,11 +18,31 @@ import {
   mergeChangeDetectionStatuses,
   mergeStatusValues,
 } from './ChangeDetectionService.ts';
+import * as oxcParser from 'storybook/internal/oxc-parser';
+import {
+  ChangeDetectionResolverFactory,
+  DependencyGraphBuilder,
+  IncrementalPatcher,
+  ReverseIndexImpl,
+} from './dependency-graph/index.ts';
 import type { GitDiffResult } from './GitDiffProvider.ts';
 import { GitDiffProvider } from './GitDiffProvider.ts';
 import type { IndexBaselineService } from './IndexBaselineService.ts';
 
 vi.mock('storybook/internal/node-logger', { spy: true });
+vi.mock('./dependency-graph/index.ts', async (importOriginal) => {
+  // Keep ReverseIndexImpl + types real so tests can build synthetic indexes; replace the
+  // ChangeDetectionResolverFactory / DependencyGraphBuilder / IncrementalPatcher constructors
+  // with `vi.fn()`s so tests can override their behaviour per-case via
+  // `vi.mocked(Ctor).mockImplementation(...)`.
+  const actual = await importOriginal<typeof import('./dependency-graph/index.ts')>();
+  return {
+    ...actual,
+    ChangeDetectionResolverFactory: vi.fn(),
+    DependencyGraphBuilder: vi.fn(),
+    IncrementalPatcher: vi.fn(),
+  };
+});
 
 function createDeferred<T>() {
   let resolve!: (value: T) => void;
@@ -43,15 +55,6 @@ function createDeferred<T>() {
   };
 }
 
-function createModuleNode(file: string): ModuleNode {
-  return {
-    file,
-    type: 'js',
-    importers: new Set(),
-    importedModules: new Set(),
-  };
-}
-
 function createStoryIndex(
   entries: Array<{ storyId: string; importPath: string; title?: string; name?: string }>
 ): StoryIndex {
@@ -73,29 +76,50 @@ function createStoryIndex(
   };
 }
 
-function createBuilder() {
-  let onModuleGraphChange: ((event: ModuleGraphChangeEvent) => void) | undefined;
+interface MockAdapterHandle {
+  adapter: ChangeDetectionAdapter;
+  emitFileChange: (event: FileChangeEvent) => void;
+  emitStartupFailure: (event: { reason: string; error?: Error }) => void;
+  hasFileChangeSubscriber: () => boolean;
+  hasStartupFailureSubscriber: () => boolean;
+}
 
-  const builder = {
-    onModuleGraphChange: vi.fn((callback: (event: ModuleGraphChangeEvent) => void) => {
-      onModuleGraphChange = callback;
-      return vi.fn(() => {
-        onModuleGraphChange = undefined;
-      });
-    }),
-  } as unknown as Builder<unknown>;
+function createMockAdapter(opts?: {
+  resolveConfig?: { projectRoot?: string };
+  withoutStartupFailure?: boolean;
+}): MockAdapterHandle {
+  const fileHandlers = new Set<(e: FileChangeEvent) => void>();
+  const startupHandlers = new Set<(e: { reason: string; error?: Error }) => void>();
+
+  const adapter: ChangeDetectionAdapter = {
+    async getResolveConfig() {
+      return {
+        projectRoot: opts?.resolveConfig?.projectRoot ?? '/repo',
+      };
+    },
+    onFileChange(handler) {
+      fileHandlers.add(handler);
+      return () => fileHandlers.delete(handler);
+    },
+  };
+
+  if (!opts?.withoutStartupFailure) {
+    adapter.onStartupFailure = (handler) => {
+      startupHandlers.add(handler);
+      return () => startupHandlers.delete(handler);
+    };
+  }
 
   return {
-    builder,
-    emit(moduleGraph: ModuleGraph) {
-      onModuleGraphChange?.({ type: 'moduleGraph', moduleGraph });
+    adapter,
+    emitFileChange: (event) => {
+      fileHandlers.forEach((h) => h(event));
     },
-    emitUnavailable(reason: string, error?: Error) {
-      onModuleGraphChange?.({ type: 'unavailable', reason, error });
-    },
-    emitError(error: Error) {
-      onModuleGraphChange?.({ type: 'error', error });
+    emitStartupFailure: (event) => {
+      startupHandlers.forEach((h) => h(event));
     },
+    hasFileChangeSubscriber: () => fileHandlers.size > 0,
+    hasStartupFailureSubscriber: () => startupHandlers.size > 0,
   };
 }
 
@@ -114,6 +138,7 @@ class MockGitDiffProvider extends GitDiffProvider {
   });
   readonly isWorkingTreeCleanMock = vi.fn(async (): Promise<boolean> => true);
   readonly getHeadCommitMock = vi.fn(async (): Promise<string> => 'mock-sha');
+  readonly disposeMock = vi.fn(() => undefined);
 
   constructor() {
     super('/repo');
@@ -138,6 +163,10 @@ class MockGitDiffProvider extends GitDiffProvider {
   override getHeadCommit(): Promise<string> {
     return this.getHeadCommitMock();
   }
+
+  override dispose(): void {
+    this.disposeMock();
+  }
 }
 
 function createMockGitDiffProvider(configure?: (provider: MockGitDiffProvider) => void) {
@@ -168,6 +197,50 @@ function createStatus(value: Status['value'], data?: Status['data']): Status {
   };
 }
 
+/**
+ * Build a ReverseIndexImpl populated with the given (dep -> story -> depth) entries.
+ * Used by tests to control what `reverseIndex.lookup(changedFile)` returns.
+ */
+function buildReverseIndex(edges: Iterable<readonly [string, string, number]>): ReverseIndexImpl {
+  const reverseIndex = new ReverseIndexImpl();
+  for (const [dep, story, depth] of edges) {
+    reverseIndex.record(dep, story, depth);
+  }
+  return reverseIndex;
+}
+
+/**
+ * Stub the dependency-graph constructors so the service uses an in-test
+ * ReverseIndexImpl + an inert IncrementalPatcher.
+ *
+ * Note: `vi.mock` replaces these exports with plain `vi.fn()` constructors. When the
+ * service calls `new Ctor(...)` we must return objects via `mockImplementation` —
+ * but vitest invokes the impl with `Reflect.construct` on `new`, so arrow-function
+ * impls throw "is not a constructor". `function () { return obj; }` works because
+ * regular functions support `[[Construct]]`.
+ */
+function installDependencyGraphMocks(reverseIndex: ReverseIndexImpl): {
+  patchSpy: ReturnType<typeof vi.fn>;
+  buildSpy: ReturnType<typeof vi.fn>;
+} {
+  const patchSpy = vi.fn(async () => undefined);
+  const buildSpy = vi.fn(async () => ({ reverseIndex, graph: new Map() }));
+
+  vi.mocked(ChangeDetectionResolverFactory).mockImplementation(function () {
+    return {
+      resolve: vi.fn(async () => null),
+    } as unknown as ChangeDetectionResolverFactory;
+  } as unknown as new () => ChangeDetectionResolverFactory);
+  vi.mocked(DependencyGraphBuilder).mockImplementation(function () {
+    return { build: buildSpy } as unknown as DependencyGraphBuilder;
+  } as unknown as new () => DependencyGraphBuilder);
+  vi.mocked(IncrementalPatcher).mockImplementation(function () {
+    return { patch: patchSpy } as unknown as IncrementalPatcher;
+  } as unknown as new () => IncrementalPatcher);
+
+  return { patchSpy, buildSpy };
+}
+
 describe('ChangeDetectionService', () => {
   const workingDir = '/repo';
 
@@ -177,36 +250,28 @@ describe('ChangeDetectionService', () => {
     vi.mocked(logger.info).mockImplementation(() => undefined);
     vi.mocked(logger.warn).mockImplementation(() => undefined);
     vi.mocked(logger.error).mockImplementation(() => undefined);
+    vi.mocked(logger.debug).mockImplementation(() => undefined);
   });
 
   afterEach(() => {
     vi.useRealTimers();
-    vi.clearAllMocks();
+    vi.resetAllMocks();
     internal_resetChangeDetectionReadiness();
   });
 
-  it('marks only the nearest stories as modified', async () => {
-    const buttonCss = createModuleNode('/repo/src/Button.module.css');
-    const buttonComponent = createModuleNode('/repo/src/Button.tsx');
-    const buttonStory = createModuleNode('/repo/src/Button.stories.tsx');
-    const headerComponent = createModuleNode('/repo/src/Header.tsx');
-    const headerStory = createModuleNode('/repo/src/Header.stories.tsx');
-
-    buttonCss.importers.add(buttonComponent);
-    buttonComponent.importers.add(buttonStory);
-    buttonComponent.importers.add(headerComponent);
-    headerComponent.importers.add(headerStory);
-
-    const moduleGraph: ModuleGraph = new Map([
-      ['/repo/src/Button.module.css', new Set([buttonCss])],
-      ['/repo/src/Button.tsx', new Set([buttonComponent])],
-      ['/repo/src/Button.stories.tsx', new Set([buttonStory])],
-      ['/repo/src/Header.tsx', new Set([headerComponent])],
-      ['/repo/src/Header.stories.tsx', new Set([headerStory])],
+  it('edits a story file -> that story is modified at distance 0; importer stories are affected at distance 1', async () => {
+    // Story A is the changed file (distance 0). Story B imports A (distance 1).
+    // Reverse index models forward-walk depths: A reaches itself at 0; B reaches A at 1.
+    const reverseIndex = buildReverseIndex([
+      ['/repo/src/A.stories.tsx', '/repo/src/A.stories.tsx', 0],
+      ['/repo/src/A.stories.tsx', '/repo/src/B.stories.tsx', 1],
+      ['/repo/src/B.stories.tsx', '/repo/src/B.stories.tsx', 0],
     ]);
+    installDependencyGraphMocks(reverseIndex);
+
     const storyIndex = createStoryIndex([
-      { storyId: 'button--primary', importPath: './src/Button.stories.tsx', title: 'Button' },
-      { storyId: 'header--default', importPath: './src/Header.stories.tsx', title: 'Header' },
+      { storyId: 'a--default', importPath: './src/A.stories.tsx', title: 'A' },
+      { storyId: 'b--default', importPath: './src/B.stories.tsx', title: 'B' },
     ]);
     const { getStatusStoreByTypeId } = createStatusStore({
       universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
@@ -214,11 +279,11 @@ describe('ChangeDetectionService', () => {
     });
     const gitDiffProvider = createMockGitDiffProvider((provider) => {
       provider.getChangedFilesMock.mockResolvedValue({
-        changed: new Set(['src/Button.module.css']),
+        changed: new Set(['src/A.stories.tsx']),
         new: new Set(),
       });
     });
-    const { builder, emit } = createBuilder();
+    const { adapter } = createMockAdapter();
     const service = new ChangeDetectionService({
       storyIndexGeneratorPromise: Promise.resolve({
         getIndex: vi.fn().mockResolvedValue(storyIndex),
@@ -229,14 +294,13 @@ describe('ChangeDetectionService', () => {
       workingDir,
     });
 
-    service.start(builder.onModuleGraphChange, true);
-    emit(moduleGraph);
+    service.start(adapter, true);
     await vi.runAllTimersAsync();
 
     expect(getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll()).toEqual({
-      'button--primary': {
+      'a--default': {
         [CHANGE_DETECTION_STATUS_TYPE_ID]: {
-          storyId: 'button--primary',
+          storyId: 'a--default',
           typeId: CHANGE_DETECTION_STATUS_TYPE_ID,
           value: 'status-value:modified',
           title: '',
@@ -244,9 +308,9 @@ describe('ChangeDetectionService', () => {
           sidebarContextMenu: false,
         },
       },
-      'header--default': {
+      'b--default': {
         [CHANGE_DETECTION_STATUS_TYPE_ID]: {
-          storyId: 'header--default',
+          storyId: 'b--default',
           typeId: CHANGE_DETECTION_STATUS_TYPE_ID,
           value: 'status-value:affected',
           title: '',
@@ -255,11 +319,156 @@ describe('ChangeDetectionService', () => {
         },
       },
     });
+    await service.dispose();
+  });
+
+  it('edits a non-story dep at distance 1 from one story and distance 2 from another -> nearest is modified, farther is affected', async () => {
+    // Button.tsx is imported by Button.stories.tsx (distance 1) and by Compositions.stories.tsx
+    // transitively via the Button story chain (distance 2).
+    const reverseIndex = buildReverseIndex([
+      ['/repo/src/Button.tsx', '/repo/src/Button.stories.tsx', 1],
+      ['/repo/src/Button.tsx', '/repo/src/Compositions.stories.tsx', 2],
+    ]);
+    installDependencyGraphMocks(reverseIndex);
+
+    const storyIndex = createStoryIndex([
+      {
+        storyId: 'button--primary',
+        importPath: './src/Button.stories.tsx',
+        title: 'Button',
+      },
+      {
+        storyId: 'compositions--default',
+        importPath: './src/Compositions.stories.tsx',
+        title: 'Compositions',
+      },
+    ]);
+    const { getStatusStoreByTypeId } = createStatusStore({
+      universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
+      environment: 'server',
+    });
+    const gitDiffProvider = createMockGitDiffProvider((provider) => {
+      provider.getChangedFilesMock.mockResolvedValue({
+        changed: new Set(['src/Button.tsx']),
+        new: new Set(),
+      });
+    });
+    const { adapter } = createMockAdapter();
+    const service = new ChangeDetectionService({
+      storyIndexGeneratorPromise: Promise.resolve({
+        getIndex: vi.fn().mockResolvedValue(storyIndex),
+      } as never),
+      statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
+      gitDiffProvider,
+      indexBaselineService: createMockStoryIndexBaselineService(),
+      workingDir,
+    });
+
+    service.start(adapter, true);
+    await vi.runAllTimersAsync();
+
+    const all = getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll();
+    expect(all['button--primary'][CHANGE_DETECTION_STATUS_TYPE_ID].value).toBe(
+      'status-value:modified'
+    );
+    expect(all['compositions--default'][CHANGE_DETECTION_STATUS_TYPE_ID].value).toBe(
+      'status-value:affected'
+    );
+    await service.dispose();
+  });
+
+  it('edits a non-story dep at equal distance from two stories -> both stories tie and are both modified', async () => {
+    // Both Button.stories.tsx and Header.stories.tsx import shared.ts at distance 1.
+    const reverseIndex = buildReverseIndex([
+      ['/repo/src/shared.ts', '/repo/src/Button.stories.tsx', 1],
+      ['/repo/src/shared.ts', '/repo/src/Header.stories.tsx', 1],
+    ]);
+    installDependencyGraphMocks(reverseIndex);
+
+    const storyIndex = createStoryIndex([
+      { storyId: 'button--primary', importPath: './src/Button.stories.tsx', title: 'Button' },
+      { storyId: 'header--default', importPath: './src/Header.stories.tsx', title: 'Header' },
+    ]);
+    const { getStatusStoreByTypeId } = createStatusStore({
+      universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
+      environment: 'server',
+    });
+    const gitDiffProvider = createMockGitDiffProvider((provider) => {
+      provider.getChangedFilesMock.mockResolvedValue({
+        changed: new Set(['src/shared.ts']),
+        new: new Set(),
+      });
+    });
+    const { adapter } = createMockAdapter();
+    const service = new ChangeDetectionService({
+      storyIndexGeneratorPromise: Promise.resolve({
+        getIndex: vi.fn().mockResolvedValue(storyIndex),
+      } as never),
+      statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
+      gitDiffProvider,
+      indexBaselineService: createMockStoryIndexBaselineService(),
+      workingDir,
+    });
+
+    service.start(adapter, true);
+    await vi.runAllTimersAsync();
+
+    const all = getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll();
+    expect(all['button--primary'][CHANGE_DETECTION_STATUS_TYPE_ID].value).toBe(
+      'status-value:modified'
+    );
+    expect(all['header--default'][CHANGE_DETECTION_STATUS_TYPE_ID].value).toBe(
+      'status-value:modified'
+    );
+    await service.dispose();
+  });
+
+  it('edits a non-story file with no story importers -> reverse-index lookup is empty -> no status emitted', async () => {
+    // orphan.ts is in neither the reverse index nor the story index.
+    const reverseIndex = buildReverseIndex([
+      ['/repo/src/Button.tsx', '/repo/src/Button.stories.tsx', 1],
+    ]);
+    installDependencyGraphMocks(reverseIndex);
+
+    const storyIndex = createStoryIndex([
+      { storyId: 'button--primary', importPath: './src/Button.stories.tsx', title: 'Button' },
+    ]);
+    const { getStatusStoreByTypeId } = createStatusStore({
+      universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
+      environment: 'server',
+    });
+    const gitDiffProvider = createMockGitDiffProvider((provider) => {
+      provider.getChangedFilesMock.mockResolvedValue({
+        changed: new Set(['src/orphan.ts']),
+        new: new Set(),
+      });
+    });
+    const { adapter } = createMockAdapter();
+    const service = new ChangeDetectionService({
+      storyIndexGeneratorPromise: Promise.resolve({
+        getIndex: vi.fn().mockResolvedValue(storyIndex),
+      } as never),
+      statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
+      gitDiffProvider,
+      indexBaselineService: createMockStoryIndexBaselineService(),
+      workingDir,
+    });
+
+    service.start(adapter, true);
+    await vi.runAllTimersAsync();
+
+    expect(getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll()).toEqual({});
     expect(await getChangeDetectionReadiness()).toEqual({ status: 'ready' });
     await service.dispose();
   });
 
+  // ------------------------------------------------------------------
+  // Orchestration / merge-status / readiness / git-state / debounce tests.
+  // ------------------------------------------------------------------
+
   it('marks new story files from the git new set and unsets them after they are reverted', async () => {
+    installDependencyGraphMocks(buildReverseIndex([]));
+
     const storyIndex = createStoryIndex([
       {
         storyId: 'new-button--primary',
@@ -282,7 +491,11 @@ describe('ChangeDetectionService', () => {
           new: new Set(),
         });
     });
-    const { builder, emit } = createBuilder();
+    let onGitStateChange: (() => void) | undefined;
+    gitDiffProvider.onGitStateChangeMock.mockImplementation((callback: () => void) => {
+      onGitStateChange = callback;
+    });
+    const { adapter } = createMockAdapter();
     const service = new ChangeDetectionService({
       storyIndexGeneratorPromise: Promise.resolve({
         getIndex: vi.fn().mockResolvedValue(storyIndex),
@@ -294,8 +507,7 @@ describe('ChangeDetectionService', () => {
       debounceMs: 10,
     });
 
-    service.start(builder.onModuleGraphChange, true);
-    emit(new Map());
+    service.start(adapter, true);
     await vi.runAllTimersAsync();
 
     expect(getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll()).toEqual({
@@ -311,7 +523,7 @@ describe('ChangeDetectionService', () => {
       },
     });
 
-    emit(new Map());
+    onGitStateChange?.();
     await vi.runAllTimersAsync();
 
     expect(getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll()).toEqual({
@@ -321,18 +533,12 @@ describe('ChangeDetectionService', () => {
   });
 
   it('replaces prior scan status data instead of cumulatively merging with store state', async () => {
-    const depA = createModuleNode('/repo/src/depA.ts');
-    const depB = createModuleNode('/repo/src/depB.ts');
-    const buttonStory = createModuleNode('/repo/src/Button.stories.tsx');
-
-    depA.importers.add(buttonStory);
-    depB.importers.add(buttonStory);
-
-    const moduleGraph: ModuleGraph = new Map([
-      ['/repo/src/depA.ts', new Set([depA])],
-      ['/repo/src/depB.ts', new Set([depB])],
-      ['/repo/src/Button.stories.tsx', new Set([buttonStory])],
+    const reverseIndex = buildReverseIndex([
+      ['/repo/src/depB.ts', '/repo/src/Button.stories.tsx', 1],
+      ['/repo/src/depA.ts', '/repo/src/Button.stories.tsx', 1],
     ]);
+    installDependencyGraphMocks(reverseIndex);
+
     const storyIndex = createStoryIndex([
       { storyId: 'button--primary', importPath: './src/Button.stories.tsx', title: 'Button' },
     ]);
@@ -351,7 +557,11 @@ describe('ChangeDetectionService', () => {
           new: new Set(),
         });
     });
-    const { builder, emit } = createBuilder();
+    let onGitStateChange: (() => void) | undefined;
+    gitDiffProvider.onGitStateChangeMock.mockImplementation((callback: () => void) => {
+      onGitStateChange = callback;
+    });
+    const { adapter } = createMockAdapter();
     const service = new ChangeDetectionService({
       storyIndexGeneratorPromise: Promise.resolve({
         getIndex: vi.fn().mockResolvedValue(storyIndex),
@@ -363,8 +573,7 @@ describe('ChangeDetectionService', () => {
       debounceMs: 10,
     });
 
-    service.start(builder.onModuleGraphChange, true);
-    emit(moduleGraph);
+    service.start(adapter, true);
     await vi.runAllTimersAsync();
 
     expect(getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll()).toEqual({
@@ -380,7 +589,7 @@ describe('ChangeDetectionService', () => {
       },
     });
 
-    emit(moduleGraph);
+    onGitStateChange?.();
     await vi.runAllTimersAsync();
 
     expect(getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll()).toEqual({
@@ -399,10 +608,11 @@ describe('ChangeDetectionService', () => {
   });
 
   it('rescans on git state changes using the normal debounce', async () => {
-    const buttonStory = createModuleNode('/repo/src/Button.stories.tsx');
-    const moduleGraph: ModuleGraph = new Map([
-      ['/repo/src/Button.stories.tsx', new Set([buttonStory])],
+    const reverseIndex = buildReverseIndex([
+      ['/repo/src/Button.stories.tsx', '/repo/src/Button.stories.tsx', 0],
     ]);
+    installDependencyGraphMocks(reverseIndex);
+
     const storyIndex = createStoryIndex([
       { storyId: 'button--primary', importPath: './src/Button.stories.tsx', title: 'Button' },
     ]);
@@ -420,7 +630,7 @@ describe('ChangeDetectionService', () => {
         onGitStateChange = callback;
       });
     });
-    const { builder, emit } = createBuilder();
+    const { adapter } = createMockAdapter();
     const service = new ChangeDetectionService({
       storyIndexGeneratorPromise: Promise.resolve({
         getIndex: vi.fn().mockResolvedValue(storyIndex),
@@ -432,8 +642,7 @@ describe('ChangeDetectionService', () => {
       debounceMs: 10,
     });
 
-    service.start(builder.onModuleGraphChange, true);
-    emit(moduleGraph);
+    service.start(adapter, true);
     await vi.runAllTimersAsync();
 
     expect(gitDiffProvider.onGitStateChangeMock).toHaveBeenCalledTimes(1);
@@ -451,13 +660,58 @@ describe('ChangeDetectionService', () => {
     await service.dispose();
   });
 
+  it('debounces consecutive file-change events into a single scan', async () => {
+    installDependencyGraphMocks(buildReverseIndex([]));
+
+    const storyIndex = createStoryIndex([
+      { storyId: 'button--primary', importPath: './src/Button.stories.tsx', title: 'Button' },
+    ]);
+    const { getStatusStoreByTypeId } = createStatusStore({
+      universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
+      environment: 'server',
+    });
+    const gitDiffProvider = createMockGitDiffProvider();
+    const { adapter, emitFileChange } = createMockAdapter();
+    const service = new ChangeDetectionService({
+      storyIndexGeneratorPromise: Promise.resolve({
+        getIndex: vi.fn().mockResolvedValue(storyIndex),
+      } as never),
+      statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
+      gitDiffProvider,
+      indexBaselineService: createMockStoryIndexBaselineService(),
+      workingDir,
+      debounceMs: 50,
+    });
+
+    service.start(adapter, true);
+    // First scan from initial start — debounce 0 runs synchronously.
+    await vi.runAllTimersAsync();
+    expect(gitDiffProvider.getChangedFilesMock).toHaveBeenCalledTimes(1);
+
+    // Three file-change events within the debounce window collapse to one scan.
+    emitFileChange({ kind: 'change', path: '/repo/src/A.ts' });
+    await vi.advanceTimersByTimeAsync(10);
+    emitFileChange({ kind: 'change', path: '/repo/src/B.ts' });
+    await vi.advanceTimersByTimeAsync(10);
+    emitFileChange({ kind: 'change', path: '/repo/src/C.ts' });
+    await vi.advanceTimersByTimeAsync(10);
+
+    expect(gitDiffProvider.getChangedFilesMock).toHaveBeenCalledTimes(1);
+
+    await vi.advanceTimersByTimeAsync(50);
+
+    expect(gitDiffProvider.getChangedFilesMock).toHaveBeenCalledTimes(2);
+
+    await service.dispose();
+  });
+
   it('does not subscribe to git state when change detection is disabled', async () => {
     const { getStatusStoreByTypeId } = createStatusStore({
       universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
       environment: 'server',
     });
     const gitDiffProvider = createMockGitDiffProvider();
-    const { builder } = createBuilder();
+    const { adapter, hasFileChangeSubscriber } = createMockAdapter();
     const service = new ChangeDetectionService({
       storyIndexGeneratorPromise: Promise.resolve({
         getIndex: vi.fn(),
@@ -468,9 +722,9 @@ describe('ChangeDetectionService', () => {
       workingDir,
     });
 
-    service.start(builder.onModuleGraphChange, false);
+    service.start(adapter, false);
 
-    expect(builder.onModuleGraphChange).not.toHaveBeenCalled();
+    expect(hasFileChangeSubscriber()).toBe(false);
     expect(gitDiffProvider.onGitStateChangeMock).not.toHaveBeenCalled();
     expect(await getChangeDetectionReadiness()).toEqual({
       status: 'unavailable',
@@ -479,7 +733,7 @@ describe('ChangeDetectionService', () => {
     await service.dispose();
   });
 
-  it('logs unavailability when the builder does not expose module graph changes', async () => {
+  it('logs unavailability when the builder does not provide an adapter', async () => {
     const { getStatusStoreByTypeId } = createStatusStore({
       universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
       environment: 'server',
@@ -497,25 +751,31 @@ describe('ChangeDetectionService', () => {
     service.start(undefined, true);
 
     expect(logger.warn).toHaveBeenCalledWith(
-      'Change detection unavailable: Not supported by builder'
+      'Change detection unavailable: builder does not support change detection'
     );
     expect(await getChangeDetectionReadiness()).toEqual({
       status: 'unavailable',
-      reason: 'builder does not support module graph',
+      reason: 'builder does not support change detection',
     });
     await service.dispose();
   });
 
-  it('resolves readiness when the builder reports change detection startup failure', async () => {
+  it('resolves readiness as unavailable when the adapter reports a startup failure', async () => {
+    // Park git lookup so the initial scan never resolves to 'ready' before we emit the failure.
+    const gitDeferred = createDeferred<GitDiffResult>();
+    installDependencyGraphMocks(buildReverseIndex([]));
+
     const { getStatusStoreByTypeId } = createStatusStore({
       universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
       environment: 'server',
     });
-    const gitDiffProvider = createMockGitDiffProvider();
-    const { builder, emitError } = createBuilder();
+    const gitDiffProvider = createMockGitDiffProvider((provider) => {
+      provider.getChangedFilesMock.mockImplementation(() => gitDeferred.promise);
+    });
+    const { adapter, emitStartupFailure } = createMockAdapter();
     const service = new ChangeDetectionService({
       storyIndexGeneratorPromise: Promise.resolve({
-        getIndex: vi.fn(),
+        getIndex: vi.fn().mockResolvedValue(createStoryIndex([])),
       } as never),
       statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
       gitDiffProvider,
@@ -523,22 +783,98 @@ describe('ChangeDetectionService', () => {
       workingDir,
     });
 
-    service.start(builder.onModuleGraphChange, true);
-    emitError(new Error('module graph warmup failed'));
-    await Promise.resolve();
+    service.start(adapter, true);
+    // Let startInternal subscribe before emitting the failure (initial scan parked on git).
+    await vi.runAllTimersAsync();
+
+    emitStartupFailure({ reason: 'vite warmup failed', error: new Error('warmup failed') });
+    await vi.runAllTimersAsync();
+
+    expect(logger.warn).toHaveBeenCalledWith('Change detection unavailable: vite warmup failed');
+    expect(await getChangeDetectionReadiness()).toEqual({
+      status: 'unavailable',
+      reason: 'vite warmup failed',
+      error: expect.objectContaining({ message: 'warmup failed' }),
+    });
+    // Unblock the parked git call so dispose can drain.
+    gitDeferred.resolve({ changed: new Set(), new: new Set() });
+    await service.dispose();
+  });
+
+  it('resolves readiness as error when the eager build throws', async () => {
+    const { buildSpy } = installDependencyGraphMocks(buildReverseIndex([]));
+    buildSpy.mockImplementation(async () => {
+      throw new ChangeDetectionFailureError('graph build blew up');
+    });
+
+    const { getStatusStoreByTypeId } = createStatusStore({
+      universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
+      environment: 'server',
+    });
+    const { adapter } = createMockAdapter();
+    const service = new ChangeDetectionService({
+      storyIndexGeneratorPromise: Promise.resolve({
+        getIndex: vi.fn().mockResolvedValue(createStoryIndex([])),
+      } as never),
+      statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
+      gitDiffProvider: createMockGitDiffProvider(),
+      indexBaselineService: createMockStoryIndexBaselineService(),
+      workingDir,
+    });
+
+    service.start(adapter, true);
+    await vi.runAllTimersAsync();
 
     expect(logger.error).toHaveBeenCalledWith(
-      'Change detection failed: module graph warmup failed'
+      'Change detection failed to start: graph build blew up'
     );
     expect(await getChangeDetectionReadiness()).toEqual({
       status: 'error',
-      error: expect.objectContaining({ message: 'module graph warmup failed' }),
+      error: expect.objectContaining({ message: 'graph build blew up' }),
     });
-    expect(gitDiffProvider.getChangedFilesMock).not.toHaveBeenCalled();
+    await service.dispose();
+  });
+
+  it('disposes the pool when startInternal throws', async () => {
+    // The startInternal pipeline throws after startup. Without the dispose() call in the
+    // catch handler disposeOxcParsePool would not be called.
+    const { buildSpy } = installDependencyGraphMocks(buildReverseIndex([]));
+    buildSpy.mockImplementation(async () => {
+      throw new ChangeDetectionFailureError('graph build blew up');
+    });
+
+    const disposePoolSpy = vi.spyOn(oxcParser, 'disposeOxcParsePool').mockResolvedValue(undefined);
+
+    const { getStatusStoreByTypeId } = createStatusStore({
+      universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
+      environment: 'server',
+    });
+    const { adapter } = createMockAdapter();
+    const service = new ChangeDetectionService({
+      storyIndexGeneratorPromise: Promise.resolve({
+        getIndex: vi.fn().mockResolvedValue(createStoryIndex([])),
+      } as never),
+      statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
+      gitDiffProvider: createMockGitDiffProvider(),
+      indexBaselineService: createMockStoryIndexBaselineService(),
+      workingDir,
+    });
+
+    service.start(adapter, true);
+    await vi.runAllTimersAsync();
+
+    // dispose() must have been called, which calls disposeOxcParsePool exactly once.
+    expect(disposePoolSpy).toHaveBeenCalledTimes(1);
+
     await service.dispose();
   });
 
   it('keeps the previous statuses when a live rescan fails', async () => {
+    const reverseIndex = buildReverseIndex([
+      ['/repo/src/Button.stories.tsx', '/repo/src/Button.stories.tsx', 0],
+    ]);
+    installDependencyGraphMocks(reverseIndex);
+
     const storyIndex = createStoryIndex([
       { storyId: 'button--primary', importPath: './src/Button.stories.tsx', title: 'Button' },
     ]);
@@ -554,7 +890,11 @@ describe('ChangeDetectionService', () => {
         })
         .mockRejectedValueOnce(new ChangeDetectionFailureError('scan blew up'));
     });
-    const { builder, emit } = createBuilder();
+    let onGitStateChange: (() => void) | undefined;
+    gitDiffProvider.onGitStateChangeMock.mockImplementation((callback: () => void) => {
+      onGitStateChange = callback;
+    });
+    const { adapter } = createMockAdapter();
     const service = new ChangeDetectionService({
       storyIndexGeneratorPromise: Promise.resolve({
         getIndex: vi.fn().mockResolvedValue(storyIndex),
@@ -566,10 +906,10 @@ describe('ChangeDetectionService', () => {
       debounceMs: 10,
     });
 
-    service.start(builder.onModuleGraphChange, true);
-    emit(new Map());
+    service.start(adapter, true);
     await vi.runAllTimersAsync();
-    emit(new Map());
+
+    onGitStateChange?.();
     await vi.runAllTimersAsync();
 
     expect(getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll()).toEqual({
@@ -589,13 +929,14 @@ describe('ChangeDetectionService', () => {
   });
 
   it('does not apply scan results or rerun after disposal', async () => {
+    const reverseIndex = buildReverseIndex([
+      ['/repo/src/Button.stories.tsx', '/repo/src/Button.stories.tsx', 0],
+    ]);
+    installDependencyGraphMocks(reverseIndex);
+
     const storyIndex = createStoryIndex([
       { storyId: 'button--primary', importPath: './src/Button.stories.tsx', title: 'Button' },
     ]);
-    const buttonStory = createModuleNode('/repo/src/Button.stories.tsx');
-    const moduleGraph: ModuleGraph = new Map([
-      ['/repo/src/Button.stories.tsx', new Set([buttonStory])],
-    ]);
     const { getStatusStoreByTypeId } = createStatusStore({
       universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
       environment: 'server',
@@ -607,7 +948,7 @@ describe('ChangeDetectionService', () => {
     const gitDiffProvider = createMockGitDiffProvider((provider) => {
       provider.getChangedFilesMock.mockImplementation(() => changedFilesDeferred.promise);
     });
-    const { builder, emit } = createBuilder();
+    const { adapter } = createMockAdapter();
     const service = new ChangeDetectionService({
       storyIndexGeneratorPromise: Promise.resolve({
         getIndex: vi.fn().mockResolvedValue(storyIndex),
@@ -619,10 +960,7 @@ describe('ChangeDetectionService', () => {
       debounceMs: 0,
     });
 
-    service.start(builder.onModuleGraphChange, true);
-    emit(moduleGraph);
-    await vi.advanceTimersByTimeAsync(0);
-    emit(moduleGraph);
+    service.start(adapter, true);
     await vi.advanceTimersByTimeAsync(0);
     await service.dispose();
 
@@ -633,7 +971,6 @@ describe('ChangeDetectionService', () => {
     await Promise.resolve();
     await Promise.resolve();
 
-    expect(gitDiffProvider.getChangedFilesMock).toHaveBeenCalledTimes(1);
     expect(getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll()).toEqual({});
     await expect(
       Promise.race([
@@ -644,6 +981,8 @@ describe('ChangeDetectionService', () => {
   });
 
   it('tears down after a permanently unavailable scan result', async () => {
+    installDependencyGraphMocks(buildReverseIndex([]));
+
     const { getStatusStoreByTypeId } = createStatusStore({
       universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
       environment: 'server',
@@ -653,10 +992,10 @@ describe('ChangeDetectionService', () => {
         new ChangeDetectionUnavailableError('not a git repository')
       );
     });
-    const { builder, emit } = createBuilder();
+    const { adapter } = createMockAdapter();
     const service = new ChangeDetectionService({
       storyIndexGeneratorPromise: Promise.resolve({
-        getIndex: vi.fn(),
+        getIndex: vi.fn().mockResolvedValue(createStoryIndex([])),
       } as never),
       statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
       gitDiffProvider,
@@ -665,11 +1004,8 @@ describe('ChangeDetectionService', () => {
       debounceMs: 0,
     });
 
-    service.start(builder.onModuleGraphChange, true);
-    emit(new Map());
-    await vi.advanceTimersByTimeAsync(0);
-    emit(new Map());
-    await vi.advanceTimersByTimeAsync(0);
+    service.start(adapter, true);
+    await vi.runAllTimersAsync();
 
     expect(gitDiffProvider.getChangedFilesMock).toHaveBeenCalledTimes(1);
     expect(logger.warn).toHaveBeenCalledWith('Change detection unavailable: not a git repository');
@@ -681,30 +1017,69 @@ describe('ChangeDetectionService', () => {
     await service.dispose();
   });
 
-  it('prefers modified over affected when the same story is reached by multiple changed files', async () => {
-    const shared = createModuleNode('/repo/src/shared.ts');
-    const closeComponent = createModuleNode('/repo/src/Close.tsx');
-    const farComponent = createModuleNode('/repo/src/Far.tsx');
-    const story = createModuleNode('/repo/src/Button.stories.tsx');
-
-    shared.importers.add(closeComponent);
-    shared.importers.add(farComponent);
-    closeComponent.importers.add(story);
-    farComponent.importers.add(closeComponent);
-
-    const directChange = createModuleNode('/repo/src/direct.ts');
-    const indirectChange = createModuleNode('/repo/src/indirect.ts');
-    directChange.importers.add(closeComponent);
-    indirectChange.importers.add(farComponent);
-
-    const moduleGraph: ModuleGraph = new Map([
-      ['/repo/src/shared.ts', new Set([shared])],
-      ['/repo/src/Close.tsx', new Set([closeComponent])],
-      ['/repo/src/Far.tsx', new Set([farComponent])],
-      ['/repo/src/Button.stories.tsx', new Set([story])],
-      ['/repo/src/direct.ts', new Set([directChange])],
-      ['/repo/src/indirect.ts', new Set([indirectChange])],
+  it('serialises concurrent file-change events through the patch chain', async () => {
+    const reverseIndex = buildReverseIndex([]);
+    const { patchSpy, buildSpy } = installDependencyGraphMocks(reverseIndex);
+    buildSpy.mockResolvedValue({ reverseIndex, graph: new Map() });
+
+    let activePatches = 0;
+    let maxConcurrent = 0;
+    patchSpy.mockImplementation(async () => {
+      activePatches += 1;
+      maxConcurrent = Math.max(maxConcurrent, activePatches);
+      // Force an actual await so two concurrent calls would visibly interleave.
+      await new Promise((resolve) => setImmediate(resolve));
+      activePatches -= 1;
+    });
+
+    const storyIndex = createStoryIndex([
+      { storyId: 'button--primary', importPath: './src/Button.stories.tsx', title: 'Button' },
     ]);
+    const { getStatusStoreByTypeId } = createStatusStore({
+      universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
+      environment: 'server',
+    });
+    const { adapter, emitFileChange } = createMockAdapter();
+    const service = new ChangeDetectionService({
+      storyIndexGeneratorPromise: Promise.resolve({
+        getIndex: vi.fn().mockResolvedValue(storyIndex),
+      } as never),
+      statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
+      gitDiffProvider: createMockGitDiffProvider(),
+      indexBaselineService: createMockStoryIndexBaselineService(),
+      workingDir,
+    });
+
+    service.start(adapter, true);
+    await vi.runAllTimersAsync();
+
+    emitFileChange({ kind: 'change', path: '/repo/src/Button.tsx' });
+    emitFileChange({ kind: 'change', path: '/repo/src/Other.tsx' });
+    emitFileChange({ kind: 'unlink', path: '/repo/src/Stale.tsx' });
+    await vi.runAllTimersAsync();
+
+    expect(patchSpy).toHaveBeenCalledTimes(3);
+    expect(maxConcurrent).toBe(1);
+
+    await service.dispose();
+  });
+
+  it('scan waits for the current patch to settle before reading reverseIndex', async () => {
+    // Without the patchSnapshot await in scan(), a git-state-change that fires scheduleScan
+    // while a patch is mid-rewalk (reverseIndex transiently empty) reads the empty index
+    // and publishes no statuses even though the patch will eventually add entries back.
+    const reverseIndex = buildReverseIndex([]);
+    const patchDeferred = createDeferred<void>();
+    const { patchSpy, buildSpy } = installDependencyGraphMocks(reverseIndex);
+    buildSpy.mockResolvedValue({ reverseIndex, graph: new Map() });
+
+    // The first patch call blocks; during that block a scan is scheduled. After the patch
+    // resolves, reverseIndex has a real entry that the scan should see.
+    patchSpy.mockImplementationOnce(async () => {
+      await patchDeferred.promise;
+      reverseIndex.record('/repo/src/Button.stories.tsx', '/repo/src/Button.stories.tsx', 0);
+    });
+
     const storyIndex = createStoryIndex([
       { storyId: 'button--primary', importPath: './src/Button.stories.tsx', title: 'Button' },
     ]);
@@ -714,11 +1089,15 @@ describe('ChangeDetectionService', () => {
     });
     const gitDiffProvider = createMockGitDiffProvider((provider) => {
       provider.getChangedFilesMock.mockResolvedValue({
-        changed: new Set(['src/direct.ts', 'src/indirect.ts']),
+        changed: new Set(['src/Button.stories.tsx']),
         new: new Set(),
       });
     });
-    const { builder, emit } = createBuilder();
+    let triggerGitStateChange: (() => void) | undefined;
+    gitDiffProvider.onGitStateChangeMock.mockImplementation((callback: () => void) => {
+      triggerGitStateChange = callback;
+    });
+    const { adapter, emitFileChange } = createMockAdapter();
     const service = new ChangeDetectionService({
       storyIndexGeneratorPromise: Promise.resolve({
         getIndex: vi.fn().mockResolvedValue(storyIndex),
@@ -727,43 +1106,38 @@ describe('ChangeDetectionService', () => {
       gitDiffProvider,
       indexBaselineService: createMockStoryIndexBaselineService(),
       workingDir,
+      debounceMs: 0,
     });
 
-    service.start(builder.onModuleGraphChange, true);
-    emit(moduleGraph);
+    service.start(adapter, true);
     await vi.runAllTimersAsync();
 
-    expect(getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll()).toEqual({
-      'button--primary': {
-        [CHANGE_DETECTION_STATUS_TYPE_ID]: {
-          storyId: 'button--primary',
-          typeId: CHANGE_DETECTION_STATUS_TYPE_ID,
-          value: 'status-value:modified',
-          title: '',
-          description: '',
-          sidebarContextMenu: false,
-        },
-      },
-    });
+    // Start a patch that will block, then immediately schedule a scan mid-patch.
+    emitFileChange({ kind: 'change', path: '/repo/src/Button.stories.tsx' });
+    triggerGitStateChange?.();
+
+    // Unblock the patch — now the reverseIndex has the entry.
+    patchDeferred.resolve();
+    await vi.runAllTimersAsync();
+
+    // The scan that ran after the patch settled should have seen the populated reverseIndex.
+    const all = getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll();
+    expect(all['button--primary']?.[CHANGE_DETECTION_STATUS_TYPE_ID]?.value).toBe(
+      'status-value:modified'
+    );
+
     await service.dispose();
   });
 
-  it('handles normalized paths when assigning statuses', async () => {
-    const buttonCssPath = join(workingDir, 'src', 'Button.module.css');
-    const buttonComponentPath = join(workingDir, 'src', 'Button.tsx');
-    const buttonStoryPath = join(workingDir, 'src', 'Button.stories.tsx');
-    const buttonCss = createModuleNode(buttonCssPath);
-    const buttonComponent = createModuleNode(buttonComponentPath);
-    const buttonStory = createModuleNode(buttonStoryPath);
-
-    buttonCss.importers.add(buttonComponent);
-    buttonComponent.importers.add(buttonStory);
-
-    const moduleGraph: ModuleGraph = new Map([
-      [buttonCssPath, new Set([buttonCss])],
-      [buttonComponentPath, new Set([buttonComponent])],
-      [buttonStoryPath, new Set([buttonStory])],
-    ]);
+  it('does not patch file-change events emitted before the adapter subscription is installed (pre-build events are dropped)', async () => {
+    const reverseIndex = buildReverseIndex([]);
+    const buildDeferred = createDeferred<void>();
+    const { patchSpy, buildSpy } = installDependencyGraphMocks(reverseIndex);
+    buildSpy.mockImplementation(async () => {
+      await buildDeferred.promise;
+      return { reverseIndex, graph: new Map() };
+    });
+
     const storyIndex = createStoryIndex([
       { storyId: 'button--primary', importPath: './src/Button.stories.tsx', title: 'Button' },
     ]);
@@ -771,39 +1145,135 @@ describe('ChangeDetectionService', () => {
       universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
       environment: 'server',
     });
-    const gitDiffProvider = createMockGitDiffProvider((provider) => {
-      provider.getChangedFilesMock.mockResolvedValue({
-        changed: new Set(['src/Button.module.css']),
-        new: new Set(),
-      });
-    });
-    const { builder, emit } = createBuilder();
+    const { adapter, emitFileChange } = createMockAdapter();
     const service = new ChangeDetectionService({
       storyIndexGeneratorPromise: Promise.resolve({
         getIndex: vi.fn().mockResolvedValue(storyIndex),
       } as never),
       statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
+      gitDiffProvider: createMockGitDiffProvider(),
+      indexBaselineService: createMockStoryIndexBaselineService(),
+      workingDir,
+    });
+
+    service.start(adapter, true);
+    // Allow startInternal to reach the build step and start awaiting it.
+    await Promise.resolve();
+    await Promise.resolve();
+
+    // The service subscribes to file-change events strictly after the eager build resolves,
+    // so anything emitted by the adapter before then has nowhere to land. Assert no patch
+    // calls have happened yet.
+    expect(patchSpy).not.toHaveBeenCalled();
+
+    buildDeferred.resolve();
+    await vi.runAllTimersAsync();
+
+    // Now the adapter has subscribers — file events go through the patcher.
+    emitFileChange({ kind: 'change', path: '/repo/src/Button.tsx' });
+    await vi.runAllTimersAsync();
+    expect(patchSpy).toHaveBeenCalledTimes(1);
+
+    await service.dispose();
+  });
+
+  it('calls gitDiffProvider.dispose() on service dispose when a git watcher was installed', async () => {
+    // Watcher leak: onGitStateChange installs FS watchers; without dispose() the watchers
+    // survive the service lifetime and fire stale callbacks on long-lived processes.
+    installDependencyGraphMocks(buildReverseIndex([]));
+
+    const gitDiffProvider = createMockGitDiffProvider((provider) => {
+      // Simulate having called onGitStateChange (watcher installed).
+      provider.onGitStateChangeMock.mockImplementation(() => undefined);
+    });
+    const { adapter } = createMockAdapter();
+    const service = new ChangeDetectionService({
+      storyIndexGeneratorPromise: Promise.resolve({
+        getIndex: vi.fn().mockResolvedValue(createStoryIndex([])),
+      } as never),
+      statusStore: createStatusStore({
+        universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
+        environment: 'server',
+      }).getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
       gitDiffProvider,
       indexBaselineService: createMockStoryIndexBaselineService(),
       workingDir,
     });
 
-    service.start(builder.onModuleGraphChange, true);
-    emit(moduleGraph);
+    service.start(adapter, true);
     await vi.runAllTimersAsync();
 
-    expect(getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID).getAll()).toEqual({
-      'button--primary': {
-        [CHANGE_DETECTION_STATUS_TYPE_ID]: {
-          storyId: 'button--primary',
-          typeId: CHANGE_DETECTION_STATUS_TYPE_ID,
-          value: 'status-value:modified',
-          title: '',
-          description: '',
-          sidebarContextMenu: false,
-        },
-      },
+    await service.dispose();
+
+    expect(gitDiffProvider.disposeMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not call gitDiffProvider.dispose() when the provider was never constructed by the service', async () => {
+    // If gitDiffProvider is never passed in and start() exits early (disabled), the service
+    // never lazily constructs a provider, so dispose() must not create one just to tear it down.
+    const { getStatusStoreByTypeId } = createStatusStore({
+      universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
+      environment: 'server',
+    });
+    const service = new ChangeDetectionService({
+      storyIndexGeneratorPromise: Promise.resolve({
+        getIndex: vi.fn(),
+      } as never),
+      statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
+      // No gitDiffProvider injected — service would lazily create one, but start(false) exits
+      // before getGitDiffProvider() is called.
+      indexBaselineService: createMockStoryIndexBaselineService(),
+      workingDir,
+    });
+
+    service.start(undefined, false);
+    // Should not throw and should not attempt to call dispose on an unconstructed provider.
+    await expect(service.dispose()).resolves.toBeUndefined();
+  });
+
+  it('replays add/unlink through the patcher when onStoryIndexInvalidated reveals new/removed stories', async () => {
+    const reverseIndex = buildReverseIndex([]);
+    const { patchSpy, buildSpy } = installDependencyGraphMocks(reverseIndex);
+    buildSpy.mockResolvedValue({ reverseIndex, graph: new Map() });
+
+    const initialIndex = createStoryIndex([
+      { storyId: 'a--default', importPath: './src/A.stories.tsx', title: 'A' },
+    ]);
+    const updatedIndex = createStoryIndex([
+      { storyId: 'a--default', importPath: './src/A.stories.tsx', title: 'A' },
+      { storyId: 'b--default', importPath: './src/B.stories.tsx', title: 'B' },
+    ]);
+    const getIndex = vi
+      .fn()
+      .mockResolvedValueOnce(initialIndex)
+      .mockResolvedValueOnce(initialIndex)
+      .mockResolvedValue(updatedIndex);
+
+    const { getStatusStoreByTypeId } = createStatusStore({
+      universalStatusStore: new MockUniversalStore(UNIVERSAL_STATUS_STORE_OPTIONS),
+      environment: 'server',
     });
+    const { adapter } = createMockAdapter();
+    const service = new ChangeDetectionService({
+      storyIndexGeneratorPromise: Promise.resolve({ getIndex } as never),
+      statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
+      gitDiffProvider: createMockGitDiffProvider(),
+      indexBaselineService: createMockStoryIndexBaselineService(),
+      workingDir,
+    });
+
+    service.start(adapter, true);
+    await vi.runAllTimersAsync();
+    expect(patchSpy).not.toHaveBeenCalled();
+
+    service.onStoryIndexInvalidated();
+    await vi.runAllTimersAsync();
+
+    expect(patchSpy).toHaveBeenCalledWith({
+      kind: 'add',
+      path: '/repo/src/B.stories.tsx',
+    });
+
     await service.dispose();
   });
 });
diff --git a/code/core/src/core-server/change-detection/ChangeDetectionService.ts b/code/core/src/core-server/change-detection/ChangeDetectionService.ts
index 857275982690..40277b5ee7b2 100644
--- a/code/core/src/core-server/change-detection/ChangeDetectionService.ts
+++ b/code/core/src/core-server/change-detection/ChangeDetectionService.ts
@@ -1,11 +1,11 @@
-import { join } from 'pathe';
+import { join, normalize } from 'pathe';
 
+import { dequal } from 'dequal';
 import { logger } from 'storybook/internal/node-logger';
+import { disposeOxcParsePool } from 'storybook/internal/oxc-parser';
+import { getProjectRoot } from 'storybook/internal/common';
 import type {
-  Builder,
-  ModuleGraph,
-  ModuleGraphChangeEvent,
-  ModuleNode,
+  Presets,
   StatusValue,
   StoryIndex,
   Status,
@@ -13,13 +13,21 @@ import type {
 } from 'storybook/internal/types';
 import { CHANGE_DETECTION_STATUS_TYPE_ID } from 'storybook/internal/types';
 
-import { normalizePath } from '../../common/utils/normalize-path.ts';
 import type { StoryIndexGenerator } from '../utils/StoryIndexGenerator.ts';
+import type { ChangeDetectionAdapter, FileChangeEvent } from './adapters/index.ts';
+import {
+  ChangeDetectionResolverFactory,
+  DependencyGraphBuilder,
+  IncrementalPatcher,
+  ParseResolveCache,
+} from './dependency-graph/index.ts';
+import type { ReverseIndexImpl } from './dependency-graph/index.ts';
 import { ChangeDetectionFailureError, ChangeDetectionUnavailableError } from './errors.ts';
 import { GitDiffProvider } from './GitDiffProvider.ts';
-import { resetChangeDetectionReadiness, setChangeDetectionReadiness } from './readiness.ts';
 import { extractBaselineEntryIds, IndexBaselineService } from './IndexBaselineService.ts';
-import { findAffectedStoryFiles } from './trace-changed.ts';
+import type { ImportParser } from './parser-registry/index.ts';
+import { ParserRegistry, builtinImportParsers } from './parser-registry/index.ts';
+import { resetChangeDetectionReadiness, setChangeDetectionReadiness } from './readiness.ts';
 
 const CHANGE_DETECTION_DEBOUNCE_MS = 200;
 
@@ -35,23 +43,34 @@ function isSameStatus(a: Status | undefined, b: Status): boolean {
     a.title === b.title &&
     a.description === b.description &&
     a.sidebarContextMenu === b.sidebarContextMenu &&
-    JSON.stringify(a.data) === JSON.stringify(b.data)
+    dequal(a.data, b.data)
   );
 }
 
+type StoryIdsByFileCacheKey = Awaited<ReturnType<StoryIndexGenerator['getIndex']>>;
+const storyIdsByFileCache = new WeakMap<
+  StoryIdsByFileCacheKey,
+  { workingDir: string; storyIdsByFile: Map<string, Set<string>> }
+>();
+
 function getStoryIdsByAbsolutePath(
-  storyIndex: Awaited<ReturnType<StoryIndexGenerator['getIndex']>>,
+  storyIndex: StoryIdsByFileCacheKey,
   workingDir: string
 ): Map<string, Set<string>> {
+  const cached = storyIdsByFileCache.get(storyIndex);
+  if (cached && cached.workingDir === workingDir) {
+    return cached.storyIdsByFile;
+  }
   const storyIdsByFile = new Map<string, Set<string>>();
   Object.values(storyIndex.entries).forEach((entry) => {
     if (entry.type === 'story' && !entry.importPath.startsWith('virtual:')) {
-      const filePath = join(workingDir, entry.importPath);
+      const filePath = normalize(join(workingDir, entry.importPath));
       const storyIds = storyIdsByFile.get(filePath) ?? new Set<string>();
       storyIds.add(entry.id);
       storyIdsByFile.set(filePath, storyIds);
     }
   });
+  storyIdsByFileCache.set(storyIndex, { workingDir, storyIdsByFile });
   return storyIdsByFile;
 }
 
@@ -115,16 +134,14 @@ export function buildIndexBaselineStatuses(
 }
 
 /**
- * Coordinates change detection by listening to builder module-graph updates, resolving changed
- * files from git, mapping those changes to affected stories, and publishing the resulting story
- * statuses to the status store.
+ * Coordinates change detection by owning a builder-supplied {@link ChangeDetectionAdapter},
+ * eagerly building a reverse-dependency index from story files at startup, applying
+ * file-system events incrementally to that index, resolving git-changed files, and publishing
+ * the resulting story statuses to the status store.
  */
 export class ChangeDetectionService {
   private disposed = false;
-  private unsubscribeModuleGraph: (() => void) | undefined;
   private debounceTimer: ReturnType<typeof setTimeout> | undefined;
-  private latestModuleGraph: ModuleGraph | undefined;
-  private hasReceivedModuleGraph = false;
   private scanInFlight = false;
   private rerunAfterCurrentScan = false;
   private readinessResolved = false;
@@ -133,6 +150,19 @@ export class ChangeDetectionService {
   private indexBaselineService: IndexBaselineService | undefined;
   private readonly workingDir: string;
   private readonly debounceMs: number;
+  private adapter: ChangeDetectionAdapter | undefined;
+  private dependencyGraphBuilder: DependencyGraphBuilder | undefined;
+  private incrementalPatcher: IncrementalPatcher | undefined;
+  private reverseIndex: ReverseIndexImpl | undefined;
+  private storyFiles: Set<string> = new Set();
+  /**
+   * Serialises file-change patches so two events touching the same dep set never interleave
+   * across `await` points inside `IncrementalPatcher.patch`. The chain ignores rejections
+   * (each call's failure is logged in {@link handleFileChange}).
+   */
+  private patchQueue: Promise<void> = Promise.resolve();
+  private unsubscribeFileChange: (() => void) | undefined;
+  private unsubscribeStartupFailure: (() => void) | undefined;
 
   constructor(
     private readonly options: {
@@ -142,6 +172,8 @@ export class ChangeDetectionService {
       indexBaselineService?: IndexBaselineService;
       workingDir?: string;
       debounceMs?: number;
+      /** Presets instance used to resolve `experimental_importParsers` contributions from framework/renderer plugins. */
+      presets?: Presets;
     }
   ) {
     this.gitDiffProvider = options.gitDiffProvider;
@@ -151,10 +183,7 @@ export class ChangeDetectionService {
     resetChangeDetectionReadiness();
   }
 
-  start(
-    onModuleGraphChange: Builder<unknown>['onModuleGraphChange'],
-    enabled: boolean | undefined
-  ): void {
+  start(adapter: ChangeDetectionAdapter | undefined, enabled: boolean | undefined): void {
     if (enabled === false) {
       logger.debug('Change detection disabled.');
       this.resolveReadiness({
@@ -164,31 +193,126 @@ export class ChangeDetectionService {
       return;
     }
 
-    if (!onModuleGraphChange) {
-      logger.warn('Change detection unavailable: Not supported by builder');
+    if (!adapter) {
+      logger.warn('Change detection unavailable: builder does not support change detection');
       this.resolveReadiness({
         status: 'unavailable',
-        reason: 'builder does not support module graph',
+        reason: 'builder does not support change detection',
       });
       return;
     }
 
     logger.debug('Change detection enabled.');
-    void this.getIndexBaselineService().start();
-    this.unsubscribeModuleGraph = onModuleGraphChange((event) => {
+    this.adapter = adapter;
+
+    void this.startInternal().catch((error) => {
       if (this.disposed) {
         return;
       }
+      const failure =
+        error instanceof Error ? error : new ChangeDetectionFailureError(String(error));
+      logger.error(`Change detection failed to start: ${failure.message}`);
+      this.resolveReadiness({ status: 'error', error: failure });
+      void this.dispose().catch(() => undefined);
+    });
+  }
 
-      if (event.type === 'moduleGraph') {
-        this.latestModuleGraph = event.moduleGraph;
-        this.scheduleScan(this.hasReceivedModuleGraph ? this.debounceMs : 0);
-        this.hasReceivedModuleGraph = true;
+  /**
+   * Builds parser registry, resolver, dependency graph, and patcher; subscribes to
+   * file-change events queued behind {@link patchQueue}; kicks off the baseline service
+   * and initial scan.
+   */
+  private async startInternal(): Promise<void> {
+    const adapter = this.adapter;
+    if (!adapter) {
+      return;
+    }
+
+    if (this.disposed) {
+      return;
+    }
+
+    const resolveConfig = await adapter.getResolveConfig();
+    const projectRoot = normalize(resolveConfig.projectRoot ?? this.workingDir);
+
+    const pluginParsers = this.options.presets
+      ? await this.options.presets.apply<ImportParser[]>('experimental_importParsers', [])
+      : [];
+    const registry = new ParserRegistry({
+      defaultParsers: builtinImportParsers,
+      pluginParsers,
+    });
+    const resolver = new ChangeDetectionResolverFactory(resolveConfig);
+    const workspaceRoots = new Set<string>([normalize(getProjectRoot())]);
+
+    const storyIndexGenerator = await this.options.storyIndexGeneratorPromise;
+    const storyIndex = await storyIndexGenerator.getIndex();
+    const storyIdsByFile = getStoryIdsByAbsolutePath(storyIndex, this.workingDir);
+    this.storyFiles = new Set(storyIdsByFile.keys());
+
+    if (this.disposed) {
+      return;
+    }
+
+    // Shared parse/resolve cache so the patcher reuses cold-start results instead of
+    // re-doing every file's parse + resolution on the first event after boot. The patcher
+    // invalidates per-file entries on every change/unlink before reading.
+    const cache = new ParseResolveCache({
+      registry,
+      resolver,
+      workspaceRoots,
+      projectRoot,
+      logger,
+    });
+
+    this.dependencyGraphBuilder = new DependencyGraphBuilder({
+      registry,
+      resolver,
+      workspaceRoots,
+      projectRoot,
+      cache,
+    });
+    const { reverseIndex, graph } = await this.dependencyGraphBuilder.build(this.storyFiles);
+    if (this.disposed) {
+      return;
+    }
+    this.reverseIndex = reverseIndex;
+
+    this.incrementalPatcher = new IncrementalPatcher({
+      reverseIndex,
+      graph,
+      registry,
+      resolver,
+      workspaceRoots,
+      projectRoot,
+      cache,
+      isStoryFile: (path: string) => this.storyFiles.has(normalize(path)),
+    });
+
+    this.unsubscribeFileChange = adapter.onFileChange((event) => {
+      if (this.disposed) {
         return;
       }
-
-      this.handleBuilderStartupEvent(event);
+      this.patchQueue = this.patchQueue.then(() => this.handleFileChange(event));
     });
+
+    if (adapter.onStartupFailure) {
+      this.unsubscribeStartupFailure = adapter.onStartupFailure((event) => {
+        if (this.disposed) {
+          return;
+        }
+        logger.warn(`Change detection unavailable: ${event.reason}`);
+        this.resolveReadiness({
+          status: 'unavailable',
+          reason: event.reason,
+          error: event.error,
+        });
+        void this.dispose();
+      });
+    }
+
+    void this.getIndexBaselineService().start();
+
     this.getGitDiffProvider().onGitStateChange(() => {
       if (this.disposed) {
         return;
@@ -199,11 +323,64 @@ export class ChangeDetectionService {
         .handleGitStateChange()
         .catch(() => undefined);
     });
+
+    // Initial scan surfaces git-pending diffs immediately.
+    this.scheduleScan(0);
   }
 
   onStoryIndexInvalidated(): void {
-    if (!this.disposed) {
-      this.scheduleScan(this.debounceMs);
+    if (this.disposed) {
+      return;
+    }
+    void this.refreshStoryFiles().catch(() => undefined);
+    this.scheduleScan(this.debounceMs);
+  }
+
+  /**
+   * Re-reads the story index and reconciles {@link storyFiles} with stories that have
+   * appeared or disappeared since startup. For each story that newly entered the index, the
+   * patcher is asked to walk it (so its forward edges are recorded). For each story that
+   * left the index, the patcher is asked to unlink it (so its reverse-index entries are
+   * pruned). Replays are queued behind {@link patchQueue} to keep the serialised-patch
+   * invariant intact.
+   */
+  private async refreshStoryFiles(): Promise<void> {
+    if (!this.incrementalPatcher) {
+      return;
+    }
+    const storyIndexGenerator = await this.options.storyIndexGeneratorPromise;
+    const storyIndex = await storyIndexGenerator.getIndex();
+    if (this.disposed) {
+      return;
+    }
+    const storyIdsByFile = getStoryIdsByAbsolutePath(storyIndex, this.workingDir);
+    const next = new Set(storyIdsByFile.keys());
+    const previous = this.storyFiles;
+
+    const added: string[] = [];
+    for (const path of next) {
+      if (!previous.has(path)) {
+        added.push(path);
+      }
+    }
+    const removed: string[] = [];
+    for (const path of previous) {
+      if (!next.has(path)) {
+        removed.push(path);
+      }
+    }
+
+    if (added.length === 0 && removed.length === 0) {
+      return;
+    }
+
+    this.storyFiles = next;
+
+    for (const path of added) {
+      this.patchQueue = this.patchQueue.then(() => this.handleFileChange({ kind: 'add', path }));
+    }
+    for (const path of removed) {
+      this.patchQueue = this.patchQueue.then(() => this.handleFileChange({ kind: 'unlink', path }));
     }
   }
 
@@ -216,8 +393,33 @@ export class ChangeDetectionService {
       this.debounceTimer = undefined;
     }
 
-    this.unsubscribeModuleGraph?.();
-    this.unsubscribeModuleGraph = undefined;
+    this.unsubscribeFileChange?.();
+    this.unsubscribeFileChange = undefined;
+    this.unsubscribeStartupFailure?.();
+    this.unsubscribeStartupFailure = undefined;
+
+    this.gitDiffProvider?.dispose();
+    // Drain in-flight patches before tearing down the OXC parse pool so no
+    // patch reads the pool after it has been disposed.
+    await this.patchQueue.catch(() => undefined);
+    await disposeOxcParsePool().catch(() => undefined);
+  }
+
+  private async handleFileChange(event: FileChangeEvent): Promise<void> {
+    if (this.disposed || !this.incrementalPatcher) {
+      return;
+    }
+    try {
+      await this.incrementalPatcher.patch(event);
+    } catch (error) {
+      logger.warn(
+        `Change detection: failed to apply ${event.kind} for ${event.path}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (this.disposed) {
+      return;
+    }
+    this.scheduleScan(this.debounceMs);
   }
 
   private scheduleScan(delayMs: number): void {
@@ -232,7 +434,17 @@ export class ChangeDetectionService {
   }
 
   private async scan(): Promise<void> {
-    if (this.disposed || !this.latestModuleGraph) {
+    if (this.disposed || !this.reverseIndex) {
+      return;
+    }
+
+    // Snapshot and drain the current patch chain before reading reverseIndex. Without this
+    // await, a scan triggered mid-patch (between removeStory and the re-walk's recordEdges)
+    // reads a transiently empty reverseIndex and publishes incorrect statuses.
+    const patchSnapshot = this.patchQueue;
+    await patchSnapshot.catch(() => undefined);
+
+    if (this.disposed || !this.reverseIndex) {
       return;
     }
 
@@ -244,7 +456,7 @@ export class ChangeDetectionService {
     this.scanInFlight = true;
 
     try {
-      const nextStatuses = await this.buildStatuses(this.latestModuleGraph);
+      const nextStatuses = await this.buildStatuses(this.reverseIndex);
       if (this.disposed) {
         return;
       }
@@ -291,7 +503,7 @@ export class ChangeDetectionService {
     }
   }
 
-  private async buildStatuses(moduleGraph: ModuleGraph): Promise<Map<string, Status>> {
+  private async buildStatuses(reverseIndex: ReverseIndexImpl): Promise<Map<string, Status>> {
     const gitDiffProvider = this.getGitDiffProvider();
     const [changes, repoRoot, storyIndexGenerator, baselineEntryIds] = await Promise.all([
       gitDiffProvider.getChangedFiles(),
@@ -300,19 +512,13 @@ export class ChangeDetectionService {
       this.getIndexBaselineService().getBaselineEntryIds(),
     ]);
 
-    const changedFiles = new Set(Array.from(changes.changed).map((path) => join(repoRoot, path)));
-    const newFiles = new Set(Array.from(changes.new).map((path) => join(repoRoot, path)));
+    const changedFiles = new Set(
+      Array.from(changes.changed).map((path) => normalize(join(repoRoot, path)))
+    );
+    const newFiles = new Set(
+      Array.from(changes.new).map((path) => normalize(join(repoRoot, path)))
+    );
     const scannedFiles = new Set([...changedFiles, ...newFiles]);
-    const normalizedModuleGraph = new Map<string, Set<ModuleNode>>();
-    moduleGraph.forEach((nodes, filePath) => {
-      const normalizedPath = normalizePath(filePath);
-      const existingNodes = normalizedModuleGraph.get(normalizedPath);
-      if (existingNodes) {
-        nodes.forEach((node) => void existingNodes.add(node));
-      } else {
-        normalizedModuleGraph.set(normalizedPath, new Set(nodes));
-      }
-    });
 
     const storyIndex = await storyIndexGenerator.getIndex();
     const baselineStatuses = buildIndexBaselineStatuses(storyIndex, baselineEntryIds);
@@ -320,16 +526,24 @@ export class ChangeDetectionService {
     const statuses = new Map<string, Status>();
 
     for (const changedFile of scannedFiles) {
-      const affectedStoryFiles = findAffectedStoryFiles(
-        changedFile,
-        normalizedModuleGraph,
-        storyIdsByFile
-      );
-      const lowestDistance = Math.min(
-        ...Array.from(affectedStoryFiles.values(), ({ distance }) => distance)
-      );
+      const affectedStoryFiles = reverseIndex.lookup(changedFile);
+      // Include the changed file as a story-at-distance-0 if it IS a story (parity with
+      // legacy trace-changed.ts:10-12).
+      const allEntries = new Map(affectedStoryFiles);
+      if (storyIdsByFile.has(changedFile)) {
+        allEntries.set(changedFile, 0);
+      }
+      if (allEntries.size === 0) {
+        continue;
+      }
+      let lowestDistance = Number.POSITIVE_INFINITY;
+      for (const distance of allEntries.values()) {
+        if (distance < lowestDistance) {
+          lowestDistance = distance;
+        }
+      }
 
-      for (const [storyFile, { distance }] of affectedStoryFiles.entries()) {
+      for (const [storyFile, distance] of allEntries.entries()) {
         const storyIds = storyIdsByFile.get(storyFile);
         if (!storyIds) {
           continue;
@@ -387,6 +601,10 @@ export class ChangeDetectionService {
       (status) => !isSameStatus(this.previousStatuses.get(status.storyId), status)
     );
 
+    if (removedStoryIds.length === 0 && changedStatuses.length === 0) {
+      return;
+    }
+
     if (removedStoryIds.length > 0) {
       this.options.statusStore.unset(removedStoryIds);
     }
@@ -411,25 +629,4 @@ export class ChangeDetectionService {
     this.readinessResolved = true;
     setChangeDetectionReadiness(readiness);
   }
-
-  private handleBuilderStartupEvent(
-    event: Exclude<ModuleGraphChangeEvent, { type: 'moduleGraph' }>
-  ): void {
-    if (event.type === 'unavailable') {
-      logger.warn(`Change detection unavailable: ${event.reason}`);
-      this.resolveReadiness({
-        status: 'unavailable',
-        reason: event.reason,
-        error: event.error,
-      });
-    } else {
-      logger.error(`Change detection failed: ${event.error.message}`);
-      this.resolveReadiness({
-        status: 'error',
-        error: event.error,
-      });
-    }
-
-    void this.dispose();
-  }
 }
diff --git a/code/core/src/core-server/change-detection/GitDiffProvider.ts b/code/core/src/core-server/change-detection/GitDiffProvider.ts
index 04d3cebfd319..a6326aafd187 100644
--- a/code/core/src/core-server/change-detection/GitDiffProvider.ts
+++ b/code/core/src/core-server/change-detection/GitDiffProvider.ts
@@ -211,6 +211,10 @@ export class GitDiffProvider {
     });
   }
 
+  dispose(): void {
+    this.stopWatching();
+  }
+
   private stopWatching(): void {
     if (this.watchingStopped) {
       return;
diff --git a/code/core/src/core-server/change-detection/adapters/index.ts b/code/core/src/core-server/change-detection/adapters/index.ts
new file mode 100644
index 000000000000..db24f8868698
--- /dev/null
+++ b/code/core/src/core-server/change-detection/adapters/index.ts
@@ -0,0 +1 @@
+export type { ChangeDetectionAdapter, FileChangeEvent, ModuleResolveConfig } from './types.ts';
diff --git a/code/core/src/core-server/change-detection/adapters/types.test.ts b/code/core/src/core-server/change-detection/adapters/types.test.ts
new file mode 100644
index 000000000000..8f9d3043adb0
--- /dev/null
+++ b/code/core/src/core-server/change-detection/adapters/types.test.ts
@@ -0,0 +1,33 @@
+// Type-level smoke tests for the ChangeDetectionAdapter contract.
+import { describe, expectTypeOf, it } from 'vitest';
+
+import type { ChangeDetectionAdapter, FileChangeEvent, ModuleResolveConfig } from './types.ts';
+
+describe('ChangeDetectionAdapter types', () => {
+  it('FileChangeEvent is a discriminated union over add | change | unlink', () => {
+    expectTypeOf<FileChangeEvent>().toEqualTypeOf<
+      | { kind: 'add'; path: string }
+      | { kind: 'change'; path: string }
+      | { kind: 'unlink'; path: string }
+    >();
+  });
+
+  it('ModuleResolveConfig.alias accepts both Record<string, string> and Array<{find, replacement}>', () => {
+    expectTypeOf<Record<string, string>>().toMatchTypeOf<
+      NonNullable<ModuleResolveConfig['alias']>
+    >();
+    expectTypeOf<Array<{ find: string | RegExp; replacement: string }>>().toMatchTypeOf<
+      NonNullable<ModuleResolveConfig['alias']>
+    >();
+  });
+
+  it('ChangeDetectionAdapter.getResolveConfig returns Promise<ModuleResolveConfig>', () => {
+    expectTypeOf<
+      ChangeDetectionAdapter['getResolveConfig']
+    >().returns.resolves.toEqualTypeOf<ModuleResolveConfig>();
+  });
+
+  it('ChangeDetectionAdapter.onFileChange returns an unsubscribe function', () => {
+    expectTypeOf<ChangeDetectionAdapter['onFileChange']>().returns.toEqualTypeOf<() => void>();
+  });
+});
diff --git a/code/core/src/core-server/change-detection/adapters/types.ts b/code/core/src/core-server/change-detection/adapters/types.ts
new file mode 100644
index 000000000000..0db056e5e610
--- /dev/null
+++ b/code/core/src/core-server/change-detection/adapters/types.ts
@@ -0,0 +1,28 @@
+/**
+ * Builder-agnostic change-detection adapter contract.
+ *
+ * The detector is owned by `code/core/src/core-server/change-detection/` and never imports a
+ * builder package. Each builder ships its own `ChangeDetectionAdapter` implementation that
+ * (a) supplies static resolve config once at start, and (b) pushes file-system events as
+ * they occur.
+ *
+ * Builder-vite is the first consumer (see `code/builders/builder-vite/src/change-detection-adapter/`).
+ */
+
+import type { ModuleResolveConfig } from 'storybook/internal/types';
+
+export type { ModuleResolveConfig };
+
+export type FileChangeEvent =
+  | { kind: 'add'; path: string }
+  | { kind: 'change'; path: string }
+  | { kind: 'unlink'; path: string };
+
+export interface ChangeDetectionAdapter {
+  /** Pull: builder produces resolve-config once at start; detector caches it. */
+  getResolveConfig(): Promise<ModuleResolveConfig>;
+  /** Push: builder reports file-system events; returns an unsubscribe function. */
+  onFileChange(handler: (event: FileChangeEvent) => void): () => void;
+  /** Optional: builder reports a startup failure so the detector can mark itself unavailable. */
+  onStartupFailure?(handler: (event: { reason: string; error?: Error }) => void): () => void;
+}
diff --git a/code/core/src/core-server/change-detection/dependency-graph/DependencyGraphBuilder.test.ts b/code/core/src/core-server/change-detection/dependency-graph/DependencyGraphBuilder.test.ts
new file mode 100644
index 000000000000..b71b153ad6fb
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/DependencyGraphBuilder.test.ts
@@ -0,0 +1,348 @@
+// Tests the eager forward-walk performed by DependencyGraphBuilder.
+// We stub readFile + ChangeDetectionResolverFactory, and drive the walker via a real
+// ParserRegistry that dispatches to an in-memory test parser — no oxc binary needed.
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { readFile } from 'node:fs/promises';
+
+import { logger } from 'storybook/internal/node-logger';
+
+import { ParserRegistry } from '../parser-registry/index.ts';
+import type { ImportEdge, ImportParser } from '../parser-registry/index.ts';
+import { DependencyGraphBuilder } from './DependencyGraphBuilder.ts';
+import type { ChangeDetectionResolverFactory } from './ResolverFactory.ts';
+
+vi.mock('node:fs/promises', { spy: true });
+vi.mock('storybook/internal/node-logger', { spy: true });
+
+interface FakeWorld {
+  /** Source files that exist (path -> content). Content is irrelevant — parser is stubbed. */
+  files: Set<string>;
+  /** Per-file outgoing edges, keyed by absolute path. */
+  edges: Map<string, ImportEdge[]>;
+  /** Per-(from, specifier) resolutions; absent → resolver returns null. */
+  resolutions: Map<string, string | null>;
+}
+
+/**
+ * Builds a real ParserRegistry with a single test parser that claims the full set of
+ * walkable JS/TS/MDX extensions. The parser returns per-file precomputed edges from the
+ * FakeWorld, standing in for oxc/mdx parsing in these unit tests.
+ */
+function makeFakeRegistry(world: FakeWorld): ParserRegistry {
+  const testParser: ImportParser = {
+    extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mdx'],
+    parse: vi.fn(async ({ filePath }) => world.edges.get(filePath) ?? []),
+  };
+  return new ParserRegistry({
+    defaultParsers: [testParser],
+    pluginParsers: [],
+  });
+}
+
+function makeFakeResolver(world: FakeWorld): ChangeDetectionResolverFactory {
+  return {
+    resolve: vi.fn(async (from: string, specifier: string) => {
+      const key = `${from}::${specifier}`;
+      return world.resolutions.has(key) ? world.resolutions.get(key)! : null;
+    }),
+  } as unknown as ChangeDetectionResolverFactory;
+}
+
+function setupFsReadOk(world: FakeWorld) {
+  vi.mocked(readFile).mockImplementation(async (path) => {
+    if (!world.files.has(String(path))) {
+      throw Object.assign(new Error(`ENOENT: ${String(path)}`), { code: 'ENOENT' });
+    }
+    return '';
+  });
+}
+
+describe('DependencyGraphBuilder', () => {
+  beforeEach(() => {
+    vi.mocked(logger.debug).mockImplementation(() => undefined);
+    vi.mocked(logger.warn).mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns empty results for an empty story list', async () => {
+    const world: FakeWorld = { files: new Set(), edges: new Map(), resolutions: new Map() };
+    setupFsReadOk(world);
+    const builder = new DependencyGraphBuilder({
+      registry: makeFakeRegistry(world),
+      resolver: makeFakeResolver(world),
+      workspaceRoots: new Set(),
+      projectRoot: '/repo',
+    });
+
+    const { reverseIndex, graph } = await builder.build([]);
+
+    expect(reverseIndex.asMap().size).toBe(0);
+    expect(graph.size).toBe(0);
+  });
+
+  it('records a story with no imports at depth 0 and adds nothing else', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const world: FakeWorld = {
+      files: new Set([story]),
+      edges: new Map([[story, []]]),
+      resolutions: new Map(),
+    };
+    setupFsReadOk(world);
+    const builder = new DependencyGraphBuilder({
+      registry: makeFakeRegistry(world),
+      resolver: makeFakeResolver(world),
+      workspaceRoots: new Set(),
+      projectRoot: '/repo',
+    });
+
+    const { reverseIndex } = await builder.build([story]);
+
+    expect(reverseIndex.lookup(story).get(story)).toBe(0);
+    expect(reverseIndex.asMap().size).toBe(1);
+  });
+
+  it('skips CSS imports (they are not walkable)', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const css = '/repo/src/styles.css';
+    const world: FakeWorld = {
+      files: new Set([story, css]),
+      edges: new Map([[story, [{ specifier: './styles.css', kind: 'static' }]]]),
+      resolutions: new Map([[`${story}::./styles.css`, css]]),
+    };
+    setupFsReadOk(world);
+    const builder = new DependencyGraphBuilder({
+      registry: makeFakeRegistry(world),
+      resolver: makeFakeResolver(world),
+      workspaceRoots: new Set(),
+      projectRoot: '/repo',
+    });
+
+    const { reverseIndex } = await builder.build([story]);
+
+    // CSS resolved into scope so the reverse index DOES record it at depth 1, but the walk
+    // does not recurse into it (no further calls to extractor on it). Verify only story root
+    // and the css leaf appear.
+    expect(reverseIndex.lookup(story).get(story)).toBe(0);
+    // CSS may be present at depth 1 (resolved into scope). Either is fine for this test —
+    // what matters is no transitive walk happened.
+    expect(reverseIndex.asMap().size).toBeLessThanOrEqual(2);
+  });
+
+  it('records sibling JS dep at depth 1 when imported by story', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const sibling = '/repo/src/sibling.ts';
+    const world: FakeWorld = {
+      files: new Set([story, sibling]),
+      edges: new Map([
+        [story, [{ specifier: './sibling.ts', kind: 'static' }]],
+        [sibling, []],
+      ]),
+      resolutions: new Map([[`${story}::./sibling.ts`, sibling]]),
+    };
+    setupFsReadOk(world);
+    const builder = new DependencyGraphBuilder({
+      registry: makeFakeRegistry(world),
+      resolver: makeFakeResolver(world),
+      workspaceRoots: new Set(),
+      projectRoot: '/repo',
+    });
+
+    const { reverseIndex } = await builder.build([story]);
+
+    expect(reverseIndex.lookup(sibling).get(story)).toBe(1);
+  });
+
+  it('walks into a workspace package (resolved into a workspaceRoot)', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const wsMain = '/repo/packages/lib/src/index.ts';
+    const world: FakeWorld = {
+      files: new Set([story, wsMain]),
+      edges: new Map([
+        [story, [{ specifier: '@scope/lib', kind: 'static' }]],
+        [wsMain, []],
+      ]),
+      resolutions: new Map([[`${story}::@scope/lib`, wsMain]]),
+    };
+    setupFsReadOk(world);
+    const builder = new DependencyGraphBuilder({
+      registry: makeFakeRegistry(world),
+      resolver: makeFakeResolver(world),
+      workspaceRoots: new Set(['/repo/packages/lib']),
+      projectRoot: '/repo',
+    });
+
+    const { reverseIndex } = await builder.build([story]);
+
+    expect(reverseIndex.lookup(wsMain).get(story)).toBe(1);
+  });
+
+  it('does NOT walk into a regular node_modules package (resolved outside scope)', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const npmMain = '/repo/node_modules/lodash/index.js';
+    const npmTransitive = '/repo/node_modules/lodash/util.js';
+    const registry = makeFakeRegistry({
+      files: new Set(),
+      edges: new Map([
+        [story, [{ specifier: 'lodash', kind: 'static' }]],
+        [npmMain, [{ specifier: './util', kind: 'static' }]],
+      ]),
+      resolutions: new Map(),
+    });
+    const resolver = {
+      resolve: vi.fn(async (from: string, spec: string) => {
+        if (from === story && spec === 'lodash') {
+          return npmMain;
+        }
+        if (from === npmMain && spec === './util') {
+          return npmTransitive;
+        }
+        return null;
+      }),
+    } as unknown as ChangeDetectionResolverFactory;
+    setupFsReadOk({
+      files: new Set([story, npmMain, npmTransitive]),
+      edges: new Map(),
+      resolutions: new Map(),
+    });
+    const builder = new DependencyGraphBuilder({
+      registry,
+      resolver,
+      workspaceRoots: new Set(),
+      projectRoot: '/repo',
+    });
+
+    const { reverseIndex } = await builder.build([story]);
+
+    // npmMain resolved out of scope — neither it nor its transitive dep should appear.
+    expect(reverseIndex.asMap().has(npmMain)).toBe(false);
+    expect(reverseIndex.asMap().has(npmTransitive)).toBe(false);
+  });
+
+  it('records two stories importing the same shared dep with their independent depths', async () => {
+    const a = '/repo/src/A.stories.tsx';
+    const b = '/repo/src/B.stories.tsx';
+    const intermediate = '/repo/src/intermediate.ts';
+    const shared = '/repo/src/shared.ts';
+    const world: FakeWorld = {
+      files: new Set([a, b, intermediate, shared]),
+      edges: new Map([
+        [a, [{ specifier: './shared.ts', kind: 'static' }]],
+        [b, [{ specifier: './intermediate.ts', kind: 'static' }]],
+        [intermediate, [{ specifier: './shared.ts', kind: 'static' }]],
+        [shared, []],
+      ]),
+      resolutions: new Map([
+        [`${a}::./shared.ts`, shared],
+        [`${b}::./intermediate.ts`, intermediate],
+        [`${intermediate}::./shared.ts`, shared],
+      ]),
+    };
+    setupFsReadOk(world);
+    const builder = new DependencyGraphBuilder({
+      registry: makeFakeRegistry(world),
+      resolver: makeFakeResolver(world),
+      workspaceRoots: new Set(),
+      projectRoot: '/repo',
+    });
+
+    const { reverseIndex } = await builder.build([a, b]);
+
+    const inner = reverseIndex.lookup(shared);
+    expect(inner.get(a)).toBe(1);
+    expect(inner.get(b)).toBe(2);
+  });
+
+  it('skips one specifier that fails to resolve but records the other edges from the same file', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const ok = '/repo/src/ok.ts';
+    const world: FakeWorld = {
+      files: new Set([story, ok]),
+      edges: new Map([
+        [
+          story,
+          [
+            { specifier: './missing', kind: 'static' },
+            { specifier: './ok.ts', kind: 'static' },
+          ],
+        ],
+        [ok, []],
+      ]),
+      // Only the ./ok.ts specifier resolves; ./missing has no entry => null.
+      resolutions: new Map([[`${story}::./ok.ts`, ok]]),
+    };
+    setupFsReadOk(world);
+    const builder = new DependencyGraphBuilder({
+      registry: makeFakeRegistry(world),
+      resolver: makeFakeResolver(world),
+      workspaceRoots: new Set(),
+      projectRoot: '/repo',
+    });
+
+    const { reverseIndex } = await builder.build([story]);
+
+    expect(reverseIndex.lookup(ok).get(story)).toBe(1);
+  });
+
+  it('resolves each shared module exactly once regardless of how many stories reach it', async () => {
+    const storyA = '/repo/src/A.stories.tsx';
+    const storyB = '/repo/src/B.stories.tsx';
+    const shared = '/repo/src/shared.ts';
+    const world: FakeWorld = {
+      files: new Set([storyA, storyB, shared]),
+      edges: new Map([
+        [storyA, [{ specifier: './shared.ts', kind: 'static' }]],
+        [storyB, [{ specifier: './shared.ts', kind: 'static' }]],
+        [shared, [{ specifier: './nothing.ts', kind: 'static' }]],
+      ]),
+      resolutions: new Map([
+        [`${storyA}::./shared.ts`, shared],
+        [`${storyB}::./shared.ts`, shared],
+        // shared's outgoing edge fails to resolve — we only care that resolver is called once
+        // for shared, not once per story walk that reaches it.
+      ]),
+    };
+    setupFsReadOk(world);
+    const resolver = makeFakeResolver(world);
+    const builder = new DependencyGraphBuilder({
+      registry: makeFakeRegistry(world),
+      resolver,
+      workspaceRoots: new Set(),
+      projectRoot: '/repo',
+    });
+
+    await builder.build([storyA, storyB]);
+
+    // Without the resolve cache, `shared.ts`'s single outgoing edge would be resolved twice
+    // (once per story walk that visits it). With the cache, it is resolved exactly once.
+    const sharedEdgeResolves = vi
+      .mocked(resolver.resolve)
+      .mock.calls.filter(([from]) => from === shared);
+    expect(sharedEdgeResolves).toHaveLength(1);
+  });
+
+  it('emits a debug log line on completion', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const world: FakeWorld = {
+      files: new Set([story]),
+      edges: new Map([[story, []]]),
+      resolutions: new Map(),
+    };
+    setupFsReadOk(world);
+    const builder = new DependencyGraphBuilder({
+      registry: makeFakeRegistry(world),
+      resolver: makeFakeResolver(world),
+      workspaceRoots: new Set(),
+      projectRoot: '/repo',
+    });
+
+    await builder.build([story]);
+
+    expect(vi.mocked(logger.debug)).toHaveBeenCalledWith(
+      expect.stringContaining('Change detection graph built:')
+    );
+  });
+});
diff --git a/code/core/src/core-server/change-detection/dependency-graph/DependencyGraphBuilder.ts b/code/core/src/core-server/change-detection/dependency-graph/DependencyGraphBuilder.ts
new file mode 100644
index 000000000000..fffe2d7d4761
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/DependencyGraphBuilder.ts
@@ -0,0 +1,92 @@
+import { cpus } from 'node:os';
+
+import pLimit from 'p-limit';
+import { normalize } from 'pathe';
+
+import { logger as defaultLogger } from 'storybook/internal/node-logger';
+
+import type { ParserRegistry } from '../parser-registry/index.ts';
+import { ParseResolveCache } from './ParseResolveCache.ts';
+import { ReverseIndexImpl } from './ReverseIndex.ts';
+import type { ChangeDetectionResolverFactory } from './ResolverFactory.ts';
+import type { DependencyGraph } from './types.ts';
+import { walkFromStory } from './walkFromStory.ts';
+
+interface BuilderLogger {
+  debug: (message: string) => void;
+  warn: (message: string) => void;
+}
+
+interface BuilderOptions {
+  registry: ParserRegistry;
+  resolver: ChangeDetectionResolverFactory;
+  workspaceRoots: Set<string>;
+  projectRoot: string;
+  logger?: BuilderLogger;
+  /**
+   * Optional shared cache. Pass the same instance to {@link IncrementalPatcher} so
+   * post-build incremental walks skip work the cold-start build already did. When
+   * omitted, the builder constructs a private cache that lives only for one `build()`.
+   */
+  cache?: ParseResolveCache;
+}
+
+/**
+ * Eagerly builds a {@link ReverseIndexImpl} + {@link DependencyGraph} by BFS-walking forward
+ * from each story file. Walks stop at workspace boundaries, non-JS extensions, or unresolved
+ * specifiers. Per-file errors (read failure, parse failure, individual unresolved specifiers)
+ * are swallowed and result in fewer recorded deps for that file — not a build failure.
+ * Graceful degradation ensures one bad file cannot crash change-detection for all stories.
+ */
+export class DependencyGraphBuilder {
+  private readonly registry: ParserRegistry;
+  private readonly logger: BuilderLogger;
+  private readonly cache: ParseResolveCache;
+
+  constructor(opts: BuilderOptions) {
+    this.registry = opts.registry;
+    this.logger = opts.logger ?? defaultLogger;
+    this.cache =
+      opts.cache ??
+      new ParseResolveCache({
+        registry: opts.registry,
+        resolver: opts.resolver,
+        workspaceRoots: opts.workspaceRoots,
+        projectRoot: opts.projectRoot,
+        logger: this.logger,
+      });
+  }
+
+  async build(
+    storyFiles: Iterable<string>
+  ): Promise<{ reverseIndex: ReverseIndexImpl; graph: DependencyGraph }> {
+    const startedAt = Date.now();
+    const reverseIndex = new ReverseIndexImpl();
+    const graph: DependencyGraph = new Map();
+
+    const limit = pLimit(cpus().length * 2);
+
+    const stories = Array.from(storyFiles, (s) => normalize(s));
+
+    await Promise.all(
+      stories.map((story) =>
+        limit(() =>
+          walkFromStory({
+            storyRoot: story,
+            registry: this.registry,
+            cache: this.cache,
+            reverseIndex,
+            recordEdges: (file, deps) => graph.set(file, deps),
+          })
+        )
+      )
+    );
+
+    const elapsed = Date.now() - startedAt;
+    this.logger.debug(
+      `Change detection graph built: ${stories.length} stories, ${reverseIndex.asMap().size} deps tracked, ${elapsed}ms`
+    );
+
+    return { reverseIndex, graph };
+  }
+}
diff --git a/code/core/src/core-server/change-detection/dependency-graph/IncrementalPatcher.ts b/code/core/src/core-server/change-detection/dependency-graph/IncrementalPatcher.ts
new file mode 100644
index 000000000000..af00eedee8f1
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/IncrementalPatcher.ts
@@ -0,0 +1,160 @@
+import { normalize } from 'pathe';
+
+import { logger as defaultLogger } from 'storybook/internal/node-logger';
+
+import type { FileChangeEvent } from '../adapters/types.ts';
+import type { ParserRegistry } from '../parser-registry/index.ts';
+import { ParseResolveCache } from './ParseResolveCache.ts';
+import type { ReverseIndexImpl } from './ReverseIndex.ts';
+import type { ChangeDetectionResolverFactory } from './ResolverFactory.ts';
+import type { DependencyGraph } from './types.ts';
+import { walkFromStory } from './walkFromStory.ts';
+
+function setsEqual(a: Set<string>, b: Set<string>): boolean {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const item of a) {
+    if (!b.has(item)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+interface PatcherLogger {
+  debug: (message: string) => void;
+  warn: (message: string) => void;
+}
+
+interface PatcherOptions {
+  reverseIndex: ReverseIndexImpl;
+  graph: DependencyGraph;
+  registry: ParserRegistry;
+  resolver: ChangeDetectionResolverFactory;
+  workspaceRoots: Set<string>;
+  projectRoot: string;
+  logger?: PatcherLogger;
+  /** Set-style predicate: returns true if the path is a story-root file. */
+  isStoryFile: (path: string) => boolean;
+  /**
+   * Optional shared cache. When the patcher and {@link DependencyGraphBuilder} share the
+   * same instance, post-build incremental walks reuse parse + resolve results from the
+   * cold-start build. The patcher invalidates `path` on every `change`/`unlink` event
+   * before reading.
+   */
+  cache?: ParseResolveCache;
+}
+
+/**
+ * Applies a single {@link FileChangeEvent} to the live reverse index + graph.
+ *
+ * `patch()` mutates `graph` and `reverseIndex` across multiple `await` points, so the caller
+ * MUST serialise concurrent calls; {@link ChangeDetectionService} chains them through
+ * `patchQueue`.
+ *
+ * Known limitation: files that are unresolved at cold-start (resolver returns null so they
+ * never enter the graph) are not automatically reconnected when they later appear on disk.
+ * A full rebuild is required to pick them up.
+ */
+export class IncrementalPatcher {
+  private readonly reverseIndex: ReverseIndexImpl;
+  private readonly graph: DependencyGraph;
+  private readonly registry: ParserRegistry;
+  private readonly logger: PatcherLogger;
+  private readonly isStoryFile: (path: string) => boolean;
+  private readonly cache: ParseResolveCache;
+
+  constructor(opts: PatcherOptions) {
+    this.reverseIndex = opts.reverseIndex;
+    this.graph = opts.graph;
+    this.registry = opts.registry;
+    this.logger = opts.logger ?? defaultLogger;
+    this.isStoryFile = opts.isStoryFile;
+    this.cache =
+      opts.cache ??
+      new ParseResolveCache({
+        registry: opts.registry,
+        resolver: opts.resolver,
+        workspaceRoots: opts.workspaceRoots,
+        projectRoot: opts.projectRoot,
+        logger: this.logger,
+      });
+  }
+
+  async patch(event: FileChangeEvent): Promise<void> {
+    const path = normalize(event.path);
+    // File contents may have changed (or the file is gone); drop any stale cached
+    // parse/resolve data before any read.
+    this.cache.invalidate(path);
+
+    if (event.kind === 'add') {
+      if (this.isStoryFile(path)) {
+        await this.walkStory(path);
+      }
+      // Non-story add: the documented limitation says we don't recover unresolved deps.
+      return;
+    }
+
+    if (event.kind === 'unlink') {
+      const dependentsSet = new Set(this.reverseIndex.lookup(path).keys());
+      this.graph.delete(path);
+      if (this.isStoryFile(path)) {
+        this.reverseIndex.removeStory(path);
+      }
+      // Re-walk every dependent story so transitive deps reachable only through `path`
+      // are pruned.
+      const storiesToWalk: string[] = [];
+      for (const story of dependentsSet) {
+        if (story === path || !this.isStoryFile(story)) {
+          continue;
+        }
+        this.reverseIndex.removeStory(story);
+        storiesToWalk.push(story);
+      }
+      await Promise.all(storiesToWalk.map((story) => this.walkStory(story)));
+      return;
+    }
+
+    // 'change' on an existing file: re-walk every story that depends on this file
+    // (plus the file itself if it's a story). The walk re-resolves dependencies via
+    // the cache (already invalidated above) and rebuilds the relevant slice of the
+    // graph and reverse-index.
+    const affectedStories = new Set(this.reverseIndex.lookup(path).keys());
+    if (this.isStoryFile(path)) {
+      affectedStories.add(path);
+    }
+
+    // Skip re-walk when the file's direct dependency set is unchanged (e.g. on a
+    // comment-only or logic-only edit). The graph and reverse-index remain accurate.
+    const oldDeps = this.graph.get(path);
+    if (oldDeps !== undefined) {
+      const newDeps = await this.cache.resolveOnce(path);
+      if (setsEqual(oldDeps, newDeps)) {
+        return;
+      }
+    }
+
+    const storiesToWalk: string[] = [];
+    for (const story of affectedStories) {
+      if (!this.isStoryFile(story)) {
+        continue;
+      }
+      this.reverseIndex.removeStory(story);
+      storiesToWalk.push(story);
+    }
+    await Promise.all(storiesToWalk.map((story) => this.walkStory(story)));
+  }
+
+  private walkStory(storyRoot: string): Promise<void> {
+    return walkFromStory({
+      storyRoot,
+      registry: this.registry,
+      cache: this.cache,
+      reverseIndex: this.reverseIndex,
+      recordEdges: (file, deps) => {
+        this.graph.set(file, deps);
+      },
+    });
+  }
+}
diff --git a/code/core/src/core-server/change-detection/dependency-graph/ParseResolveCache.ts b/code/core/src/core-server/change-detection/dependency-graph/ParseResolveCache.ts
new file mode 100644
index 000000000000..f4eb39a928e9
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/ParseResolveCache.ts
@@ -0,0 +1,122 @@
+import { readFile } from 'node:fs/promises';
+
+import { normalize } from 'pathe';
+
+import type { ParserRegistry } from '../parser-registry/index.ts';
+import type { ImportEdge } from './types.ts';
+import type { ChangeDetectionResolverFactory } from './ResolverFactory.ts';
+import { isInScope } from './scope.ts';
+
+interface CacheLogger {
+  debug: (message: string) => void;
+  warn: (message: string) => void;
+}
+
+interface CacheOptions {
+  registry: ParserRegistry;
+  resolver: ChangeDetectionResolverFactory;
+  workspaceRoots: Set<string>;
+  projectRoot: string;
+  logger: CacheLogger;
+}
+
+/**
+ * Long-lived parse + resolve cache shared across cold-start build and incremental patch.
+ *
+ * Both layers were re-parsing and re-resolving every shared module on every walk before
+ * this cache existed (`DependencyGraphBuilder` had per-build caches; the patcher had none
+ * at all). Promoting the caches to instance scope and invalidating on file-change events
+ * collapses the redundant work without sacrificing correctness — `change`/`unlink` events
+ * call {@link invalidate} before the patcher reads, so a stale entry can never survive.
+ */
+export class ParseResolveCache {
+  private readonly registry: ParserRegistry;
+  private readonly resolver: ChangeDetectionResolverFactory;
+  private readonly workspaceRoots: Set<string>;
+  private readonly projectRoot: string;
+  private readonly logger: CacheLogger;
+
+  private readonly parseCache = new Map<string, Promise<ImportEdge[]>>();
+  private readonly resolveCache = new Map<string, Promise<Set<string>>>();
+
+  constructor(opts: CacheOptions) {
+    this.registry = opts.registry;
+    this.resolver = opts.resolver;
+    this.workspaceRoots = new Set(Array.from(opts.workspaceRoots, (r) => normalize(r)));
+    this.projectRoot = normalize(opts.projectRoot);
+    this.logger = opts.logger;
+  }
+
+  /**
+   * Parses the file once and caches the resulting edge list. Returns `[]` for unreadable
+   * files, parse failures, or files whose extension has no registered parser — callers
+   * cannot distinguish between "no edges" and "we couldn't look", which is by design:
+   * either way the file contributes nothing to the dependency graph.
+   */
+  parseOnce(filePath: string): Promise<ImportEdge[]> {
+    const existing = this.parseCache.get(filePath);
+    if (existing) {
+      return existing;
+    }
+    const promise = (async (): Promise<ImportEdge[]> => {
+      let source: string;
+      try {
+        source = await readFile(filePath, 'utf8');
+      } catch (error) {
+        this.logger.debug(
+          `Change detection: could not read ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return [];
+      }
+      try {
+        return (await this.registry.parse(filePath, source)) ?? [];
+      } catch (error) {
+        this.logger.debug(
+          `Change detection: failed to parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return [];
+      }
+    })();
+    this.parseCache.set(filePath, promise);
+    return promise;
+  }
+
+  /** Resolves every in-scope edge declared by `filePath` and returns the dep Set. */
+  resolveOnce(filePath: string): Promise<Set<string>> {
+    const existing = this.resolveCache.get(filePath);
+    if (existing) {
+      return existing;
+    }
+    const promise = (async (): Promise<Set<string>> => {
+      const edges = await this.parseOnce(filePath);
+      const deps = new Set<string>();
+      for (const edge of edges) {
+        const resolved = await this.resolver.resolve(filePath, edge.specifier);
+        if (resolved === null) {
+          this.logger.debug(`Could not resolve ${edge.specifier} from ${filePath}`);
+          continue;
+        }
+        const normalised = normalize(resolved);
+        if (!isInScope(normalised, this.projectRoot, this.workspaceRoots)) {
+          continue;
+        }
+        deps.add(normalised);
+      }
+      return deps;
+    })();
+    this.resolveCache.set(filePath, promise);
+    return promise;
+  }
+
+  /** Drops both cached entries for `filePath`. Call on every `change`/`unlink` event. */
+  invalidate(filePath: string): void {
+    this.parseCache.delete(filePath);
+    this.resolveCache.delete(filePath);
+  }
+
+  /** Test-only: full reset. */
+  clear(): void {
+    this.parseCache.clear();
+    this.resolveCache.clear();
+  }
+}
diff --git a/code/core/src/core-server/change-detection/dependency-graph/ResolverFactory.test.ts b/code/core/src/core-server/change-detection/dependency-graph/ResolverFactory.test.ts
new file mode 100644
index 000000000000..f252f29d8e89
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/ResolverFactory.test.ts
@@ -0,0 +1,248 @@
+/**
+ * Integration tests for ChangeDetectionResolverFactory alias and tsconfig path resolution.
+ *
+ * These tests use real file system access and the real oxc-resolver binary so that we catch
+ * oxc-resolver behavioural differences (e.g. trailing-slash alias keys not working, tsconfig
+ * path resolution) rather than just testing our own normalisation logic.
+ */
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { ChangeDetectionResolverFactory } from './ResolverFactory.ts';
+
+let dir: string;
+
+beforeEach(() => {
+  // realpathSync resolves macOS /var → /private/var symlink so path comparisons work
+  dir = realpathSync(mkdtempSync(join(tmpdir(), 'sb-resolver-test-')));
+});
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function write(relPath: string, content = 'export {};') {
+  const abs = join(dir, relPath);
+  mkdirSync(join(dir, relPath, '..'), { recursive: true });
+  writeFileSync(abs, content);
+  return abs;
+}
+
+function tsconfig(compilerOptions: Record<string, unknown>, filename = 'tsconfig.json') {
+  const abs = join(dir, filename);
+  writeFileSync(abs, JSON.stringify({ compilerOptions }));
+  return abs;
+}
+
+describe('ChangeDetectionResolverFactory', () => {
+  describe('no alias, no tsconfig', () => {
+    it('resolves relative imports', async () => {
+      const a = write('src/a.ts');
+      const b = write('src/b.ts');
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(a, './b')).toBe(b);
+    });
+
+    it('returns null for bare specifiers without node_modules', async () => {
+      const a = write('src/a.ts');
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(a, 'react')).toBeNull();
+    });
+  });
+
+  describe('explicit alias (Record form)', () => {
+    it('resolves alias to absolute path', async () => {
+      const target = write('src/utils/index.ts');
+      const from = write('src/components/Foo.ts');
+      const r = new ChangeDetectionResolverFactory({
+        projectRoot: dir,
+        alias: { utils: join(dir, 'src/utils') },
+      });
+      expect(await r.resolve(from, 'utils/index')).toBe(target);
+    });
+
+    it('strips trailing slash from alias key (oxc-resolver does not support @/ prefix keys)', async () => {
+      const target = write('src/app/Component.ts');
+      const from = write('src/pages/Page.ts');
+      // "@/" with trailing slash would fail in raw oxc-resolver; we normalise it to "@"
+      const r = new ChangeDetectionResolverFactory({
+        projectRoot: dir,
+        alias: { '@/': join(dir, 'src') + '/' },
+      });
+      expect(await r.resolve(from, '@/app/Component')).toBe(target);
+    });
+  });
+
+  describe('explicit alias (Array form)', () => {
+    it('resolves array alias with string find', async () => {
+      const target = write('src/utils/helper.ts');
+      const from = write('src/a.ts');
+      const r = new ChangeDetectionResolverFactory({
+        projectRoot: dir,
+        alias: [{ find: 'utils', replacement: join(dir, 'src/utils') }],
+      });
+      expect(await r.resolve(from, 'utils/helper')).toBe(target);
+    });
+
+    it('strips trailing slash from array alias find', async () => {
+      const target = write('src/shared/util.ts');
+      const from = write('src/a.ts');
+      const r = new ChangeDetectionResolverFactory({
+        projectRoot: dir,
+        alias: [{ find: '~@/', replacement: join(dir, 'src') + '/' }],
+      });
+      expect(await r.resolve(from, '~@/shared/util')).toBe(target);
+    });
+
+    it('returns null and does not throw for regex aliases (unsupported, opaque-leaf)', async () => {
+      const from = write('src/a.ts');
+      write('src/utils/foo.ts');
+      const r = new ChangeDetectionResolverFactory({
+        projectRoot: dir,
+        alias: [{ find: /^utils\/(.*)/, replacement: join(dir, 'src/utils/$1') }],
+      });
+      expect(await r.resolve(from, 'utils/foo')).toBeNull();
+    });
+  });
+
+  describe('tsconfig path aliases (auto-discovered via resolveFileAsync)', () => {
+    it('resolves standard wildcard pattern "@/*"', async () => {
+      const target = write('src/components/Button.tsx');
+      const from = write('src/pages/Home.tsx');
+      tsconfig({ baseUrl: '.', paths: { '@/*': ['./*'] } });
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(from, '@/src/components/Button')).toBe(target);
+    });
+
+    it('resolves named wildcard pattern "components/*"', async () => {
+      const target = write('src/ui/Button.tsx');
+      const from = write('src/pages/Home.tsx');
+      tsconfig({ baseUrl: '.', paths: { 'components/*': ['src/ui/*'] } });
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(from, 'components/Button')).toBe(target);
+    });
+
+    it('resolves multiple tsconfig path entries', async () => {
+      const btn = write('src/ui/Button.tsx');
+      const util = write('src/helpers/format.ts');
+      const from = write('src/pages/Home.tsx');
+      tsconfig({
+        baseUrl: '.',
+        paths: {
+          'components/*': ['src/ui/*'],
+          'helpers/*': ['src/helpers/*'],
+        },
+      });
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(from, 'components/Button')).toBe(btn);
+      expect(await r.resolve(from, 'helpers/format')).toBe(util);
+    });
+
+    it('explicit alias and tsconfig wildcard paths resolve consistently', async () => {
+      const target = write('src/ui/Button.tsx');
+      const from = write('src/pages/Home.tsx');
+      tsconfig({ baseUrl: '.', paths: { '@/*': ['src/ui/*'] } });
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(from, '@/Button')).toBe(target);
+    });
+
+    it('returns null for tsconfig path alias when no tsconfig exists', async () => {
+      const from = write('src/a.ts');
+      // No tsconfig.json written — @/* has no resolver backing
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(from, '@/src/a')).toBeNull();
+    });
+
+    it('handles tsconfig without baseUrl (paths relative to tsconfig dir)', async () => {
+      const target = write('src/components/Button.tsx');
+      const from = write('src/pages/Home.tsx');
+      // No baseUrl — TypeScript resolves paths relative to tsconfig dir
+      tsconfig({ paths: { '@/*': ['src/*'] } });
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(from, '@/components/Button')).toBe(target);
+    });
+
+    it('resolves "@/*": ["./*"] from deeply nested source file (dify-plus pattern)', async () => {
+      // Reproduces: @/app/components/base/icons/IconBase unresolved from
+      // app/components/base/icons/src/vender/line/others/Tools.tsx
+      // oxc-resolver's resolveFileAsync walks up from the file to find tsconfig.json
+      const target = write('app/components/base/icons/IconBase.tsx');
+      const from = write('app/components/base/icons/src/vender/line/others/Tools.tsx');
+      tsconfig({ paths: { '@/*': ['./*'], '~@/*': ['./*'] } });
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(from, '@/app/components/base/icons/IconBase')).toBe(target);
+    });
+  });
+
+  /**
+   * Yarn-workspace cross-package resolution
+   *
+   * In a monorepo the root `tsconfig.json` typically maps workspace package names to their
+   * source directories (e.g. "@mantinex/*" -> ["./packages/@mantinex/ * /src"]).  Per-package
+   * tsconfigs often do NOT extend the root, so `tsconfig: 'auto'` only sees the nearest
+   * (package-level) tsconfig and misses these workspace paths -> NotFound("@mantinex/demo").
+   *
+   * The fix in ResolverFactory uses the root tsconfig explicitly when it exists, so that
+   * workspace-level path mappings are always consulted.
+   */
+  describe('yarn workspace cross-package resolution', () => {
+    it('resolves workspace sibling via root tsconfig paths when package-level tsconfig has no mapping', async () => {
+      // Reproduces: @mantinex/demo unresolved from packages/@docs/demos/src/.../YearPicker/
+      // Root tsconfig has "@mantinex/*" paths; package tsconfig has no paths and no extends.
+      const target = write('packages/@mantinex/demo/src/index.ts');
+      // Package-level tsconfig — no paths, no extends (mirrors real mantine setup)
+      mkdirSync(join(dir, 'packages/@docs/demos'), { recursive: true });
+      writeFileSync(
+        join(dir, 'packages/@docs/demos/tsconfig.json'),
+        JSON.stringify({ compilerOptions: {} })
+      );
+      // Root tsconfig — maps workspace packages to source directories
+      tsconfig({ paths: { '@mantinex/*': ['./packages/@mantinex/*/src'] } });
+      const from = write(
+        'packages/@docs/demos/src/demos/dates/YearPicker/YearPicker.demo.controlProps.tsx'
+      );
+
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(from, '@mantinex/demo')).toBe(target);
+    });
+
+    it('resolves workspace sibling via node_modules symlink (yarn workspaces classic linker)', async () => {
+      // yarn workspace classic linker symlinks workspace packages at root node_modules.
+      // The resolver must traverse up past sub-package boundaries to reach root node_modules.
+      const target = write('packages/@mantinex/demo/src/index.ts');
+      writeFileSync(
+        join(dir, 'packages/@mantinex/demo/package.json'),
+        JSON.stringify({ name: '@mantinex/demo', main: './src/index.ts' })
+      );
+      const from = write('packages/@docs/demos/src/demos/dates/YearPicker/file.tsx');
+
+      mkdirSync(join(dir, 'node_modules/@mantinex'), { recursive: true });
+      symlinkSync(
+        join(dir, 'packages/@mantinex/demo'),
+        join(dir, 'node_modules/@mantinex/demo'),
+        'dir'
+      );
+
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(from, '@mantinex/demo')).toBe(target);
+    });
+
+    it('resolves multiple workspace siblings from the same root tsconfig paths', async () => {
+      const demoTarget = write('packages/@mantinex/demo/src/index.ts');
+      const iconsTarget = write('packages/@mantinex/dev-icons/src/index.ts');
+      tsconfig({
+        paths: {
+          '@mantinex/*': ['./packages/@mantinex/*/src'],
+        },
+      });
+      const from = write('packages/@docs/demos/src/file.tsx');
+
+      const r = new ChangeDetectionResolverFactory({ projectRoot: dir });
+      expect(await r.resolve(from, '@mantinex/demo')).toBe(demoTarget);
+      expect(await r.resolve(from, '@mantinex/dev-icons')).toBe(iconsTarget);
+    });
+  });
+});
diff --git a/code/core/src/core-server/change-detection/dependency-graph/ResolverFactory.ts b/code/core/src/core-server/change-detection/dependency-graph/ResolverFactory.ts
new file mode 100644
index 000000000000..250c30611f47
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/ResolverFactory.ts
@@ -0,0 +1,159 @@
+import { join } from 'node:path';
+
+import { ResolverFactory as OxcResolverFactory } from 'oxc-resolver';
+
+import { logger } from 'storybook/internal/node-logger';
+
+import type { ModuleResolveConfig } from '../adapters/types.ts';
+
+const DEFAULT_EXTENSIONS = ['.tsx', '.ts', '.d.ts', '.jsx', '.js', '.mjs', '.cjs', '.json'];
+const DEFAULT_CONDITIONS = ['storybook', 'import', 'module', 'default'];
+
+/**
+ * `ModuleResolveConfig.alias` accepts both Vite shapes:
+ *   - `Record<string, string>` (object form)
+ *   - `Array<{ find: string | RegExp; replacement: string }>` (array form)
+ *
+ * `oxc-resolver` expects `Record<string, Array<string | undefined | null>>`.
+ * RegExp `find` entries cannot be expressed in oxc-resolver's alias config and
+ * are skipped with a debug log (downgraded to opaque-leaf at resolve time).
+ *
+ * Instance-scoped so each ChangeDetectionResolverFactory warns independently —
+ * multiple service instances in the same process do not suppress each other's warnings.
+ */
+class AliasNormalizer {
+  private readonly warnedRegexAliases = new Set<string>();
+
+  normalize(
+    alias: ModuleResolveConfig['alias']
+  ): Record<string, Array<string | undefined | null>> | undefined {
+    if (!alias) {
+      return undefined;
+    }
+
+    const out: Record<string, Array<string | undefined | null>> = {};
+    const skippedRegex: string[] = [];
+
+    if (Array.isArray(alias)) {
+      for (const entry of alias) {
+        if (typeof entry.find === 'string') {
+          const find = entry.find.replace(/\/$/, '');
+          const replacement = entry.replacement.replace(/\/$/, '');
+          out[find] = [replacement];
+        } else {
+          skippedRegex.push(String(entry.find));
+        }
+      }
+    } else {
+      for (const [find, replacement] of Object.entries(alias)) {
+        out[find.replace(/\/$/, '')] = [replacement.replace(/\/$/, '')];
+      }
+    }
+
+    if (skippedRegex.length > 0) {
+      const newPatterns = skippedRegex.filter((p) => !this.warnedRegexAliases.has(p));
+      if (newPatterns.length > 0) {
+        for (const p of newPatterns) {
+          this.warnedRegexAliases.add(p);
+        }
+        logger.warn(
+          `Change detection: ignored ${skippedRegex.length} regex alias(es); related modules tracked as opaque-leaf.`
+        );
+        logger.debug(
+          `ChangeDetectionResolverFactory: skipped regex aliases [${skippedRegex.join(', ')}]`
+        );
+      } else {
+        for (const pattern of skippedRegex) {
+          logger.debug(`ChangeDetectionResolverFactory: skipping regex alias '${pattern}'`);
+        }
+      }
+    }
+
+    return Object.keys(out).length > 0 ? out : undefined;
+  }
+}
+
+/**
+ * Thin wrapper around `oxc-resolver`'s `ResolverFactory` configured per a
+ * builder-supplied {@link ModuleResolveConfig}. Normalizes the alias map shape and
+ * converts resolver errors to `null` (with a debug log) — the caller treats
+ * unresolvable specifiers as opaque-leaf edges.
+ */
+export class ChangeDetectionResolverFactory {
+  private readonly factory: OxcResolverFactory;
+  private readonly aliasNormalizer = new AliasNormalizer();
+  /**
+   * Virtual entry point placed directly in the project root.
+   *
+   * Used as the fallback `from` path when the primary resolution fails.
+   * Resolving from here guarantees that `resolveFileAsync`'s tsconfig
+   * walk-up reaches the root `tsconfig.json` before any intermediate
+   * per-package tsconfig — so workspace-level `paths` mappings are
+   * consulted even when the per-package tsconfig does not extend root.
+   */
+  private readonly projectRootEntry: string;
+
+  constructor(config: ModuleResolveConfig) {
+    const alias = this.aliasNormalizer.normalize(config.alias);
+    const conditionNames = config.conditions ?? DEFAULT_CONDITIONS;
+
+    this.factory = new OxcResolverFactory({
+      tsconfig: 'auto',
+      alias,
+      conditionNames,
+      extensions: DEFAULT_EXTENSIONS,
+    });
+
+    this.projectRootEntry = join(config.projectRoot, '__sb_resolver_root__.ts');
+  }
+
+  /**
+   * Resolves `specifier` from the file at `from` (must be an absolute path).
+   *
+   * Two-pass strategy:
+   * 1. Resolve from `from` — handles per-package tsconfig paths and local node_modules.
+   * 2. On failure, retry from the project root — picks up root-level tsconfig `paths`
+   *    (e.g. workspace package aliases) that intermediate per-package tsconfigs may
+   *    not inherit, as well as root-level node_modules symlinks.
+   *
+   * Returns the absolute resolved path, or `null` if both passes fail.
+   * Never throws — internal errors are converted to `null` and a debug-level log
+   * line is emitted.
+   */
+  async resolve(from: string, specifier: string): Promise<string | null> {
+    try {
+      const result = await this.factory.resolveFileAsync(from, specifier);
+      if (result.path) {
+        return result.path;
+      }
+
+      // Fallback: retry from the project root so that root-level tsconfig paths
+      // and root node_modules are consulted.  Skip the fallback when `from` is
+      // already the virtual root entry to avoid a redundant second attempt.
+      if (from !== this.projectRootEntry) {
+        const rootResult = await this.factory.resolveFileAsync(this.projectRootEntry, specifier);
+        if (rootResult.path) {
+          return rootResult.path;
+        }
+        if (result.error ?? rootResult.error) {
+          logger.debug(
+            `ChangeDetectionResolverFactory: '${specifier}' from '${from}' unresolved (${result.error ?? rootResult.error})`
+          );
+        }
+        return null;
+      }
+
+      if (result.error) {
+        logger.debug(
+          `ChangeDetectionResolverFactory: '${specifier}' from '${from}' unresolved (${result.error})`
+        );
+      }
+      return null;
+    } catch (error) {
+      logger.debug(
+        `ChangeDetectionResolverFactory: error resolving '${specifier}' from '${from}': ${String(error)}`
+      );
+      return null;
+    }
+  }
+}
diff --git a/code/core/src/core-server/change-detection/dependency-graph/ReverseIndex.test.ts b/code/core/src/core-server/change-detection/dependency-graph/ReverseIndex.test.ts
new file mode 100644
index 000000000000..abf96dcc67e2
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/ReverseIndex.test.ts
@@ -0,0 +1,98 @@
+// Covers the construction + mutation surface of ReverseIndexImpl.
+import { describe, expect, it } from 'vitest';
+
+import { ReverseIndexImpl } from './ReverseIndex.ts';
+
+describe('ReverseIndexImpl', () => {
+  it('returns an empty Map (not undefined) when looking up an unknown dep', () => {
+    const index = new ReverseIndexImpl();
+
+    const result = index.lookup('/repo/src/foo.ts');
+
+    expect(result).toBeInstanceOf(Map);
+    expect(result.size).toBe(0);
+  });
+
+  it('records (dep, story, depth) and surfaces the depth via lookup', () => {
+    const index = new ReverseIndexImpl();
+
+    index.record('/repo/src/foo.ts', '/repo/src/Foo.stories.tsx', 1);
+
+    const result = index.lookup('/repo/src/foo.ts');
+    expect(result.get('/repo/src/Foo.stories.tsx')).toBe(1);
+  });
+
+  it('keeps min(existing, depth) when the same (dep, story) is recorded twice with different depths', () => {
+    const index = new ReverseIndexImpl();
+
+    index.record('/repo/src/foo.ts', '/repo/src/A.stories.tsx', 3);
+    index.record('/repo/src/foo.ts', '/repo/src/A.stories.tsx', 1);
+    index.record('/repo/src/foo.ts', '/repo/src/A.stories.tsx', 2);
+
+    expect(index.lookup('/repo/src/foo.ts').get('/repo/src/A.stories.tsx')).toBe(1);
+  });
+
+  it('records the same dep against multiple stories and surfaces both via lookup', () => {
+    const index = new ReverseIndexImpl();
+
+    index.record('/repo/src/shared.ts', '/repo/src/A.stories.tsx', 1);
+    index.record('/repo/src/shared.ts', '/repo/src/B.stories.tsx', 2);
+
+    const result = index.lookup('/repo/src/shared.ts');
+    expect(result.size).toBe(2);
+    expect(result.get('/repo/src/A.stories.tsx')).toBe(1);
+    expect(result.get('/repo/src/B.stories.tsx')).toBe(2);
+  });
+
+  it('removeStory deletes the story from every inner map and prunes outer entries that become empty', () => {
+    const index = new ReverseIndexImpl();
+    index.record('/repo/src/x.ts', '/repo/src/A.stories.tsx', 1);
+    index.record('/repo/src/x.ts', '/repo/src/B.stories.tsx', 2);
+    index.record('/repo/src/y.ts', '/repo/src/A.stories.tsx', 1);
+
+    index.removeStory('/repo/src/A.stories.tsx');
+
+    // /repo/src/y.ts had only A — should be pruned.
+    expect(index.asMap().has('/repo/src/y.ts')).toBe(false);
+    // /repo/src/x.ts retained for B; A removed.
+    const inner = index.lookup('/repo/src/x.ts');
+    expect(inner.size).toBe(1);
+    expect(inner.get('/repo/src/B.stories.tsx')).toBe(2);
+    expect(inner.has('/repo/src/A.stories.tsx')).toBe(false);
+  });
+
+  it('removeEdge removes only the (dep, story) pair without touching other stories', () => {
+    const index = new ReverseIndexImpl();
+    index.record('/repo/src/x.ts', '/repo/src/A.stories.tsx', 1);
+    index.record('/repo/src/x.ts', '/repo/src/B.stories.tsx', 2);
+
+    index.removeEdge('/repo/src/x.ts', '/repo/src/A.stories.tsx');
+
+    const inner = index.lookup('/repo/src/x.ts');
+    expect(inner.has('/repo/src/A.stories.tsx')).toBe(false);
+    expect(inner.get('/repo/src/B.stories.tsx')).toBe(2);
+  });
+
+  it('removeEdge prunes the outer entry when it becomes empty', () => {
+    const index = new ReverseIndexImpl();
+    index.record('/repo/src/x.ts', '/repo/src/A.stories.tsx', 1);
+
+    index.removeEdge('/repo/src/x.ts', '/repo/src/A.stories.tsx');
+
+    expect(index.asMap().has('/repo/src/x.ts')).toBe(false);
+  });
+
+  it('handles cycles by retaining the minimum depth across multiple recordings', () => {
+    // A imports B (depth 1); B imports C (depth 2); C imports B (would be depth 3).
+    // Whatever order build() visits in, recording min keeps depth 1 for B and 2 for C from story A.
+    const index = new ReverseIndexImpl();
+    index.record('/repo/src/B.ts', '/repo/src/A.stories.tsx', 1);
+    index.record('/repo/src/C.ts', '/repo/src/A.stories.tsx', 2);
+    // Cycle re-entry attempts:
+    index.record('/repo/src/B.ts', '/repo/src/A.stories.tsx', 3);
+    index.record('/repo/src/C.ts', '/repo/src/A.stories.tsx', 4);
+
+    expect(index.lookup('/repo/src/B.ts').get('/repo/src/A.stories.tsx')).toBe(1);
+    expect(index.lookup('/repo/src/C.ts').get('/repo/src/A.stories.tsx')).toBe(2);
+  });
+});
diff --git a/code/core/src/core-server/change-detection/dependency-graph/ReverseIndex.ts b/code/core/src/core-server/change-detection/dependency-graph/ReverseIndex.ts
new file mode 100644
index 000000000000..732e0b2608f0
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/ReverseIndex.ts
@@ -0,0 +1,82 @@
+import type { ReverseIndex } from './types.ts';
+
+/**
+ * In-memory reverse index from dep file → story file → shortest BFS depth.
+ *
+ * **Contract:** callers MUST pass already-normalised paths (`pathe.normalize`); the index
+ * does not re-normalise on each mutation. Producers in `DependencyGraphBuilder` and
+ * `IncrementalPatcher` already normalise at the boundary.
+ */
+export class ReverseIndexImpl {
+  private readonly index: ReverseIndex = new Map();
+  /** Forward mapping from story file -> Set of dep files it reaches. */
+  private readonly forwardIndex = new Map<string, Set<string>>();
+
+  /** Records (or updates with min) the depth for (dep, story). */
+  record(dep: string, story: string, depth: number): void {
+    let inner = this.index.get(dep);
+    if (!inner) {
+      inner = new Map<string, number>();
+      this.index.set(dep, inner);
+    }
+    const previous = inner.get(story);
+    if (previous === undefined || depth < previous) {
+      inner.set(story, depth);
+
+      let deps = this.forwardIndex.get(story);
+      if (!deps) {
+        deps = new Set<string>();
+        this.forwardIndex.set(story, deps);
+      }
+      deps.add(dep);
+    }
+  }
+
+  /** Removes a story from every inner map; prunes outer entries that become empty. */
+  removeStory(story: string): void {
+    const deps = this.forwardIndex.get(story);
+    if (!deps) {
+      return;
+    }
+    for (const dep of deps) {
+      const inner = this.index.get(dep);
+      if (inner) {
+        inner.delete(story);
+        if (inner.size === 0) {
+          this.index.delete(dep);
+        }
+      }
+    }
+    this.forwardIndex.delete(story);
+  }
+
+  /** Removes a single (dep, story) pair without affecting other stories' depths to that dep. */
+  removeEdge(dep: string, story: string): void {
+    const inner = this.index.get(dep);
+    if (!inner) {
+      return;
+    }
+    if (inner.delete(story)) {
+      if (inner.size === 0) {
+        this.index.delete(dep);
+      }
+      const deps = this.forwardIndex.get(story);
+      if (deps) {
+        deps.delete(dep);
+        if (deps.size === 0) {
+          this.forwardIndex.delete(story);
+        }
+      }
+    }
+  }
+
+  /** Returns the per-story depth map for dep. EMPTY map (not undefined) if dep unknown. */
+  lookup(dep: string): Map<string, number> {
+    return this.index.get(dep) ?? new Map<string, number>();
+  }
+
+  /** Internal state inspection — for tests. */
+  asMap(): ReverseIndex {
+    return this.index;
+  }
+}
diff --git a/code/core/src/core-server/change-detection/dependency-graph/incremental-patch.test.ts b/code/core/src/core-server/change-detection/dependency-graph/incremental-patch.test.ts
new file mode 100644
index 000000000000..1c4d3ea41b06
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/incremental-patch.test.ts
@@ -0,0 +1,364 @@
+// Covers the IncrementalPatcher behaviour for add/change/unlink events.
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { readFile } from 'node:fs/promises';
+
+import { logger } from 'storybook/internal/node-logger';
+
+import { ParserRegistry } from '../parser-registry/index.ts';
+import type { ImportEdge, ImportParser } from '../parser-registry/index.ts';
+import { IncrementalPatcher } from './IncrementalPatcher.ts';
+import type { ChangeDetectionResolverFactory } from './ResolverFactory.ts';
+import { ReverseIndexImpl } from './ReverseIndex.ts';
+import type { DependencyGraph } from './types.ts';
+
+vi.mock('node:fs/promises', { spy: true });
+vi.mock('storybook/internal/node-logger', { spy: true });
+
+interface PatcherWorld {
+  edges: Map<string, ImportEdge[]>;
+  resolutions: Map<string, string | null>;
+}
+
+interface TestRegistry {
+  registry: ParserRegistry;
+  parseSpy: ReturnType<typeof vi.fn>;
+}
+
+/**
+ * Build a real ParserRegistry with a single test parser that reads precomputed edges out
+ * of the PatcherWorld. Exposes the parse spy so tests can assert how many times a path
+ * was dispatched to the parser.
+ */
+function makeRegistry(world: PatcherWorld): TestRegistry {
+  const parseSpy = vi.fn(async ({ filePath }: { filePath: string }) => {
+    return world.edges.get(filePath) ?? [];
+  });
+  const testParser: ImportParser = {
+    extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mdx'],
+    parse: parseSpy,
+  };
+  const registry = new ParserRegistry({
+    defaultParsers: [testParser],
+    pluginParsers: [],
+  });
+  return { registry, parseSpy };
+}
+
+function makeResolver(world: PatcherWorld): ChangeDetectionResolverFactory {
+  return {
+    resolve: vi.fn(async (from: string, specifier: string) => {
+      const key = `${from}::${specifier}`;
+      return world.resolutions.has(key) ? world.resolutions.get(key)! : null;
+    }),
+  } as unknown as ChangeDetectionResolverFactory;
+}
+
+function setupReadFile() {
+  vi.mocked(readFile).mockImplementation(async () => '');
+}
+
+function buildPatcher(opts: {
+  reverseIndex?: ReverseIndexImpl;
+  graph?: DependencyGraph;
+  storyFiles?: Set<string>;
+  world: PatcherWorld;
+}): {
+  patcher: IncrementalPatcher;
+  reverseIndex: ReverseIndexImpl;
+  graph: DependencyGraph;
+  parseSpy: ReturnType<typeof vi.fn>;
+} {
+  const reverseIndex = opts.reverseIndex ?? new ReverseIndexImpl();
+  const graph = opts.graph ?? new Map();
+  const storyFiles = opts.storyFiles ?? new Set<string>();
+  const { registry, parseSpy } = makeRegistry(opts.world);
+  const resolver = makeResolver(opts.world);
+  const patcher = new IncrementalPatcher({
+    reverseIndex,
+    graph,
+    registry,
+    resolver,
+    workspaceRoots: new Set(),
+    projectRoot: '/repo',
+    isStoryFile: (path: string) => storyFiles.has(path),
+  });
+  return { patcher, reverseIndex, graph, parseSpy };
+}
+
+describe('IncrementalPatcher', () => {
+  beforeEach(() => {
+    setupReadFile();
+    vi.mocked(logger.debug).mockImplementation(() => undefined);
+    vi.mocked(logger.warn).mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('treats a `change` event for an unknown non-story file as a no-op', async () => {
+    const { patcher, reverseIndex, graph, parseSpy } = buildPatcher({
+      world: { edges: new Map(), resolutions: new Map() },
+    });
+
+    await patcher.patch({ kind: 'change', path: '/repo/src/unknown.ts' });
+
+    // No dependents in reverseIndex, not a story file — nothing to re-walk.
+    expect(reverseIndex.asMap().size).toBe(0);
+    expect(parseSpy).not.toHaveBeenCalled();
+    expect(graph.has('/repo/src/unknown.ts')).toBe(false);
+  });
+
+  it('re-walks a story root on `change`, updating depths', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const dep = '/repo/src/dep.ts';
+    const world: PatcherWorld = {
+      edges: new Map([
+        [story, [{ specifier: './dep.ts', kind: 'static' }]],
+        [dep, []],
+      ]),
+      resolutions: new Map([[`${story}::./dep.ts`, dep]]),
+    };
+    const initialIndex = new ReverseIndexImpl();
+    initialIndex.record(story, story, 0);
+    const { patcher, reverseIndex } = buildPatcher({
+      world,
+      reverseIndex: initialIndex,
+      storyFiles: new Set([story]),
+    });
+
+    await patcher.patch({ kind: 'change', path: story });
+
+    expect(reverseIndex.lookup(dep).get(story)).toBe(1);
+  });
+
+  it('removes (oldDep, story) edges when an import disappears on `change`', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const oldDep = '/repo/src/old.ts';
+    const newDep = '/repo/src/new.ts';
+    const initialIndex = new ReverseIndexImpl();
+    initialIndex.record(story, story, 0);
+    initialIndex.record(oldDep, story, 1);
+    const initialGraph: DependencyGraph = new Map([[story, new Set([oldDep])]]);
+    const world: PatcherWorld = {
+      edges: new Map([
+        [story, [{ specifier: './new.ts', kind: 'static' }]],
+        [newDep, []],
+      ]),
+      resolutions: new Map([[`${story}::./new.ts`, newDep]]),
+    };
+    const { patcher, reverseIndex } = buildPatcher({
+      world,
+      reverseIndex: initialIndex,
+      graph: initialGraph,
+      storyFiles: new Set([story]),
+    });
+
+    await patcher.patch({ kind: 'change', path: story });
+
+    expect(reverseIndex.asMap().has(oldDep)).toBe(false);
+    expect(reverseIndex.lookup(newDep).get(story)).toBe(1);
+  });
+
+  it('adds NEW edges with the correct depth on `change`', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const newDep = '/repo/src/added.ts';
+    const initialIndex = new ReverseIndexImpl();
+    initialIndex.record(story, story, 0);
+    const initialGraph: DependencyGraph = new Map([[story, new Set()]]);
+    const world: PatcherWorld = {
+      edges: new Map([
+        [story, [{ specifier: './added.ts', kind: 'static' }]],
+        [newDep, []],
+      ]),
+      resolutions: new Map([[`${story}::./added.ts`, newDep]]),
+    };
+    const { patcher, reverseIndex } = buildPatcher({
+      world,
+      reverseIndex: initialIndex,
+      graph: initialGraph,
+      storyFiles: new Set([story]),
+    });
+
+    await patcher.patch({ kind: 'change', path: story });
+
+    expect(reverseIndex.lookup(newDep).get(story)).toBe(1);
+  });
+
+  it('removes a story root on `unlink` and clears its reverse-index contribution', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const dep = '/repo/src/dep.ts';
+    const initialIndex = new ReverseIndexImpl();
+    initialIndex.record(story, story, 0);
+    initialIndex.record(dep, story, 1);
+    const initialGraph: DependencyGraph = new Map([[story, new Set([dep])]]);
+    const { patcher, reverseIndex, graph } = buildPatcher({
+      world: { edges: new Map(), resolutions: new Map() },
+      reverseIndex: initialIndex,
+      graph: initialGraph,
+      storyFiles: new Set([story]),
+    });
+
+    await patcher.patch({ kind: 'unlink', path: story });
+
+    expect(reverseIndex.asMap().has(dep)).toBe(false);
+    expect(reverseIndex.asMap().has(story)).toBe(false);
+    expect(graph.has(story)).toBe(false);
+  });
+
+  it('on `unlink` of a non-story dep, re-walks every story that previously reached it', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const dep = '/repo/src/dep.ts';
+    const initialIndex = new ReverseIndexImpl();
+    initialIndex.record(story, story, 0);
+    initialIndex.record(dep, story, 1);
+    const initialGraph: DependencyGraph = new Map([
+      [story, new Set([dep])],
+      [dep, new Set()],
+    ]);
+    const world: PatcherWorld = {
+      edges: new Map([[story, []]]),
+      resolutions: new Map(),
+    };
+    const { patcher, reverseIndex } = buildPatcher({
+      world,
+      reverseIndex: initialIndex,
+      graph: initialGraph,
+      storyFiles: new Set([story]),
+    });
+
+    await patcher.patch({ kind: 'unlink', path: dep });
+
+    // dep removed from index; story re-walked with no deps so only story@0 remains.
+    expect(reverseIndex.asMap().has(dep)).toBe(false);
+    expect(reverseIndex.lookup(story).get(story)).toBe(0);
+  });
+
+  it('runs full BFS for an `add` event for a new story root', async () => {
+    const story = '/repo/src/New.stories.tsx';
+    const dep = '/repo/src/dep.ts';
+    const world: PatcherWorld = {
+      edges: new Map([
+        [story, [{ specifier: './dep.ts', kind: 'static' }]],
+        [dep, []],
+      ]),
+      resolutions: new Map([[`${story}::./dep.ts`, dep]]),
+    };
+    const { patcher, reverseIndex } = buildPatcher({
+      world,
+      storyFiles: new Set([story]),
+    });
+
+    await patcher.patch({ kind: 'add', path: story });
+
+    expect(reverseIndex.lookup(story).get(story)).toBe(0);
+    expect(reverseIndex.lookup(dep).get(story)).toBe(1);
+  });
+
+  it('skips re-walk on `change` when dep set is unchanged (comment-only edit)', async () => {
+    const story = '/repo/src/A.stories.tsx';
+    const dep = '/repo/src/shared.ts';
+
+    const initialIndex = new ReverseIndexImpl();
+    initialIndex.record(story, story, 0);
+    initialIndex.record(dep, story, 1);
+    const initialGraph: DependencyGraph = new Map([
+      [story, new Set([dep])],
+      [dep, new Set()],
+    ]);
+
+    // dep changes but its import list stays empty (comment-only edit)
+    const world: PatcherWorld = {
+      edges: new Map([[dep, []]]),
+      resolutions: new Map(),
+    };
+    const { patcher, reverseIndex, parseSpy } = buildPatcher({
+      world,
+      reverseIndex: initialIndex,
+      graph: initialGraph,
+      storyFiles: new Set([story]),
+    });
+
+    await patcher.patch({ kind: 'change', path: dep });
+
+    // story must NOT be re-walked — graph and index are still accurate
+    const storyCalls = parseSpy.mock.calls.filter((c) => c[0].filePath === story);
+    expect(storyCalls.length).toBe(0);
+    // reverse-index entries are preserved unchanged
+    expect(reverseIndex.lookup(dep).get(story)).toBe(1);
+    expect(reverseIndex.lookup(story).get(story)).toBe(0);
+  });
+
+  it('treats `add` for a non-story file as a no-op', async () => {
+    const file = '/repo/src/loose.ts';
+    const world: PatcherWorld = { edges: new Map(), resolutions: new Map() };
+    const { patcher, reverseIndex, parseSpy } = buildPatcher({
+      world,
+      storyFiles: new Set(),
+    });
+
+    await patcher.patch({ kind: 'add', path: file });
+
+    expect(reverseIndex.asMap().size).toBe(0);
+    expect(parseSpy).not.toHaveBeenCalled();
+  });
+
+  it('parses the story root exactly once when the graph entry is absent (no diff-check path)', async () => {
+    // graph is empty so graph.get(path) === undefined → skip the resolveOnce diff-check
+    // → walkStory calls resolveOnce once → parseOnce called exactly once.
+    const story = '/repo/src/A.stories.tsx';
+    const initialIndex = new ReverseIndexImpl();
+    initialIndex.record(story, story, 0);
+    const world: PatcherWorld = {
+      edges: new Map([[story, []]]),
+      resolutions: new Map(),
+    };
+    const { patcher, parseSpy } = buildPatcher({
+      world,
+      reverseIndex: initialIndex,
+      storyFiles: new Set([story]),
+    });
+
+    await patcher.patch({ kind: 'change', path: story });
+
+    const calls = parseSpy.mock.calls.filter((c) => c[0].filePath === story);
+    expect(calls.length).toBe(1);
+  });
+
+  it('unlink of a dep clears the dep from the graph and from the story reverse-index, not just from the index edges', async () => {
+    // Models the stale-cache regression: story → dep is seeded into graph + reverseIndex at
+    // cold-start. Without importer invalidation on unlink, walkFromStory re-uses the cached
+    // resolveCache entry for `story` (which still lists `dep`), silently re-adding dep to
+    // the graph and leaving reverseIndex.lookup(dep) non-empty.
+    const story = '/repo/src/A.stories.tsx';
+    const dep = '/repo/src/dep.ts';
+
+    const initialIndex = new ReverseIndexImpl();
+    initialIndex.record(story, story, 0);
+    initialIndex.record(dep, story, 1);
+    const initialGraph: DependencyGraph = new Map([
+      [story, new Set([dep])],
+      [dep, new Set()],
+    ]);
+
+    // After unlink, the story no longer imports dep.
+    const world: PatcherWorld = {
+      edges: new Map([[story, []]]),
+      resolutions: new Map(),
+    };
+    const { patcher, reverseIndex, graph } = buildPatcher({
+      world,
+      reverseIndex: initialIndex,
+      graph: initialGraph,
+      storyFiles: new Set([story]),
+    });
+
+    await patcher.patch({ kind: 'unlink', path: dep });
+
+    expect(reverseIndex.lookup(dep).size).toBe(0);
+    expect(graph.has(dep)).toBe(false);
+    // The story itself still exists at depth 0; dep is no longer reachable from it.
+    expect(reverseIndex.lookup(story).get(story)).toBe(0);
+  });
+});
diff --git a/code/core/src/core-server/change-detection/dependency-graph/index.ts b/code/core/src/core-server/change-detection/dependency-graph/index.ts
new file mode 100644
index 000000000000..e0ddc7c77d53
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/index.ts
@@ -0,0 +1,6 @@
+export type { ImportEdge, ReverseIndex, DependencyGraph } from './types.ts';
+export { ChangeDetectionResolverFactory } from './ResolverFactory.ts';
+export { ReverseIndexImpl } from './ReverseIndex.ts';
+export { DependencyGraphBuilder } from './DependencyGraphBuilder.ts';
+export { IncrementalPatcher } from './IncrementalPatcher.ts';
+export { ParseResolveCache } from './ParseResolveCache.ts';
diff --git a/code/core/src/core-server/change-detection/dependency-graph/scope.ts b/code/core/src/core-server/change-detection/dependency-graph/scope.ts
new file mode 100644
index 000000000000..c59c0660f19b
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/scope.ts
@@ -0,0 +1,28 @@
+const NODE_MODULES_SEGMENT = '/node_modules/';
+
+export function isInsideAnyWorkspace(absolute: string, workspaceRoots: Set<string>): boolean {
+  if (absolute.includes(NODE_MODULES_SEGMENT)) {
+    return false;
+  }
+  for (const root of workspaceRoots) {
+    if (absolute === root || absolute.startsWith(root.endsWith('/') ? root : `${root}/`)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function isInScope(
+  absolute: string,
+  projectRoot: string,
+  workspaceRoots: Set<string>
+): boolean {
+  const projectPrefix = projectRoot.endsWith('/') ? projectRoot : `${projectRoot}/`;
+  if (
+    (absolute === projectRoot || absolute.startsWith(projectPrefix)) &&
+    !absolute.includes(NODE_MODULES_SEGMENT)
+  ) {
+    return true;
+  }
+  return isInsideAnyWorkspace(absolute, workspaceRoots);
+}
diff --git a/code/core/src/core-server/change-detection/dependency-graph/types.ts b/code/core/src/core-server/change-detection/dependency-graph/types.ts
new file mode 100644
index 000000000000..736b8ad93d84
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/types.ts
@@ -0,0 +1,15 @@
+import type { ImportEdge } from '../parser-registry/index.ts';
+
+export type { ImportEdge };
+
+/**
+ * Reverse index from dep file path → story file → shortest forward-walk depth from that story.
+ * Inner number preserves the BFS hop-count semantics used by `ChangeDetectionService.buildStatuses`
+ * to distinguish `modified` (closest stories) from `affected` (farther stories).
+ *
+ * Keys are absolute paths normalised via `pathe.normalize`.
+ */
+export type ReverseIndex = Map<string, Map<string, number>>;
+
+/** Per-file outgoing edges, used by IncrementalPatcher to compute diffs. */
+export type DependencyGraph = Map<string, Set<string>>;
diff --git a/code/core/src/core-server/change-detection/dependency-graph/walkFromStory.ts b/code/core/src/core-server/change-detection/dependency-graph/walkFromStory.ts
new file mode 100644
index 000000000000..678971d1a132
--- /dev/null
+++ b/code/core/src/core-server/change-detection/dependency-graph/walkFromStory.ts
@@ -0,0 +1,54 @@
+import type { ParserRegistry } from '../parser-registry/index.ts';
+import type { ParseResolveCache } from './ParseResolveCache.ts';
+import type { ReverseIndexImpl } from './ReverseIndex.ts';
+
+export interface WalkFromStoryArgs {
+  storyRoot: string;
+  registry: ParserRegistry;
+  cache: ParseResolveCache;
+  reverseIndex: ReverseIndexImpl;
+  /** Called once per visited file with its resolved outgoing dependencies. */
+  recordEdges: (file: string, deps: Set<string>) => void;
+}
+
+/**
+ * BFS forward-walk from `storyRoot`, parsing + resolving each file once via the shared
+ * cache and recording (dep, story, depth) tuples on `reverseIndex`. Stops at non-walkable
+ * files (no parser registered).
+ */
+export async function walkFromStory({
+  storyRoot,
+  registry,
+  cache,
+  reverseIndex,
+  recordEdges,
+}: WalkFromStoryArgs): Promise<void> {
+  reverseIndex.record(storyRoot, storyRoot, 0);
+
+  const visited = new Map<string, number>();
+  visited.set(storyRoot, 0);
+  const queue: Array<{ file: string; depth: number }> = [{ file: storyRoot, depth: 0 }];
+  let head = 0;
+
+  while (head < queue.length) {
+    const { file, depth } = queue[head++];
+
+    if (registry.parserFor(file) === undefined) {
+      continue;
+    }
+
+    const resolvedDeps = await cache.resolveOnce(file);
+    recordEdges(file, resolvedDeps);
+
+    const nextDepth = depth + 1;
+    for (const normalised of resolvedDeps) {
+      const previousDepth = visited.get(normalised);
+      if (previousDepth !== undefined && previousDepth <= nextDepth) {
+        continue;
+      }
+      visited.set(normalised, nextDepth);
+      reverseIndex.record(normalised, storyRoot, nextDepth);
+      queue.push({ file: normalised, depth: nextDepth });
+    }
+  }
+}
diff --git a/code/core/src/core-server/change-detection/index.ts b/code/core/src/core-server/change-detection/index.ts
index b0b545e148ba..1bd5583d15aa 100644
--- a/code/core/src/core-server/change-detection/index.ts
+++ b/code/core/src/core-server/change-detection/index.ts
@@ -6,3 +6,15 @@ export {
   type ChangeDetectionReadiness,
 } from './readiness.ts';
 export { ChangeDetectionService } from './ChangeDetectionService.ts';
+export type {
+  ChangeDetectionAdapter,
+  FileChangeEvent,
+  ModuleResolveConfig,
+} from './adapters/index.ts';
+export { ParserRegistry, builtinImportParsers } from './parser-registry/index.ts';
+export type {
+  ImportEdge,
+  ImportParser,
+  ImportParserContext,
+  ParseFileArgs,
+} from './parser-registry/index.ts';
diff --git a/code/core/src/core-server/change-detection/parser-registry/ParserRegistry.test.ts b/code/core/src/core-server/change-detection/parser-registry/ParserRegistry.test.ts
new file mode 100644
index 000000000000..1075bbb5a6fa
--- /dev/null
+++ b/code/core/src/core-server/change-detection/parser-registry/ParserRegistry.test.ts
@@ -0,0 +1,134 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { logger } from 'storybook/internal/node-logger';
+
+import { ParserRegistry } from './ParserRegistry.ts';
+import { builtinImportParsers } from './builtins.ts';
+import type { ImportParser } from './types.ts';
+
+vi.mock('storybook/internal/node-logger', { spy: true });
+
+describe('ParserRegistry', () => {
+  beforeEach(() => {
+    vi.mocked(logger.debug).mockImplementation(() => undefined);
+  });
+
+  it('registers default parsers and looks them up by extension', () => {
+    const registry = new ParserRegistry({
+      defaultParsers: builtinImportParsers,
+      pluginParsers: [],
+    });
+
+    expect(registry.parserFor('/tmp/a.ts')).toBeDefined();
+    expect(registry.parserFor('/tmp/a.tsx')).toBeDefined();
+    expect(registry.parserFor('/tmp/a.mdx')).toBeDefined();
+  });
+
+  it('lets a plugin parser override a default parser and logs a debug line', () => {
+    const pluginParse = vi.fn(async () => []);
+    const plugin: ImportParser = {
+      extensions: ['.ts'],
+      parse: pluginParse,
+    };
+
+    const registry = new ParserRegistry({
+      defaultParsers: builtinImportParsers,
+      pluginParsers: [plugin],
+    });
+
+    expect(registry.parserFor('/tmp/a.ts')).toBe(pluginParse);
+    expect(vi.mocked(logger.debug)).toHaveBeenCalledWith(
+      expect.stringContaining('.ts parser overridden')
+    );
+  });
+
+  it('returns undefined from parserFor for an unknown extension', () => {
+    const registry = new ParserRegistry({
+      defaultParsers: builtinImportParsers,
+      pluginParsers: [],
+    });
+
+    expect(registry.parserFor('/tmp/a.unknown')).toBeUndefined();
+  });
+
+  it('returns null from parse for an unknown extension (not empty array, not throw)', async () => {
+    const registry = new ParserRegistry({
+      defaultParsers: builtinImportParsers,
+      pluginParsers: [],
+    });
+
+    await expect(registry.parse('/tmp/a.unknown', 'anything')).resolves.toBeNull();
+  });
+
+  it('matches extensions case-insensitively (.TSX matches a .tsx plugin)', () => {
+    const plugin: ImportParser = {
+      extensions: ['.tsx'],
+      parse: vi.fn(async () => []),
+    };
+    const registry = new ParserRegistry({
+      defaultParsers: [],
+      pluginParsers: [plugin],
+    });
+
+    expect(registry.parserFor('/tmp/COMP.TSX')).toBe(plugin.parse);
+  });
+
+  it('lowercases the extensions a plugin registers so subsequent lookups match', () => {
+    const plugin: ImportParser = {
+      extensions: ['.FOO'],
+      parse: vi.fn(async () => []),
+    };
+    const registry = new ParserRegistry({
+      defaultParsers: [],
+      pluginParsers: [plugin],
+    });
+
+    expect(registry.parserFor('/tmp/a.foo')).toBe(plugin.parse);
+  });
+
+  it('exposes parseScriptWithOxc to plugins via the context, returning import edges', async () => {
+    let observedEdges: unknown;
+    const sfcPlugin: ImportParser = {
+      extensions: ['.sfc'],
+      async parse(_args, ctx) {
+        observedEdges = await ctx.parseScriptWithOxc(
+          `import x from 'y'; export { a } from 'b';`,
+          '/tmp/virtual.ts'
+        );
+        return observedEdges as { specifier: string; kind: 'static' | 'dynamic' | 'require' }[];
+      },
+    };
+    const registry = new ParserRegistry({
+      defaultParsers: [],
+      pluginParsers: [sfcPlugin],
+    });
+
+    const edges = await registry.parse('/tmp/component.sfc', 'ignored-by-plugin');
+
+    expect(edges).toEqual([
+      { specifier: 'y', kind: 'static' },
+      { specifier: 'b', kind: 'static' },
+    ]);
+    expect(observedEdges).toEqual(edges);
+  });
+
+  it('dispatches a known extension to the registered parser and returns its edges', async () => {
+    const pluginParse = vi.fn(async () => [{ specifier: 'foo', kind: 'static' as const }]);
+    const plugin: ImportParser = {
+      extensions: ['.foo'],
+      parse: pluginParse,
+    };
+    const registry = new ParserRegistry({
+      defaultParsers: [],
+      pluginParsers: [plugin],
+    });
+
+    const edges = await registry.parse('/tmp/a.foo', 'some source');
+
+    expect(edges).toEqual([{ specifier: 'foo', kind: 'static' }]);
+    expect(pluginParse).toHaveBeenCalledWith(
+      { filePath: '/tmp/a.foo', source: 'some source' },
+      expect.objectContaining({ parseScriptWithOxc: expect.any(Function) })
+    );
+  });
+});
diff --git a/code/core/src/core-server/change-detection/parser-registry/ParserRegistry.ts b/code/core/src/core-server/change-detection/parser-registry/ParserRegistry.ts
new file mode 100644
index 000000000000..79c30f9eb3a2
--- /dev/null
+++ b/code/core/src/core-server/change-detection/parser-registry/ParserRegistry.ts
@@ -0,0 +1,63 @@
+import { extname } from 'pathe';
+
+import { logger } from 'storybook/internal/node-logger';
+import { parseWithOxc } from 'storybook/internal/oxc-parser';
+
+import type { ImportEdge, ImportParser, ImportParserContext } from './types.ts';
+
+/**
+ * Dispatches a file to the correct {@link ImportParser} based on its extension. The
+ * registry is constructed from a set of default parsers plus any plugin-supplied
+ * parsers (e.g. contributions to the `experimental_importParsers` preset key).
+ *
+ * Registration is last-wins on collision (plugin extensions override built-in
+ * extensions). Lookup is case-insensitive and uses `path.extname` — compound
+ * extensions like `.svelte.ts` match only the last segment (`.ts`).
+ */
+export class ParserRegistry {
+  private byExtension = new Map<string, ImportParser['parse']>();
+  private context: ImportParserContext;
+
+  constructor(opts: {
+    defaultParsers: readonly ImportParser[];
+    pluginParsers: readonly ImportParser[];
+  }) {
+    this.context = { parseScriptWithOxc: this.parseScriptWithOxc.bind(this) };
+    for (const p of opts.defaultParsers) {
+      this.register(p);
+    }
+    for (const p of opts.pluginParsers) {
+      this.register(p);
+    }
+  }
+
+  private register(plugin: ImportParser): void {
+    for (const ext of plugin.extensions) {
+      const lower = ext.toLowerCase();
+      if (this.byExtension.has(lower)) {
+        logger.debug(`ParserRegistry: ${lower} parser overridden`);
+      }
+      this.byExtension.set(lower, plugin.parse);
+    }
+  }
+
+  parserFor(filePath: string): ImportParser['parse'] | undefined {
+    return this.byExtension.get(extname(filePath).toLowerCase());
+  }
+
+  /**
+   * Returns `null` when no parser claims the extension — callers interpret this as
+   * "opaque leaf, do not walk into".
+   */
+  async parse(filePath: string, source: string): Promise<ImportEdge[] | null> {
+    const fn = this.parserFor(filePath);
+    if (!fn) {
+      return null;
+    }
+    return fn({ filePath, source }, this.context);
+  }
+
+  private async parseScriptWithOxc(source: string, virtualFilePath: string): Promise<ImportEdge[]> {
+    return parseWithOxc(virtualFilePath, source);
+  }
+}
diff --git a/code/core/src/core-server/change-detection/parser-registry/builtins.test.ts b/code/core/src/core-server/change-detection/parser-registry/builtins.test.ts
new file mode 100644
index 000000000000..2e009329c50f
--- /dev/null
+++ b/code/core/src/core-server/change-detection/parser-registry/builtins.test.ts
@@ -0,0 +1,250 @@
+// Integration tests for the built-in ImportParser plugins. We exercise the real oxc-parser
+// binary here (no spy) — the parser is fast enough for unit tests and stubbing it would
+// test the stub, not the extractor's mapping from oxc nodes to ImportEdge.
+import { describe, expect, it, vi } from 'vitest';
+
+import { ChangeDetectionFailureError } from '../errors.ts';
+import { mdxImportParser, oxcImportParser } from './builtins.ts';
+import type { ImportParserContext } from './types.ts';
+
+vi.mock('storybook/internal/node-logger', { spy: true });
+
+const noopContext: ImportParserContext = {
+  parseScriptWithOxc: async () => [],
+};
+
+describe('oxcImportParser', () => {
+  it('claims the core JS/TS extensions', () => {
+    expect(oxcImportParser.extensions).toEqual(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+  });
+
+  it('extracts a regular static `import x from "y"`', async () => {
+    const edges = await oxcImportParser.parse(
+      { filePath: '/tmp/a.ts', source: `import x from 'y';` },
+      noopContext
+    );
+
+    expect(edges).toEqual([{ specifier: 'y', kind: 'static' }]);
+  });
+
+  it('skips a type-only `import type x from "y"`', async () => {
+    const edges = await oxcImportParser.parse(
+      { filePath: '/tmp/a.ts', source: `import type x from 'y';` },
+      noopContext
+    );
+
+    expect(edges).toEqual([]);
+  });
+
+  it('keeps a re-export `export { x } from "y"`', async () => {
+    const edges = await oxcImportParser.parse(
+      { filePath: '/tmp/a.ts', source: `export { x } from 'y';` },
+      noopContext
+    );
+
+    expect(edges).toEqual([{ specifier: 'y', kind: 'static' }]);
+  });
+
+  it('skips a type-only `export type { x } from "y"`', async () => {
+    const edges = await oxcImportParser.parse(
+      { filePath: '/tmp/a.ts', source: `export type { x } from 'y';` },
+      noopContext
+    );
+
+    expect(edges).toEqual([]);
+  });
+
+  it('keeps a dynamic `import("y")` with a string literal', async () => {
+    const edges = await oxcImportParser.parse(
+      { filePath: '/tmp/a.ts', source: `const m = import('y');` },
+      noopContext
+    );
+
+    expect(edges).toEqual([{ specifier: 'y', kind: 'dynamic' }]);
+  });
+
+  it('skips a dynamic import with a non-literal specifier', async () => {
+    const edges = await oxcImportParser.parse(
+      {
+        filePath: '/tmp/a.ts',
+        source: `async function f(name: string) { await import(name); }`,
+      },
+      noopContext
+    );
+
+    expect(edges).toEqual([]);
+  });
+
+  it('skips a template-literal dynamic import with interpolation', async () => {
+    const edges = await oxcImportParser.parse(
+      {
+        filePath: '/tmp/a.ts',
+        source: 'async function f(x: string) { await import(`./${x}`); }',
+      },
+      noopContext
+    );
+
+    expect(edges).toEqual([]);
+  });
+
+  it('keeps a template-literal dynamic import with no interpolation', async () => {
+    const edges = await oxcImportParser.parse(
+      { filePath: '/tmp/a.ts', source: 'async function f() { await import(`./y`); }' },
+      noopContext
+    );
+
+    expect(edges).toEqual([{ specifier: './y', kind: 'dynamic' }]);
+  });
+
+  it('extracts a `require("y")` call with a string literal', async () => {
+    const edges = await oxcImportParser.parse(
+      { filePath: '/tmp/a.js', source: `const m = require('y');` },
+      noopContext
+    );
+
+    const requires = edges.filter((edge) => edge.kind === 'require');
+    expect(requires).toEqual([{ specifier: 'y', kind: 'require' }]);
+  });
+
+  it('skips `require(someVar)` with a non-literal argument', async () => {
+    const edges = await oxcImportParser.parse(
+      { filePath: '/tmp/a.js', source: `function f(name) { return require(name); }` },
+      noopContext
+    );
+
+    expect(edges.filter((edge) => edge.kind === 'require')).toEqual([]);
+  });
+
+  it('parses a .tsx file with JSX and an import together', async () => {
+    const edges = await oxcImportParser.parse(
+      {
+        filePath: '/tmp/a.tsx',
+        source: `import React from 'react';\nexport const X = () => <div />;`,
+      },
+      noopContext
+    );
+
+    expect(edges).toEqual([{ specifier: 'react', kind: 'static' }]);
+  });
+
+  it('parses `.mjs` and `.cjs` sources without error', async () => {
+    const mjs = await oxcImportParser.parse(
+      { filePath: '/tmp/a.mjs', source: `import x from 'y';` },
+      noopContext
+    );
+    const cjs = await oxcImportParser.parse(
+      { filePath: '/tmp/a.cjs', source: `const m = require('y');` },
+      noopContext
+    );
+
+    expect(mjs).toEqual([{ specifier: 'y', kind: 'static' }]);
+    expect(cjs.filter((e) => e.kind === 'require')).toEqual([{ specifier: 'y', kind: 'require' }]);
+  });
+
+  it('wraps an oxc-parser throw in a ChangeDetectionFailureError', async () => {
+    // The dissolved oxc wrapper throws ChangeDetectionFailureError on any parser-level
+    // failure (null `module`, oxc throw). We cannot reliably produce an oxc throw with
+    // a test fixture — oxc is permissive. We document the contract: if the parser
+    // refused the source, the wrapping is a ChangeDetectionFailureError.
+    let threw: unknown;
+    try {
+      // Pass binary-garbage-ish source; if oxc refuses, we expect the error-wrapping path.
+      await oxcImportParser.parse(
+        { filePath: '/tmp/a.ts', source: ' invalid  source `' },
+        noopContext
+      );
+    } catch (error) {
+      threw = error;
+    }
+    if (threw !== undefined) {
+      expect(threw).toBeInstanceOf(ChangeDetectionFailureError);
+    }
+  });
+});
+
+describe('mdxImportParser', () => {
+  it('claims the `.mdx` extension', () => {
+    expect(mdxImportParser.extensions).toEqual(['.mdx']);
+  });
+
+  it('extracts top-of-file import lines from an MDX source', async () => {
+    const source = [
+      `import { Meta } from '@storybook/blocks';`,
+      `import * as ButtonStories from './Button.stories';`,
+      ``,
+      `<Meta of={ButtonStories} />`,
+    ].join('\n');
+
+    const edges = await mdxImportParser.parse({ filePath: '/tmp/intro.mdx', source }, noopContext);
+
+    expect(edges).toEqual([
+      { specifier: '@storybook/blocks', kind: 'static' },
+      { specifier: './Button.stories', kind: 'static' },
+    ]);
+  });
+
+  it('returns an empty array when an MDX file has no imports', async () => {
+    const edges = await mdxImportParser.parse(
+      { filePath: '/tmp/doc.mdx', source: `# Title\n\nSome prose.` },
+      noopContext
+    );
+
+    expect(edges).toEqual([]);
+  });
+
+  it('deduplicates identical import specifiers', async () => {
+    const source = [
+      `import { Meta } from '@storybook/blocks';`,
+      `import { Canvas } from '@storybook/blocks';`,
+    ].join('\n');
+
+    const edges = await mdxImportParser.parse({ filePath: '/tmp/intro.mdx', source }, noopContext);
+
+    expect(edges).toEqual([{ specifier: '@storybook/blocks', kind: 'static' }]);
+  });
+
+  it('extracts "export ... from" declarations from an MDX source', async () => {
+    const source = [`export { Meta } from '@storybook/blocks';`, `export * from './others';`].join(
+      '\n'
+    );
+
+    const edges = await mdxImportParser.parse({ filePath: '/tmp/intro.mdx', source }, noopContext);
+
+    expect(edges).toEqual([
+      { specifier: '@storybook/blocks', kind: 'static' },
+      { specifier: './others', kind: 'static' },
+    ]);
+  });
+
+  it('does NOT extract imports inside fenced code blocks (```js ... ```)', async () => {
+    const source = [
+      `import { Meta } from '@storybook/blocks';`,
+      ``,
+      `\`\`\`js`,
+      `import fake from 'this-is-an-example';`,
+      `import another from './example-dep';`,
+      `\`\`\``,
+      ``,
+      `<Meta title="Docs" />`,
+    ].join('\n');
+
+    const edges = await mdxImportParser.parse({ filePath: '/tmp/doc.mdx', source }, noopContext);
+
+    expect(edges).toEqual([{ specifier: '@storybook/blocks', kind: 'static' }]);
+    expect(edges.map((e) => e.specifier)).not.toContain('this-is-an-example');
+    expect(edges.map((e) => e.specifier)).not.toContain('./example-dep');
+  });
+
+  it('does NOT extract imports inside backtick inline code spans', async () => {
+    const source = [
+      `import { Canvas } from '@storybook/blocks';`,
+      ``,
+      `Use \`import foo from 'fake-pkg'\` in your code.`,
+    ].join('\n');
+
+    const edges = await mdxImportParser.parse({ filePath: '/tmp/doc.mdx', source }, noopContext);
+
+    expect(edges).toEqual([{ specifier: '@storybook/blocks', kind: 'static' }]);
+    expect(edges.map((e) => e.specifier)).not.toContain('fake-pkg');
+  });
+});
diff --git a/code/core/src/core-server/change-detection/parser-registry/builtins.ts b/code/core/src/core-server/change-detection/parser-registry/builtins.ts
new file mode 100644
index 000000000000..108aedc76473
--- /dev/null
+++ b/code/core/src/core-server/change-detection/parser-registry/builtins.ts
@@ -0,0 +1,28 @@
+import { parseWithOxc } from 'storybook/internal/oxc-parser';
+
+import { mdxParse } from './mdx-parse.ts';
+import type { ImportParser } from './types.ts';
+
+/** Default parser for JavaScript/TypeScript source. Uses `oxc-parser` under the hood. */
+export const oxcImportParser: ImportParser = {
+  extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+  async parse({ filePath, source }) {
+    return parseWithOxc(filePath, source);
+  },
+};
+
+/** Default parser for MDX files. Uses a regex fallback (oxc-parser cannot parse MDX). */
+export const mdxImportParser: ImportParser = {
+  extensions: ['.mdx'],
+  async parse({ source }) {
+    return mdxParse(source);
+  },
+};
+
+/**
+ * Built-in parsers shipped with core change-detection. These cover the extensions the
+ * previous {@link ImportExtractor} handled directly; additional extensions (e.g. `.vue`,
+ * `.svelte`) are contributed by framework/renderer plugins via the
+ * `experimental_importParsers` preset key.
+ */
+export const builtinImportParsers: readonly ImportParser[] = [oxcImportParser, mdxImportParser];
diff --git a/code/core/src/core-server/change-detection/parser-registry/index.ts b/code/core/src/core-server/change-detection/parser-registry/index.ts
new file mode 100644
index 000000000000..fe906b1f67a4
--- /dev/null
+++ b/code/core/src/core-server/change-detection/parser-registry/index.ts
@@ -0,0 +1,3 @@
+export type { ImportEdge, ImportParser, ImportParserContext, ParseFileArgs } from './types.ts';
+export { ParserRegistry } from './ParserRegistry.ts';
+export { builtinImportParsers, mdxImportParser, oxcImportParser } from './builtins.ts';
diff --git a/code/core/src/core-server/change-detection/parser-registry/mdx-parse.ts b/code/core/src/core-server/change-detection/parser-registry/mdx-parse.ts
new file mode 100644
index 000000000000..bc07a8f4599b
--- /dev/null
+++ b/code/core/src/core-server/change-detection/parser-registry/mdx-parse.ts
@@ -0,0 +1,43 @@
+import type { ImportEdge } from './types.ts';
+
+/**
+ * Matches `import` or `export ... from` declarations in an MDX source.
+ * oxc-parser does not understand MDX, so we fall back to a regex. This only captures
+ * literal-string specifiers — enough for change detection to resolve them with oxc-resolver.
+ */
+const MDX_IMPORT_REGEX =
+  /(?:import\s+(?:[\s\S]*?\s+from\s+)?|export\s+[\s\S]*?\s+from\s+)['"]([^'"]+)['"]/g;
+
+/**
+ * Strips fenced code blocks (```lang\n...\n```) and inline code (`...`) from MDX source,
+ * replacing each region with spaces of equal length. Preserves line numbers so any
+ * future debug output remains accurate. We strip before running the import regex to avoid
+ * treating example imports inside code blocks as real dependency edges.
+ */
+function stripCodeRegions(source: string): string {
+  // Replace fenced code blocks first (they may contain backtick runs inside).
+  // The `s` flag makes `.` match newlines so multi-line blocks are covered.
+  let stripped = source.replace(/```[\s\S]*?```/gs, (match) => ' '.repeat(match.length));
+  // Replace inline code spans (single backtick pairs).
+  stripped = stripped.replace(/`[^`]*`/g, (match) => ' '.repeat(match.length));
+  return stripped;
+}
+
+/** Extracts literal-string import edges from an `.mdx` file via regex fallback. */
+export function mdxParse(source: string): ImportEdge[] {
+  const stripped = stripCodeRegions(source);
+  const edges: ImportEdge[] = [];
+  const seen = new Set<string>();
+  MDX_IMPORT_REGEX.lastIndex = 0;
+  let match: RegExpExecArray | null = MDX_IMPORT_REGEX.exec(stripped);
+  while (match !== null) {
+    const specifier = match[1];
+    const key = `static:${specifier}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      edges.push({ specifier, kind: 'static' });
+    }
+    match = MDX_IMPORT_REGEX.exec(stripped);
+  }
+  return edges;
+}
diff --git a/code/core/src/core-server/change-detection/parser-registry/types.ts b/code/core/src/core-server/change-detection/parser-registry/types.ts
new file mode 100644
index 000000000000..5e9eb43f33f1
--- /dev/null
+++ b/code/core/src/core-server/change-detection/parser-registry/types.ts
@@ -0,0 +1,38 @@
+// `ImportEdge` lives in the oxc-parser sub-package because it is the oxc-parser's
+// output type, not a registry-specific concept.
+import type { ImportEdge } from 'storybook/internal/oxc-parser';
+
+export type { ImportEdge };
+
+/** Arguments handed to an {@link ImportParser} when the registry dispatches a file to it. */
+export interface ParseFileArgs {
+  filePath: string;
+  source: string;
+}
+
+/**
+ * Services passed to every parser. SFC parsers (vue, svelte) extract a `<script>` block
+ * and then delegate the actual import-edge extraction to the built-in oxc wrapper via
+ * {@link ImportParserContext.parseScriptWithOxc}.
+ */
+export interface ImportParserContext {
+  /** Core's oxc-parser wrapper. SFC plugins call this after extracting <script> content. */
+  parseScriptWithOxc(source: string, virtualFilePath: string): Promise<ImportEdge[]>;
+}
+
+/**
+ * A parser plugin that claims one or more file extensions and knows how to extract import
+ * edges from that file type. May be registered with a {@link ParserRegistry} directly or
+ * surfaced through the `experimental_importParsers` preset key.
+ *
+ * Extensions are compared with `path.extname(filePath).toLowerCase()` lookup — compound
+ * extensions such as `.svelte.ts` are NOT supported here (only the last segment matches).
+ */
+export interface ImportParser {
+  /**
+   * Lowercase, leading dot. Compound extensions like `.svelte.ts` are NOT supported here —
+   * `path.extname` returns the last segment only, so `.svelte.ts` matches `.ts`.
+   */
+  extensions: readonly string[];
+  parse(args: ParseFileArgs, ctx: ImportParserContext): Promise<ImportEdge[]>;
+}
diff --git a/code/core/src/core-server/change-detection/trace-changed.test.ts b/code/core/src/core-server/change-detection/trace-changed.test.ts
deleted file mode 100644
index 66ecffa05a73..000000000000
--- a/code/core/src/core-server/change-detection/trace-changed.test.ts
+++ /dev/null
@@ -1,151 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import type { ModuleGraph, ModuleNode } from 'storybook/internal/types';
-
-import { findAffectedStoryFiles } from './trace-changed.ts';
-
-function createModuleNode(file: string): ModuleNode {
-  return {
-    file,
-    type: 'js',
-    importers: new Set(),
-    importedModules: new Set(),
-  };
-}
-
-function createStoryIdsByFile(...files: string[]): Map<string, Set<string>> {
-  return new Map(files.map((file) => [file, new Set([file])]));
-}
-
-describe('findAffectedStoryFiles', () => {
-  it('returns every reachable story file with its shortest distance', () => {
-    const buttonCss = createModuleNode('/repo/src/Button.module.css');
-    const button = createModuleNode('/repo/src/Button.tsx');
-    const header = createModuleNode('/repo/src/Header.tsx');
-    const buttonStory = createModuleNode('/repo/src/Button.stories.tsx');
-    const headerStory = createModuleNode('/repo/src/Header.stories.tsx');
-    const page = createModuleNode('/repo/src/Page.tsx');
-    const pageStory = createModuleNode('/repo/src/Page.stories.tsx');
-
-    buttonCss.importers.add(button);
-    button.importers.add(buttonStory);
-    button.importers.add(header);
-    header.importers.add(headerStory);
-    header.importers.add(page);
-    page.importers.add(pageStory);
-
-    const moduleGraph: ModuleGraph = new Map([
-      ['/repo/src/Button.module.css', new Set([buttonCss])],
-      ['/repo/src/Button.tsx', new Set([button])],
-      ['/repo/src/Header.tsx', new Set([header])],
-      ['/repo/src/Button.stories.tsx', new Set([buttonStory])],
-      ['/repo/src/Header.stories.tsx', new Set([headerStory])],
-      ['/repo/src/Page.tsx', new Set([page])],
-      ['/repo/src/Page.stories.tsx', new Set([pageStory])],
-    ]);
-
-    expect(
-      findAffectedStoryFiles(
-        '/repo/src/Button.module.css',
-        moduleGraph,
-        createStoryIdsByFile(
-          '/repo/src/Button.stories.tsx',
-          '/repo/src/Header.stories.tsx',
-          '/repo/src/Page.stories.tsx'
-        )
-      )
-    ).toEqual(
-      new Map([
-        ['/repo/src/Button.stories.tsx', { distance: 2 }],
-        ['/repo/src/Header.stories.tsx', { distance: 3 }],
-        ['/repo/src/Page.stories.tsx', { distance: 4 }],
-      ])
-    );
-  });
-
-  it('keeps the shortest distance when the same story file is reachable multiple ways', () => {
-    const shared = createModuleNode('/repo/src/shared.ts');
-    const a = createModuleNode('/repo/src/A.tsx');
-    const b = createModuleNode('/repo/src/B.tsx');
-    const storyViaA = createModuleNode('/repo/src/Shared.stories.tsx');
-    const storyViaB = createModuleNode('/repo/src/Shared.stories.tsx');
-
-    shared.importers.add(a);
-    shared.importers.add(b);
-    a.importers.add(storyViaA);
-    b.importers.add(a);
-    b.importers.add(storyViaB);
-
-    const moduleGraph: ModuleGraph = new Map([
-      ['/repo/src/shared.ts', new Set([shared])],
-      ['/repo/src/A.tsx', new Set([a])],
-      ['/repo/src/B.tsx', new Set([b])],
-      ['/repo/src/Shared.stories.tsx', new Set([storyViaA, storyViaB])],
-    ]);
-
-    expect(
-      findAffectedStoryFiles(
-        '/repo/src/shared.ts',
-        moduleGraph,
-        createStoryIdsByFile('/repo/src/Shared.stories.tsx')
-      )
-    ).toEqual(new Map([['/repo/src/Shared.stories.tsx', { distance: 2 }]]));
-  });
-
-  it('handles cycles without looping forever', () => {
-    const changed = createModuleNode('/repo/src/changed.ts');
-    const a = createModuleNode('/repo/src/A.ts');
-    const b = createModuleNode('/repo/src/B.ts');
-    const story = createModuleNode('/repo/src/Cycle.stories.tsx');
-
-    changed.importers.add(a);
-    a.importers.add(b);
-    b.importers.add(a);
-    b.importers.add(story);
-
-    const moduleGraph: ModuleGraph = new Map([
-      ['/repo/src/changed.ts', new Set([changed])],
-      ['/repo/src/A.ts', new Set([a])],
-      ['/repo/src/B.ts', new Set([b])],
-      ['/repo/src/Cycle.stories.tsx', new Set([story])],
-    ]);
-
-    expect(
-      findAffectedStoryFiles(
-        '/repo/src/changed.ts',
-        moduleGraph,
-        createStoryIdsByFile('/repo/src/Cycle.stories.tsx')
-      )
-    ).toEqual(new Map([['/repo/src/Cycle.stories.tsx', { distance: 3 }]]));
-  });
-
-  it('returns the changed story file with distance zero', () => {
-    expect(
-      findAffectedStoryFiles(
-        '/repo/src/Button.stories.tsx',
-        new Map(),
-        createStoryIdsByFile('/repo/src/Button.stories.tsx')
-      )
-    ).toEqual(new Map([['/repo/src/Button.stories.tsx', { distance: 0 }]]));
-  });
-
-  it('returns an empty map when no story files are reachable', () => {
-    const changed = createModuleNode('/repo/src/changed.ts');
-    const component = createModuleNode('/repo/src/Component.tsx');
-
-    changed.importers.add(component);
-
-    const moduleGraph: ModuleGraph = new Map([
-      ['/repo/src/changed.ts', new Set([changed])],
-      ['/repo/src/Component.tsx', new Set([component])],
-    ]);
-
-    expect(
-      findAffectedStoryFiles(
-        '/repo/src/changed.ts',
-        moduleGraph,
-        createStoryIdsByFile('/repo/src/Button.stories.tsx')
-      )
-    ).toEqual(new Map());
-  });
-});
diff --git a/code/core/src/core-server/change-detection/trace-changed.ts b/code/core/src/core-server/change-detection/trace-changed.ts
deleted file mode 100644
index 697badcc69ac..000000000000
--- a/code/core/src/core-server/change-detection/trace-changed.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import type { ModuleGraph, ModuleNode } from 'storybook/internal/types';
-
-export function findAffectedStoryFiles(
-  changedFile: string,
-  moduleGraph: ModuleGraph,
-  storyIdsByFile: Map<string, Set<string>>
-): Map<string, { distance: number }> {
-  const affectedStoryFiles = new Map<string, { distance: number }>();
-
-  if (storyIdsByFile.has(changedFile)) {
-    affectedStoryFiles.set(changedFile, { distance: 0 });
-  }
-
-  const startingNodes = moduleGraph.get(changedFile);
-  if (!startingNodes?.size) {
-    return affectedStoryFiles;
-  }
-
-  const visited = new Map<ModuleNode, number>();
-  const queue = Array.from(startingNodes, (node) => ({ node, distance: 0 }));
-  let queueIndex = 0;
-
-  startingNodes.forEach((node) => {
-    visited.set(node, 0);
-  });
-
-  while (queueIndex < queue.length) {
-    const current = queue[queueIndex++];
-    current.node.importers.forEach((importer) => {
-      const distance = current.distance + 1;
-      const previousDistance = visited.get(importer);
-
-      if (previousDistance !== undefined && previousDistance <= distance) {
-        return;
-      }
-
-      visited.set(importer, distance);
-      if (storyIdsByFile.has(importer.file)) {
-        const previousStoryDistance = affectedStoryFiles.get(importer.file)?.distance;
-
-        if (previousStoryDistance === undefined || distance < previousStoryDistance) {
-          affectedStoryFiles.set(importer.file, { distance });
-        }
-      }
-
-      queue.push({ node: importer, distance });
-    });
-  }
-
-  return affectedStoryFiles;
-}
diff --git a/code/core/src/core-server/dev-server.ts b/code/core/src/core-server/dev-server.ts
index 1841a15c4b02..e085a4446255 100644
--- a/code/core/src/core-server/dev-server.ts
+++ b/code/core/src/core-server/dev-server.ts
@@ -1,5 +1,4 @@
 import { logConfig, normalizeStories } from 'storybook/internal/common';
-import { DOCS_PREPARED, STORY_RENDERED } from 'storybook/internal/core-events';
 import { logger } from 'storybook/internal/node-logger';
 import { MissingBuilderError } from 'storybook/internal/server-errors';
 import { CHANGE_DETECTION_STATUS_TYPE_ID } from 'storybook/internal/types';
@@ -9,8 +8,8 @@ import compression from '@polka/compression';
 import polka from 'polka';
 
 import { isTelemetryModuleEnabled, telemetry } from '../telemetry/index.ts';
+import type { ChangeDetectionAdapter } from './change-detection/index.ts';
 import { ChangeDetectionService } from './change-detection/index.ts';
-import { setChangeDetectionReadiness } from './change-detection/readiness.ts';
 import { getStatusStoreByTypeId } from './stores/status.ts';
 import type { StoryIndexGenerator } from './utils/StoryIndexGenerator.ts';
 import { doTelemetry } from './utils/doTelemetry.ts';
@@ -53,6 +52,7 @@ export async function storybookDevServer(
     storyIndexGeneratorPromise,
     statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID),
     workingDir,
+    presets: options.presets,
   });
 
   app.use(compression({ level: 1 }));
@@ -125,7 +125,7 @@ export async function storybookDevServer(
 
   if (!options.ignorePreview) {
     if (!features.changeDetection) {
-      changeDetectionService.start(previewBuilder.onModuleGraphChange, false);
+      changeDetectionService.start(undefined, false);
     }
 
     logger.debug('Starting preview..');
@@ -154,26 +154,14 @@ export async function storybookDevServer(
       });
 
     if (features.changeDetection) {
-      let changeDetectionStarted = false;
-      const startChangeDetection = () => {
-        if (changeDetectionStarted) {
-          return;
-        }
-        try {
-          changeDetectionStarted = true;
-          changeDetectionService.start(previewBuilder.onModuleGraphChange, true);
-        } catch (error) {
-          logger.error('Failed to start change detection');
-          logger.error(error instanceof Error ? error : String(error));
-          setChangeDetectionReadiness({
-            status: 'error',
-            error: error instanceof Error ? error : new Error(String(error)),
-          });
-        }
-      };
-
-      options.channel.once(STORY_RENDERED, startChangeDetection);
-      options.channel.once(DOCS_PREPARED, startChangeDetection);
+      let adapter: ChangeDetectionAdapter | undefined;
+      try {
+        adapter = previewBuilder.changeDetectionAdapter?.();
+      } catch (err) {
+        logger.warn('Change detection: adapter initialisation failed');
+        logger.debug(err instanceof Error ? (err.stack ?? err.message) : String(err));
+      }
+      changeDetectionService.start(adapter, true);
     }
   }
 
diff --git a/code/core/src/core-server/index.ts b/code/core/src/core-server/index.ts
index d4cf1bcd7eac..c1a75eff1047 100644
--- a/code/core/src/core-server/index.ts
+++ b/code/core/src/core-server/index.ts
@@ -28,6 +28,19 @@ export {
 export {
   getChangeDetectionReadiness as experimental_getChangeDetectionReadiness,
   type ChangeDetectionReadiness as Experimental_ChangeDetectionReadiness,
+  ChangeDetectionFailureError,
+  ChangeDetectionUnavailableError,
+} from './change-detection/index.ts';
+export type {
+  ChangeDetectionAdapter,
+  FileChangeEvent,
+  ModuleResolveConfig,
+} from './change-detection/index.ts';
+export type {
+  ImportEdge,
+  ImportParser,
+  ImportParserContext,
+  ParseFileArgs,
 } from './change-detection/index.ts';
 export { ChangeDetectionService } from './change-detection/ChangeDetectionService.ts';
 export {
diff --git a/code/core/src/core-server/presets/common-preset.ts b/code/core/src/core-server/presets/common-preset.ts
index 966356b01645..cc9fb0c65653 100644
--- a/code/core/src/core-server/presets/common-preset.ts
+++ b/code/core/src/core-server/presets/common-preset.ts
@@ -207,7 +207,7 @@ export const features: PresetProperty<'features'> = async (existing) => ({
   actions: true,
   argTypeTargetsV7: true,
   backgrounds: true,
-  changeDetection: false,
+  changeDetection: true,
   componentsManifest: false,
   controls: true,
   disallowImplicitActionsInRenderV8: true,
diff --git a/code/core/src/manager-api/modules/stories.ts b/code/core/src/manager-api/modules/stories.ts
index d860e131cdf1..ba42fe6fb014 100644
--- a/code/core/src/manager-api/modules/stories.ts
+++ b/code/core/src/manager-api/modules/stories.ts
@@ -61,6 +61,7 @@ import {
 } from '../lib/stories.ts';
 import type { ModuleFn } from '../lib/types.tsx';
 import { buildNavigationUrl } from '../lib/url.ts';
+import { hasActiveFilters } from '../../shared/utils/story-index-filters.ts';
 import type { ComposedRef } from '../root.tsx';
 import { fullStatusStore } from '../stores/status.ts';
 import { BUILT_IN_FILTERS } from '../../shared/constants/tags.ts';
@@ -596,21 +597,11 @@ export const init: ModuleFn<SubAPI, SubState> = ({
       }
     },
     selectFirstStory: () => {
-      const {
-        index,
-        filteredIndex,
-        includedTagFilters,
-        excludedTagFilters,
-        includedStatusFilters,
-        excludedStatusFilters,
-      } = store.getState();
-      const hasActiveFilters =
-        includedTagFilters.length > 0 ||
-        excludedTagFilters.length > 0 ||
-        (includedStatusFilters?.length ?? 0) > 0 ||
-        (excludedStatusFilters?.length ?? 0) > 0;
-
-      if (hasActiveFilters) {
+      const state = store.getState();
+      const hasAnyActiveFilters = hasActiveFilters(state);
+
+      if (hasAnyActiveFilters) {
+        const { filteredIndex } = state;
         if (!filteredIndex) {
           return;
         }
@@ -624,6 +615,7 @@ export const init: ModuleFn<SubAPI, SubState> = ({
         return;
       }
 
+      const { index } = state;
       if (!index) {
         return;
       }
@@ -1044,20 +1036,10 @@ export const init: ModuleFn<SubAPI, SubState> = ({
          * - If the user started storybook with a specific page-URL like "/settings/about"
          */
         if (isCanvasRoute) {
-          const {
-            includedTagFilters,
-            excludedTagFilters,
-            includedStatusFilters,
-            excludedStatusFilters,
-            filteredIndex,
-          } = state;
-          const hasActiveFilters =
-            (includedTagFilters?.length ?? 0) > 0 ||
-            (excludedTagFilters?.length ?? 0) > 0 ||
-            (includedStatusFilters?.length ?? 0) > 0 ||
-            (excludedStatusFilters?.length ?? 0) > 0;
-
-          if (hasActiveFilters && !stateHasSelection) {
+          const hasAnyActiveFilters = hasActiveFilters(state);
+
+          if (hasAnyActiveFilters && !stateHasSelection) {
+            const { filteredIndex } = state;
             const storyPassesFilter = filteredIndex && filteredIndex[storyId]?.type === 'story';
 
             if (!storyPassesFilter) {
diff --git a/code/core/src/manager/components/sidebar/Filter.tsx b/code/core/src/manager/components/sidebar/Filter.tsx
index 35dff36f30c2..223ee4f40f75 100644
--- a/code/core/src/manager/components/sidebar/Filter.tsx
+++ b/code/core/src/manager/components/sidebar/Filter.tsx
@@ -9,6 +9,7 @@ import { FilterIcon } from '@storybook/icons';
 import { type API, type Combo, Consumer, experimental_useStatusStore } from 'storybook/manager-api';
 import { styled } from 'storybook/theming';
 
+import { getActiveFilterCount } from '../../../shared/utils/story-index-filters.ts';
 import { FilterPanel } from './FilterPanel.tsx';
 
 const StyledButton = styled(Button)<{ $isHighlighted: boolean }>(({ $isHighlighted, theme }) => ({
@@ -42,11 +43,7 @@ const TagSelected = styled(Badge)(({ theme }) => ({
 const filterMapper = ({ api, state }: Combo) => ({
   api,
   indexJson: state.internal_index as StoryIndex | undefined,
-  activeFilterCount:
-    (state.includedTagFilters?.length ?? 0) +
-    (state.excludedTagFilters?.length ?? 0) +
-    (state.includedStatusFilters?.length ?? 0) +
-    (state.excludedStatusFilters?.length ?? 0),
+  activeFilterCount: getActiveFilterCount(state),
   defaultIncludedFilters: state.defaultIncludedTagFilters,
   defaultExcludedFilters: state.defaultExcludedTagFilters,
   includedFilters: state.includedTagFilters,
diff --git a/code/core/src/manager/components/sidebar/FilterPanel.tsx b/code/core/src/manager/components/sidebar/FilterPanel.tsx
index ed6042f9b5d5..e7623237df0a 100644
--- a/code/core/src/manager/components/sidebar/FilterPanel.tsx
+++ b/code/core/src/manager/components/sidebar/FilterPanel.tsx
@@ -94,6 +94,7 @@ export const FilterPanel = ({
         id: shortName,
         type: 'status',
         title: shortName.charAt(0).toUpperCase() + shortName.slice(1),
+        tooltip: entry.description,
         count: entry.count,
         icon: statusIconEl ? <StatusIcon $iconColor={iconColor}>{statusIconEl}</StatusIcon> : null,
         isIncluded,
@@ -140,9 +141,7 @@ export const FilterPanel = ({
   );
 
   const setAllFilters = useCallback(
-    (selected: boolean) => {
-      api.setAllTagFilters(selected ? filterIds : [], []);
-    },
+    (selected: boolean) => api.setAllTagFilters(selected ? filterIds : [], []),
     [api, filterIds]
   );
 
@@ -181,9 +180,9 @@ export const FilterPanel = ({
                 ariaLabel={false}
                 id="deselect-all"
                 key="deselect-all"
-                onClick={() => {
-                  setAllFilters(false);
-                  api.resetStatusFilters();
+                onClick={async () => {
+                  await setAllFilters(false);
+                  await api.resetStatusFilters();
                 }}
               >
                 <SweepIcon />
diff --git a/code/core/src/manager/components/sidebar/FilterPanel.utils.ts b/code/core/src/manager/components/sidebar/FilterPanel.utils.ts
index 6381ed46bf4c..e1079d471e50 100644
--- a/code/core/src/manager/components/sidebar/FilterPanel.utils.ts
+++ b/code/core/src/manager/components/sidebar/FilterPanel.utils.ts
@@ -4,12 +4,17 @@ import type { FilterFunction, StatusValue, Tag } from 'storybook/internal/types'
 
 import { BUILT_IN_FILTERS, USER_TAG_FILTER } from '../../../shared/constants/tags.ts';
 
-export { countStatusesByValue, statusValueShortName } from '../../../shared/status-store/index.ts';
+export {
+  countStatusesByValue,
+  statusValueShortName,
+  statusValueDescription,
+} from '../../../shared/status-store/index.ts';
 
 export type FilterItem = {
   id: string;
   type: string;
   title: string;
+  tooltip?: string;
   count: number;
   icon: ReactElement | null;
   isIncluded: boolean;
diff --git a/code/core/src/manager/components/sidebar/FilterPanelLink.tsx b/code/core/src/manager/components/sidebar/FilterPanelLink.tsx
index 2430091c7465..e2ba1c41767e 100644
--- a/code/core/src/manager/components/sidebar/FilterPanelLink.tsx
+++ b/code/core/src/manager/components/sidebar/FilterPanelLink.tsx
@@ -25,6 +25,7 @@ export const createFilterLink = ({
   id,
   type,
   title,
+  tooltip,
   count,
   icon,
   isIncluded,
@@ -34,7 +35,7 @@ export const createFilterLink = ({
 }: FilterItem): Link => {
   const isChecked = isIncluded || isExcluded;
   const toggleLabel = `${type} filter: ${isExcluded ? `exclude ${title}` : title}`;
-  const toggleTooltip = `${isChecked ? 'Remove' : 'Add'} ${type} filter: ${title}`;
+  const toggleTooltip = tooltip ?? `${isChecked ? 'Remove' : 'Add'} ${type} filter: ${title}`;
   const invertButtonLabel = `${isExcluded ? 'Include' : 'Exclude'} ${type}: ${title}`;
 
   return {
diff --git a/code/core/src/manager/components/sidebar/NoResults.tsx b/code/core/src/manager/components/sidebar/NoResults.tsx
index 26c128aa4e6a..db135ed3f711 100644
--- a/code/core/src/manager/components/sidebar/NoResults.tsx
+++ b/code/core/src/manager/components/sidebar/NoResults.tsx
@@ -14,4 +14,8 @@ export const NoResults = styled.div(({ theme }) => ({
     color: theme.textMutedColor,
     fontSize: `${theme.typography.size.s1}px`,
   },
+  button: {
+    marginTop: 8,
+    alignSelf: 'center',
+  },
 }));
diff --git a/code/core/src/manager/components/sidebar/RefBlocks.tsx b/code/core/src/manager/components/sidebar/RefBlocks.tsx
index 45f8a09ce421..bc4910da53e7 100644
--- a/code/core/src/manager/components/sidebar/RefBlocks.tsx
+++ b/code/core/src/manager/components/sidebar/RefBlocks.tsx
@@ -11,8 +11,9 @@ import {
 } from 'storybook/internal/components';
 
 import { global } from '@storybook/global';
-import { ChevronDownIcon, LockIcon, SyncIcon } from '@storybook/icons';
+import { ChevronDownIcon, LockIcon, SweepIcon, SyncIcon } from '@storybook/icons';
 
+import { useStorybookApi } from 'storybook/manager-api';
 import { styled } from 'storybook/theming';
 
 import { useLayout } from '../layout/LayoutProvider.tsx';
@@ -157,52 +158,82 @@ const WideSpaced = styled(Spaced)({
   flex: 1,
 });
 
-export const EmptyBlock = ({ isMain, hasEntries }: { isMain: boolean; hasEntries: boolean }) => (
-  <Contained>
-    <FlexSpaced col={1}>
-      <WideSpaced>
-        {hasEntries ? (
-          <NoResults>
-            <strong>No stories found</strong>
-            <small>Your selected filters did not match any stories.</small>
-          </NoResults>
-        ) : isMain ? (
-          <Text>
-            Oh no! Your Storybook is empty. This can happen when:
-            <ul>
-              <li>
-                Your{' '}
-                <Link
-                  href="https://storybook.js.org/docs/api/main-config/main-config-stories?ref=ui"
-                  cancel={false}
-                  target="_blank"
-                >
-                  stories glob configuration
-                </Link>{' '}
-                does not match any files.{' '}
-              </li>
-              <li>
-                You have{' '}
-                <Link
-                  href="https://storybook.js.org/docs/writing-stories?ref=ui"
-                  cancel={false}
-                  target="_blank"
+export const EmptyBlock = ({
+  isMain,
+  hasEntries,
+  activeFilterCount,
+}: {
+  isMain: boolean;
+  hasEntries: boolean;
+  activeFilterCount: number;
+}) => {
+  const api = useStorybookApi();
+
+  return (
+    <Contained>
+      <FlexSpaced col={1}>
+        <WideSpaced>
+          {hasEntries ? (
+            <NoResults>
+              <strong>No stories found</strong>
+              {activeFilterCount > 0 ? (
+                <small>Your selected filters did not match any stories.</small>
+              ) : (
+                <small>Try adding some stories!</small>
+              )}
+              {activeFilterCount > 0 ? (
+                <Button
+                  ariaLabel={false}
+                  size="small"
+                  variant="outline"
+                  onClick={async () => {
+                    await api.setAllTagFilters([], []);
+                    await api.resetStatusFilters();
+                  }}
                 >
-                  no stories defined
-                </Link>{' '}
-                in your story files.{' '}
-              </li>
-            </ul>
-          </Text>
-        ) : (
-          <Text>
-            This composed Storybook is empty. Perhaps no stories match your selected filters.
-          </Text>
-        )}
-      </WideSpaced>
-    </FlexSpaced>
-  </Contained>
-);
+                  <SweepIcon />
+                  Clear filters
+                </Button>
+              ) : null}
+            </NoResults>
+          ) : isMain ? (
+            <Text>
+              Oh no! Your Storybook is empty. This can happen when:
+              <ul>
+                <li>
+                  Your{' '}
+                  <Link
+                    href="https://storybook.js.org/docs/api/main-config/main-config-stories?ref=ui"
+                    cancel={false}
+                    target="_blank"
+                  >
+                    stories glob configuration
+                  </Link>{' '}
+                  does not match any files.{' '}
+                </li>
+                <li>
+                  You have{' '}
+                  <Link
+                    href="https://storybook.js.org/docs/writing-stories?ref=ui"
+                    cancel={false}
+                    target="_blank"
+                  >
+                    no stories defined
+                  </Link>{' '}
+                  in your story files.{' '}
+                </li>
+              </ul>
+            </Text>
+          ) : (
+            <Text>
+              This composed Storybook is empty. Perhaps no stories match your selected filters.
+            </Text>
+          )}
+        </WideSpaced>
+      </FlexSpaced>
+    </Contained>
+  );
+};
 
 export const LoaderBlock: FC<{ isMain: boolean }> = ({ isMain }) => (
   <Contained>
diff --git a/code/core/src/manager/components/sidebar/Refs.tsx b/code/core/src/manager/components/sidebar/Refs.tsx
index 2011bc1da0e4..591e133dc94c 100644
--- a/code/core/src/manager/components/sidebar/Refs.tsx
+++ b/code/core/src/manager/components/sidebar/Refs.tsx
@@ -4,6 +4,7 @@ import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useStorybookApi, useStorybookState } from 'storybook/manager-api';
 import { styled } from 'storybook/theming';
 
+import { getActiveFilterCount } from '../../../shared/utils/story-index-filters.ts';
 import { getStateType } from '../../utils/tree.ts';
 import { AuthBlock, EmptyBlock, ErrorBlock, LoaderBlock } from './RefBlocks.tsx';
 import { RefIndicator } from './RefIndicator.tsx';
@@ -73,7 +74,7 @@ const CollapseButton = styled.button(({ theme }) => ({
 }));
 
 export const Ref: FC<RefType & RefProps> = React.memo(function Ref(props) {
-  const { docsOptions } = useStorybookState();
+  const storybookState = useStorybookState();
   const api = useStorybookApi();
   const {
     filteredIndex: index,
@@ -103,6 +104,7 @@ export const Ref: FC<RefType & RefProps> = React.memo(function Ref(props) {
   const isError = !!indexError;
   const isEmpty = !isLoading && length === 0;
   const isAuthRequired = !!loginUrl && length === 0;
+  const activeFilterCount = getActiveFilterCount(storybookState);
 
   const state = getStateType(isLoading, isAuthRequired, isError, isEmpty);
   const [isExpanded, setExpanded] = useState<boolean>(expanded);
@@ -111,9 +113,9 @@ export const Ref: FC<RefType & RefProps> = React.memo(function Ref(props) {
     if (index && selectedStoryId && index[selectedStoryId]) {
       setExpanded(true);
     }
-  }, [setExpanded, index, selectedStoryId]);
+  }, [index, selectedStoryId]);
 
-  const handleClick = useCallback(() => setExpanded((value) => !value), [setExpanded]);
+  const handleClick = useCallback(() => setExpanded((value) => !value), []);
 
   const setHighlightedItemId = useCallback(
     (itemId: string) => setHighlighted({ itemId, refId }),
@@ -146,7 +148,13 @@ export const Ref: FC<RefType & RefProps> = React.memo(function Ref(props) {
           {/* @ts-expect-error (non strict) */}
           {state === 'error' && <ErrorBlock error={indexError} />}
           {state === 'loading' && <LoaderBlock isMain={isMain} />}
-          {state === 'empty' && <EmptyBlock isMain={isMain} hasEntries={hasEntries} />}
+          {state === 'empty' && (
+            <EmptyBlock
+              isMain={isMain}
+              hasEntries={hasEntries}
+              activeFilterCount={activeFilterCount}
+            />
+          )}
           {state === 'ready' && (
             <Tree
               allStatuses={allStatuses}
@@ -156,7 +164,7 @@ export const Ref: FC<RefType & RefProps> = React.memo(function Ref(props) {
               // @ts-expect-error (non strict)
               data={index}
               // @ts-expect-error (non strict)
-              docsMode={docsOptions.docsMode}
+              docsMode={storybookState.docsOptions.docsMode}
               selectedStoryId={selectedStoryId}
               onSelectStoryId={onSelectStoryId}
               highlightedRef={highlightedRef}
diff --git a/code/core/src/manager/components/sidebar/Sidebar.stories.tsx b/code/core/src/manager/components/sidebar/Sidebar.stories.tsx
index e312809d2e13..262caaa11e6e 100644
--- a/code/core/src/manager/components/sidebar/Sidebar.stories.tsx
+++ b/code/core/src/manager/components/sidebar/Sidebar.stories.tsx
@@ -258,6 +258,45 @@ export const EmptyMobile: Story = {
   play: waitForChecklistWidget,
 };
 
+export const EmptyWithFilters: Story = {
+  args: Empty.args,
+  decorators: [
+    (storyFn, { args, globals, title }) => {
+      const context = managerContext(args);
+      return (
+        <ManagerContext.Provider
+          value={{
+            ...context,
+            state: {
+              ...context.state,
+              includedTagFilters: ['A'],
+              excludedTagFilters: ['B'],
+              includedStatusFilters: [],
+              excludedStatusFilters: [],
+            },
+          }}
+        >
+          <LayoutProvider
+            forceDesktop={
+              globals.viewport?.value === 'desktop' ||
+              globals.viewport?.value === undefined ||
+              title.endsWith('scrolled')
+            }
+          >
+            {storyFn()}
+          </LayoutProvider>
+        </ManagerContext.Provider>
+      );
+    },
+  ],
+  play: async ({ canvasElement }) => {
+    await waitForChecklistWidget();
+    const canvas = within(canvasElement);
+    const clearFiltersButton = await canvas.findByRole('button', { name: 'Clear filters' });
+    await expect(clearFiltersButton).toBeInTheDocument();
+  },
+};
+
 export const EmptyIndex: Story = {
   args: {
     index: {},
diff --git a/code/core/src/manager/components/sidebar/useFilterData.tsx b/code/core/src/manager/components/sidebar/useFilterData.tsx
index 6ae2f192fa45..c31082ebb40c 100644
--- a/code/core/src/manager/components/sidebar/useFilterData.tsx
+++ b/code/core/src/manager/components/sidebar/useFilterData.tsx
@@ -18,6 +18,7 @@ import {
   countStatusesByValue,
   getFilterFunction,
   statusValueShortName,
+  statusValueDescription,
 } from './FilterPanel.utils.ts';
 
 export interface TagFilterEntry {
@@ -32,6 +33,7 @@ export interface StatusFilterEntry {
   statusValue: StatusValue;
   shortName: string;
   count: number;
+  description?: string;
 }
 
 const BUILT_IN_FILTER_DEFS: Array<{
@@ -92,6 +94,7 @@ export function useStatusFilterEntries(allStatuses: StatusesByStoryIdAndTypeId)
     return STATUS_DISPLAY_ORDER.map((statusValue) => ({
       statusValue,
       shortName: statusValueShortName(statusValue),
+      description: statusValueDescription(statusValue),
       count: counts[statusValue] ?? 0,
     }));
   }, [allStatuses]);
diff --git a/code/core/src/oxc-parser/errors.ts b/code/core/src/oxc-parser/errors.ts
new file mode 100644
index 000000000000..ec56e747b780
--- /dev/null
+++ b/code/core/src/oxc-parser/errors.ts
@@ -0,0 +1,21 @@
+import { Category, StorybookError } from '../server-errors.ts';
+
+/**
+ * Thrown by the oxc-parser sub-package whenever parsing fails (parser error, missing module
+ * info, worker-thread failure, pool tear-down). Callers that want soft fallback semantics
+ * should catch this and decide how to recover; the worker-pool already swallows pool-level
+ * failures and falls back to inline parsing in {@link parseWithOxc}.
+ */
+export class OxcParseError extends StorybookError {
+  constructor(message: string, options?: ErrorOptions) {
+    super({
+      name: 'OxcParseError',
+      category: Category.CORE_SERVER,
+      code: 17,
+      message,
+    });
+    if (options?.cause !== undefined) {
+      (this as Error & { cause?: unknown }).cause = options.cause;
+    }
+  }
+}
diff --git a/code/core/src/oxc-parser/index.ts b/code/core/src/oxc-parser/index.ts
new file mode 100644
index 000000000000..8d34ec351623
--- /dev/null
+++ b/code/core/src/oxc-parser/index.ts
@@ -0,0 +1,28 @@
+import { oxcParse } from './parse.ts';
+import type { ImportEdge } from './types.ts';
+import { disposeOxcParsePool, getOxcParsePool } from './worker-pool.ts';
+
+export type { ImportEdge } from './types.ts';
+
+/**
+ * Parses a file with oxc-parser, using the worker pool when available and falling back to
+ * inline {@link oxcParse} otherwise. Plugin parsers (Vue/Svelte/MDX) that use
+ * `ctx.parseScriptWithOxc` also route through here, so SFC script blocks get the same
+ * off-thread treatment as plain JS/TS files.
+ */
+export async function parseWithOxc(filePath: string, source: string): Promise<ImportEdge[]> {
+  const pool = getOxcParsePool();
+  if (!pool) {
+    return oxcParse(filePath, source);
+  }
+  try {
+    return await pool.parse(filePath, source);
+  } catch {
+    // Worker-level failure: fall back to inline so a single bad pool doesn't break the
+    // whole build. The pool logs its own debug line; callers get the inline error if the
+    // parse is genuinely malformed.
+    return oxcParse(filePath, source);
+  }
+}
+
+export { disposeOxcParsePool };
diff --git a/code/core/src/oxc-parser/parse.ts b/code/core/src/oxc-parser/parse.ts
new file mode 100644
index 000000000000..385caa5b234b
--- /dev/null
+++ b/code/core/src/oxc-parser/parse.ts
@@ -0,0 +1,182 @@
+import { parse as oxcRawParse } from 'oxc-parser';
+
+import { OxcParseError } from './errors.ts';
+import type { ImportEdge } from './types.ts';
+
+/**
+ * Files larger than this are treated as opaque-leaf and skipped — protects the require-walk
+ * iterator (and the worker IPC roundtrip) from O(MB) AST traversals on minified bundles or
+ * generated artefacts that happen to land in `code/`.
+ */
+const MAX_PARSE_SIZE = 2_000_000;
+
+/**
+ * Extracts literal-string import edges from a JS/TS/JSX/TSX source file using oxc-parser.
+ * Type-only imports/exports and non-literal dynamic-import specifiers are skipped.
+ * Throws {@link OxcParseError} when the parser fails or returns no module
+ * info; callers should catch and treat such files as opaque-leaf.
+ */
+export async function oxcParse(filePath: string, source: string): Promise<ImportEdge[]> {
+  if (source.length > MAX_PARSE_SIZE) {
+    return [];
+  }
+  let parseResult: Awaited<ReturnType<typeof oxcRawParse>>;
+  try {
+    parseResult = await oxcRawParse(filePath, source);
+  } catch (error) {
+    throw new OxcParseError(
+      `oxc-parser failed for ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? { cause: error } : undefined
+    );
+  }
+
+  const moduleInfo = parseResult.module;
+  if (!moduleInfo) {
+    throw new OxcParseError(`oxc-parser returned no module info for ${filePath}`);
+  }
+
+  const edges: ImportEdge[] = [];
+  const seen = new Set<string>();
+
+  for (const staticImport of moduleInfo.staticImports) {
+    const specifier = staticImport.moduleRequest.value;
+    // A `StaticImport` represents `import ... from "mod"`. If every specifier
+    // entry is `isType`, the whole import is type-only and contributes no
+    // runtime edge. Bare `import "mod"` (entries empty) IS a runtime edge.
+    const allTypeOnly =
+      staticImport.entries.length > 0 && staticImport.entries.every((entry) => entry.isType);
+    if (allTypeOnly) {
+      continue;
+    }
+    const key = `static:${specifier}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    edges.push({ specifier, kind: 'static' });
+  }
+
+  for (const staticExport of moduleInfo.staticExports) {
+    for (const entry of staticExport.entries) {
+      if (!entry.moduleRequest || entry.isType) {
+        continue;
+      }
+      const specifier = entry.moduleRequest.value;
+      const key = `static:${specifier}`;
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      edges.push({ specifier, kind: 'static' });
+    }
+  }
+
+  for (const dynamicImport of moduleInfo.dynamicImports) {
+    const specifierSpan = dynamicImport.moduleRequest;
+    const literal = extractLiteralFromSource(source, specifierSpan.start, specifierSpan.end);
+    if (literal === null) {
+      continue;
+    }
+    const key = `dynamic:${literal}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    edges.push({ specifier: literal, kind: 'dynamic' });
+  }
+
+  // oxc-parser does not surface require() calls separately. Walk the AST only after two
+  // cheap gates: ESM-exclusive extensions skip the walk entirely, and a source-level
+  // substring prefilter rules out files that cannot contain the literal `require(` token.
+  if (parseResult.program?.body && canContainRequireCall(filePath, source)) {
+    collectRequireSpecifiers(parseResult.program, edges, seen);
+  }
+
+  return edges;
+}
+
+function canContainRequireCall(filePath: string, source: string): boolean {
+  const dot = filePath.lastIndexOf('.');
+  if (dot !== -1) {
+    const ext = filePath.slice(dot).toLowerCase();
+    if (ext === '.mjs' || ext === '.mts') {
+      return false;
+    }
+  }
+  return source.includes('require(');
+}
+
+/**
+ * The dynamic-import `moduleRequest` span covers the literal token (including its
+ * surrounding quotes) when the argument IS a string literal. If the argument is
+ * non-literal (`import(someVar)`), the span still exists but does not delimit a
+ * string literal we can use; we return null in that case so the caller skips it.
+ */
+function extractLiteralFromSource(source: string, start: number, end: number): string | null {
+  if (start < 0 || end > source.length || end <= start) {
+    return null;
+  }
+  const slice = source.slice(start, end);
+  const first = slice[0];
+  const last = slice[slice.length - 1];
+  if ((first === '"' || first === "'" || first === '`') && last === first && slice.length >= 2) {
+    const inner = slice.slice(1, -1);
+    // Template literals with interpolation contain `${`; treat those as non-literal.
+    if (first === '`' && inner.includes('${')) {
+      return null;
+    }
+    return inner;
+  }
+  return null;
+}
+
+/**
+ * Iterative AST walk for `CallExpression` nodes whose callee is the identifier `require`
+ * and whose first argument is a string literal. Iterative (not recursive) so deeply
+ * nested ASTs cannot blow the call stack on minified bundles. Skips estree-shaped
+ * metadata fields (`parent`/`loc`/`range`); oxc-parser does not emit `parent`/`loc`/
+ * `range`, so the skip is defensive against future shape changes.
+ */
+function collectRequireSpecifiers(root: unknown, edges: ImportEdge[], seen: Set<string>): void {
+  const stack: unknown[] = [root];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node === null || typeof node !== 'object') {
+      continue;
+    }
+    if (Array.isArray(node)) {
+      for (let i = node.length - 1; i >= 0; i--) {
+        stack.push(node[i]);
+      }
+      continue;
+    }
+
+    const maybeNode = node as { type?: unknown; callee?: unknown; arguments?: unknown };
+    if (maybeNode.type === 'CallExpression') {
+      const callee = maybeNode.callee as { type?: unknown; name?: unknown } | null | undefined;
+      if (callee && callee.type === 'Identifier' && callee.name === 'require') {
+        const args = Array.isArray(maybeNode.arguments) ? maybeNode.arguments : [];
+        const firstArg = args[0] as { type?: unknown; value?: unknown } | null | undefined;
+        if (
+          firstArg &&
+          (firstArg.type === 'StringLiteral' || firstArg.type === 'Literal') &&
+          typeof firstArg.value === 'string'
+        ) {
+          const specifier = firstArg.value;
+          const key = `require:${specifier}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            edges.push({ specifier, kind: 'require' });
+          }
+        }
+      }
+    }
+
+    for (const key of Object.keys(node)) {
+      if (key === 'parent' || key === 'loc' || key === 'range') {
+        continue;
+      }
+      stack.push((node as Record<string, unknown>)[key]);
+    }
+  }
+}
diff --git a/code/core/src/oxc-parser/types.ts b/code/core/src/oxc-parser/types.ts
new file mode 100644
index 000000000000..b744ed2e8d48
--- /dev/null
+++ b/code/core/src/oxc-parser/types.ts
@@ -0,0 +1,10 @@
+/**
+ * A single import edge extracted from a source file. `specifier` is the literal token the
+ * source used (e.g. `./foo`, `lodash`, `@scope/pkg`). `kind` distinguishes the three edge
+ * flavours the oxc-parser surfaces: static `import`/`export`, dynamic `import()`, and
+ * CommonJS `require()`.
+ */
+export interface ImportEdge {
+  specifier: string;
+  kind: 'static' | 'dynamic' | 'require';
+}
diff --git a/code/core/src/oxc-parser/worker-pool.test.ts b/code/core/src/oxc-parser/worker-pool.test.ts
new file mode 100644
index 000000000000..884d1f686b0e
--- /dev/null
+++ b/code/core/src/oxc-parser/worker-pool.test.ts
@@ -0,0 +1,222 @@
+// Unit tests for the worker-pool dispatch / failure / dispose / refcount plumbing. A real
+// worker is substituted with an EventEmitter stand-in so the tests stay hermetic.
+import type { EventEmitter } from 'node:events';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+interface FakeMsg {
+  id: number;
+  filePath: string;
+  source: string;
+}
+
+interface FakeWorkerHook {
+  onPostMessage?: (msg: FakeMsg) => void;
+}
+
+interface FakeWorker extends EventEmitter {
+  terminated: boolean;
+  hook: FakeWorkerHook;
+  postMessage: ReturnType<typeof vi.fn>;
+  terminate: ReturnType<typeof vi.fn>;
+  unref: ReturnType<typeof vi.fn>;
+  ref: ReturnType<typeof vi.fn>;
+}
+
+const fakeWorkers: FakeWorker[] = [];
+let constructorThrowAt = -1;
+
+vi.mock('node:worker_threads', async () => {
+  const { EventEmitter: NodeEventEmitter } = await import('node:events');
+
+  class FakeWorkerImpl extends NodeEventEmitter {
+    terminated = false;
+    hook: FakeWorkerHook = {};
+    constructor() {
+      super();
+      if (constructorThrowAt === fakeWorkers.length) {
+        throw new Error(`fake constructor failure at index ${constructorThrowAt}`);
+      }
+      fakeWorkers.push(this as unknown as FakeWorker);
+    }
+    postMessage = vi.fn((msg: FakeMsg) => {
+      if (this.hook.onPostMessage) {
+        this.hook.onPostMessage(msg);
+        return;
+      }
+      queueMicrotask(() => {
+        this.emit('message', {
+          id: msg.id,
+          ok: true,
+          edges: [{ specifier: `edge-for:${msg.filePath}`, kind: 'static' }],
+        });
+      });
+    });
+    terminate = vi.fn(async () => {
+      this.terminated = true;
+      return 0;
+    });
+    unref = vi.fn();
+    ref = vi.fn();
+  }
+
+  return { Worker: FakeWorkerImpl };
+});
+
+vi.mock('node:fs', () => ({ existsSync: () => true }));
+
+vi.mock('storybook/internal/node-logger', { spy: true });
+
+const loadModule = async () => await import('./worker-pool.ts');
+
+describe('OxcWorkerPool', () => {
+  beforeEach(() => {
+    fakeWorkers.length = 0;
+    constructorThrowAt = -1;
+  });
+
+  afterEach(async () => {
+    const mod = await loadModule();
+    await mod._resetOxcParsePoolForTesting();
+    vi.resetModules();
+    fakeWorkers.length = 0;
+  });
+
+  it('dispatches parses through the fake worker and returns edges', async () => {
+    const { OxcWorkerPool } = await loadModule();
+    const pool = new OxcWorkerPool('/fake/script.js', 2);
+
+    const edges = await pool.parse('/src/a.ts', 'import "x";');
+
+    expect(edges).toEqual([{ specifier: 'edge-for:/src/a.ts', kind: 'static' }]);
+    await pool.dispose();
+  });
+
+  it('serialises tasks when all workers are busy and releases slots on response', async () => {
+    const { OxcWorkerPool } = await loadModule();
+    const pool = new OxcWorkerPool('/fake/script.js', 1);
+
+    const [a, b, c] = await Promise.all([
+      pool.parse('/src/a.ts', 'x'),
+      pool.parse('/src/b.ts', 'x'),
+      pool.parse('/src/c.ts', 'x'),
+    ]);
+
+    expect(a[0].specifier).toBe('edge-for:/src/a.ts');
+    expect(b[0].specifier).toBe('edge-for:/src/b.ts');
+    expect(c[0].specifier).toBe('edge-for:/src/c.ts');
+    await pool.dispose();
+  });
+
+  it('rejects in-flight parses on dispose', async () => {
+    const { OxcWorkerPool } = await loadModule();
+    const pool = new OxcWorkerPool('/fake/script.js', 1);
+
+    fakeWorkers[0].hook.onPostMessage = () => {
+      // never echoes — task will sit pending until dispose
+    };
+
+    const pending = pool.parse('/src/stuck.ts', 'x');
+    await pool.dispose();
+    await expect(pending).rejects.toThrow(/disposed/);
+  });
+
+  it('rejects all in-flight tasks and disposes the pool when a worker errors', async () => {
+    const { OxcWorkerPool, getOxcParsePool } = await loadModule();
+    const pool = new OxcWorkerPool('/fake/script.js', 2, 0); // disable timeout
+
+    // Both workers hang so tasks stay in flight.
+    fakeWorkers[0].hook.onPostMessage = () => {};
+    fakeWorkers[1].hook.onPostMessage = () => {};
+
+    const taskA = pool.parse('/src/a.ts', 'x');
+    const taskB = pool.parse('/src/b.ts', 'x');
+
+    fakeWorkers[0].emit('error', new Error('boom'));
+
+    await expect(taskA).rejects.toThrow(/oxc-worker failure: boom/);
+    await expect(taskB).rejects.toThrow(/oxc-worker failure: boom/);
+
+    // Subsequent parse() on the now-disposed pool fails fast.
+    await expect(pool.parse('/src/c.ts', 'x')).rejects.toThrow(/disposed/);
+  });
+
+  it('rejects victim entries when a worker emits exit unexpectedly', async () => {
+    const { OxcWorkerPool } = await loadModule();
+    const pool = new OxcWorkerPool('/fake/script.js', 1, 0);
+
+    fakeWorkers[0].hook.onPostMessage = () => {
+      /* never echoes */
+    };
+
+    const pending = pool.parse('/src/a.ts', 'x');
+    fakeWorkers[0].emit('exit', 137);
+    await expect(pending).rejects.toThrow(/oxc-worker exit/);
+    await pool.dispose();
+  });
+
+  it('terminates already-spawned workers when constructor throws partway', async () => {
+    const { OxcWorkerPool } = await loadModule();
+    constructorThrowAt = 2; // fail on third construction
+    expect(() => new OxcWorkerPool('/fake/script.js', 4)).toThrow(/fake constructor failure/);
+    // Two workers were spawned before the throw; both must be terminated.
+    expect(fakeWorkers.length).toBe(2);
+    expect(fakeWorkers.every((w) => w.terminate.mock.calls.length > 0)).toBe(true);
+  });
+
+  it('times out hung tasks at the configured per-task timeout', async () => {
+    const { OxcWorkerPool } = await loadModule();
+    const pool = new OxcWorkerPool('/fake/script.js', 1, 50);
+
+    fakeWorkers[0].hook.onPostMessage = () => {
+      /* hang */
+    };
+
+    const pending = pool.parse('/src/hang.ts', 'x');
+    await expect(pending).rejects.toThrow(/timed out/);
+    await pool.dispose();
+  });
+
+  it('dispose() rejects pending parse() callers before terminate() completes (H1 regression)', async () => {
+    const { OxcWorkerPool } = await loadModule();
+    const pool = new OxcWorkerPool('/fake/script.js', 2, 0);
+
+    // Make both workers hang — tasks will sit in pending until dispose.
+    fakeWorkers[0].hook.onPostMessage = () => {};
+    fakeWorkers[1].hook.onPostMessage = () => {};
+
+    // Override terminate() to return a never-resolving promise to simulate a hung worker.
+    const neverResolve = new Promise<number>(() => {});
+    fakeWorkers[0].terminate.mockReturnValue(neverResolve);
+    fakeWorkers[1].terminate.mockReturnValue(neverResolve);
+
+    const p1 = pool.parse('/src/a.ts', 'x');
+    const p2 = pool.parse('/src/b.ts', 'x');
+
+    // Race: parse rejections should win against a 100 ms timeout even though terminate() hangs.
+    const rejected = Promise.all([p1.catch((e) => e), p2.catch((e) => e)]);
+    const timeout = new Promise<'timeout'>((res) => setTimeout(() => res('timeout'), 100));
+
+    pool.dispose(); // intentionally not awaited — terminate() hangs
+    const result = await Promise.race([rejected, timeout]);
+
+    expect(result).not.toBe('timeout');
+    const [e1, e2] = result as [Error, Error];
+    expect(e1.message).toMatch(/disposed/);
+    expect(e2.message).toMatch(/disposed/);
+  });
+
+  it('getOxcParsePool returns the same instance on repeated calls; dispose tears it down and fresh instance is created on next call', async () => {
+    const { getOxcParsePool, disposeOxcParsePool } = await loadModule();
+    const pool = getOxcParsePool();
+    expect(pool).not.toBeNull();
+    // Repeated calls return the same instance without re-creating.
+    expect(getOxcParsePool()).toBe(pool);
+    // After dispose, the next call creates a fresh pool (lazy re-init).
+    await disposeOxcParsePool();
+    const fresh = getOxcParsePool();
+    expect(fresh).not.toBeNull();
+    expect(fresh).not.toBe(pool);
+    await disposeOxcParsePool();
+  });
+});
diff --git a/code/core/src/oxc-parser/worker-pool.ts b/code/core/src/oxc-parser/worker-pool.ts
new file mode 100644
index 000000000000..0ce0085ebb78
--- /dev/null
+++ b/code/core/src/oxc-parser/worker-pool.ts
@@ -0,0 +1,275 @@
+import { existsSync } from 'node:fs';
+import { cpus } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { Worker } from 'node:worker_threads';
+
+import { logger } from 'storybook/internal/node-logger';
+
+import { OxcParseError } from './errors.ts';
+import type { ImportEdge } from './types.ts';
+
+/**
+ * Pool of worker threads that each run {@link ./parse.ts} against the files the main
+ * thread hands them. Pool size is `min(4, max(1, cpus()-1))`. When the compiled worker
+ * script isn't on disk (e.g. running from source without a build), `getOxcParsePool`
+ * returns `null` and callers transparently fall back to inline parsing.
+ */
+interface Pending {
+  resolve: (edges: ImportEdge[]) => void;
+  reject: (error: unknown) => void;
+  /** Optional inactivity timer that rejects the entry if a worker hangs. */
+  timer?: NodeJS.Timeout;
+}
+
+interface WorkerSlot {
+  worker: Worker;
+  busy: boolean;
+}
+
+interface QueueEntry {
+  filePath: string;
+  source: string;
+  resolve: (edges: ImportEdge[]) => void;
+  reject: (error: unknown) => void;
+}
+
+interface WorkerResponse {
+  id: number;
+  ok: boolean;
+  edges?: ImportEdge[];
+  message?: string;
+  name?: string;
+}
+
+export interface OxcParsePool {
+  parse(filePath: string, source: string): Promise<ImportEdge[]>;
+  dispose(): Promise<void>;
+}
+
+// OxcWorkerPool ships bundled into `dist/core-server/index.js`; the worker is emitted as
+// a sibling sub-package at `dist/oxc-parser/worker.js`, one level up from core-server/.
+const WORKER_RELATIVE_PATH = '../oxc-parser/worker.js';
+
+const DEFAULT_TASK_TIMEOUT_MS = 30_000;
+
+function resolveWorkerScriptPath(): string | undefined {
+  // import.meta.url may be synthetic under exotic bundling; guard explicitly.
+  if (typeof import.meta.url !== 'string') {
+    return undefined;
+  }
+  const path = fileURLToPath(new URL(WORKER_RELATIVE_PATH, import.meta.url));
+  return existsSync(path) ? path : undefined;
+}
+
+function computePoolSize(): number {
+  const cpuCount = cpus().length;
+  return Math.max(1, Math.min(4, cpuCount - 1));
+}
+
+export class OxcWorkerPool implements OxcParsePool {
+  private readonly taskTimeoutMs: number;
+  private readonly workers: WorkerSlot[] = [];
+  private readonly queue: QueueEntry[] = [];
+  private readonly pending = new Map<number, Pending>();
+  private nextId = 0;
+  private disposed = false;
+
+  constructor(scriptPath: string, size: number, taskTimeoutMs = DEFAULT_TASK_TIMEOUT_MS) {
+    this.taskTimeoutMs = taskTimeoutMs;
+    try {
+      for (let i = 0; i < size; i++) {
+        const worker = new Worker(scriptPath);
+        const slot: WorkerSlot = { worker, busy: false };
+        worker.on('message', (msg: WorkerResponse) => this.handleMessage(slot, msg));
+        worker.on('error', (error) => this.handleWorkerFailure(error));
+        worker.on('exit', (code) => {
+          if (!this.disposed) {
+            this.handleWorkerFailure(new Error(`oxc-worker exited unexpectedly with code ${code}`));
+          }
+        });
+        // Release the event loop's grip so a spawned-but-idle pool never blocks shutdown.
+        worker.unref();
+        this.workers.push(slot);
+      }
+    } catch (err) {
+      // Partial-construction failure: terminate workers already spawned and rethrow.
+      for (const slot of this.workers) {
+        slot.worker.terminate().catch(() => 0);
+      }
+      this.workers.length = 0;
+      throw err;
+    }
+  }
+
+  parse(filePath: string, source: string): Promise<ImportEdge[]> {
+    if (this.disposed) {
+      return Promise.reject(new OxcParseError('oxc parse pool disposed'));
+    }
+    return new Promise<ImportEdge[]>((resolve, reject) => {
+      this.queue.push({ filePath, source, resolve, reject });
+      this.drain();
+    });
+  }
+
+  private drain(): void {
+    while (this.queue.length > 0) {
+      const slot = this.workers.find((s) => !s.busy);
+      if (!slot) {
+        return;
+      }
+      const task = this.queue.shift()!;
+      const id = this.nextId++;
+      slot.busy = true;
+      const pending: Pending = {
+        resolve: task.resolve,
+        reject: task.reject,
+      };
+      if (this.taskTimeoutMs > 0) {
+        pending.timer = setTimeout(() => {
+          this.handleWorkerFailure(
+            new Error(`oxc-worker task ${id} timed out after ${this.taskTimeoutMs}ms`)
+          );
+        }, this.taskTimeoutMs);
+        pending.timer.unref?.();
+      }
+      this.pending.set(id, pending);
+      slot.worker.postMessage({ id, filePath: task.filePath, source: task.source });
+    }
+  }
+
+  private handleMessage(slot: WorkerSlot, msg: WorkerResponse): void {
+    const entry = this.pending.get(msg.id);
+    if (!entry) {
+      return;
+    }
+    if (entry.timer) {
+      clearTimeout(entry.timer);
+    }
+    this.pending.delete(msg.id);
+    slot.busy = false;
+    if (msg.ok && msg.edges) {
+      entry.resolve(msg.edges);
+    } else {
+      const err = new OxcParseError(msg.message ?? 'oxc-worker error');
+      if (msg.name) {
+        err.name = msg.name;
+      }
+      entry.reject(err);
+    }
+    this.drain();
+  }
+
+  /**
+   * On any worker failure: reject all in-flight and queued tasks, dispose the pool so
+   * subsequent parse() calls fail fast and the caller in index.ts falls back to inline
+   * oxcParse. Nulls out the module-level pool reference so getOxcParsePool() returns null.
+   */
+  private handleWorkerFailure(error: Error): void {
+    if (this.disposed) {
+      return;
+    }
+    logger.debug(`oxc-worker failure: ${error.message}`);
+    this.disposed = true;
+
+    for (const [, entry] of this.pending) {
+      if (entry.timer) {
+        clearTimeout(entry.timer);
+      }
+      entry.reject(new OxcParseError(`oxc-worker failure: ${error.message}`, { cause: error }));
+    }
+    this.pending.clear();
+
+    for (const queued of this.queue) {
+      queued.reject(new OxcParseError('oxc parse pool disposed'));
+    }
+    this.queue.length = 0;
+
+    for (const slot of this.workers) {
+      slot.worker.terminate().catch(() => 0);
+    }
+    this.workers.length = 0;
+
+    // Null out the module-level pool so getOxcParsePool() returns null and callers
+    // fall through to inline oxcParse.
+    sharedPool = null;
+  }
+
+  async dispose(): Promise<void> {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+
+    for (const [, entry] of this.pending) {
+      if (entry.timer) {
+        clearTimeout(entry.timer);
+      }
+      entry.reject(new OxcParseError('oxc parse pool disposed'));
+    }
+    this.pending.clear();
+
+    for (const queued of this.queue) {
+      queued.reject(new OxcParseError('oxc parse pool disposed'));
+    }
+    this.queue.length = 0;
+
+    // Reject callers BEFORE awaiting terminate() so they are never held hostage by a
+    // hung worker thread — terminate() may stall if the OS is unresponsive.
+    const terminations = this.workers.map((s) => s.worker.terminate().catch(() => 0));
+    this.workers.length = 0;
+    await Promise.all(terminations);
+  }
+}
+
+let sharedPool: OxcParsePool | null = null;
+
+function ensurePool(): void {
+  if (sharedPool) {
+    return;
+  }
+  const scriptPath = resolveWorkerScriptPath();
+  if (!scriptPath) {
+    logger.debug(
+      'oxc worker pool disabled: compiled worker script not found (running from source?)'
+    );
+    return;
+  }
+  try {
+    sharedPool = new OxcWorkerPool(scriptPath, computePoolSize());
+  } catch (error) {
+    logger.debug(
+      `oxc worker pool disabled: failed to spawn (${error instanceof Error ? error.message : String(error)})`
+    );
+    sharedPool = null;
+  }
+}
+
+/**
+ * Returns the shared pool, initializing it on first call. Returns null if workers are
+ * disabled or the compiled worker script is unavailable. Callers should fall back to
+ * inline {@link oxcParse} on null.
+ */
+export function getOxcParsePool(): OxcParsePool | null {
+  ensurePool();
+  return sharedPool;
+}
+
+/**
+ * Disposes the shared pool if one is running.
+ */
+export async function disposeOxcParsePool(): Promise<void> {
+  const pool = sharedPool;
+  sharedPool = null;
+  if (pool) {
+    await pool.dispose().catch(() => undefined);
+  }
+}
+
+/** Test-only: force-reset the singleton state between cases. */
+export async function _resetOxcParsePoolForTesting(): Promise<void> {
+  const pool = sharedPool;
+  sharedPool = null;
+  if (pool) {
+    await pool.dispose().catch(() => undefined);
+  }
+}
diff --git a/code/core/src/oxc-parser/worker.ts b/code/core/src/oxc-parser/worker.ts
new file mode 100644
index 000000000000..a3611057f2a5
--- /dev/null
+++ b/code/core/src/oxc-parser/worker.ts
@@ -0,0 +1,46 @@
+/**
+ * Worker-thread entry point that parses a single file with `oxc-parser` and returns its
+ * import edges. The worker is spawned by {@link ./worker-pool.ts} and delegates to the
+ * same {@link oxcParse} implementation used on the main thread — the only difference is
+ * that the CPU work runs off the event loop so dev-server traffic stays responsive.
+ */
+import { parentPort } from 'node:worker_threads';
+
+import { oxcParse } from './parse.ts';
+
+if (!parentPort) {
+  throw new Error('oxc-parser worker must be run as a worker thread');
+}
+
+interface RequestMessage {
+  id: number;
+  filePath: string;
+  source: string;
+}
+
+interface ResponseMessage {
+  id: number;
+  ok: boolean;
+  edges?: unknown;
+  message?: string;
+  name?: string;
+}
+
+const port = parentPort;
+
+port.on('message', async (msg: RequestMessage) => {
+  try {
+    const edges = await oxcParse(msg.filePath, msg.source);
+    const response: ResponseMessage = { id: msg.id, ok: true, edges };
+    port.postMessage(response);
+  } catch (error) {
+    const err = error as { message?: string; name?: string } | undefined;
+    const response: ResponseMessage = {
+      id: msg.id,
+      ok: false,
+      message: err?.message ?? String(error),
+      name: err?.name ?? 'Error',
+    };
+    port.postMessage(response);
+  }
+});
diff --git a/code/core/src/shared/status-store/index.ts b/code/core/src/shared/status-store/index.ts
index a6c262d95442..1333adee0c7e 100644
--- a/code/core/src/shared/status-store/index.ts
+++ b/code/core/src/shared/status-store/index.ts
@@ -42,6 +42,18 @@ export const statusValueShortName = (value: StatusValue): string => {
   return value.slice(STATUS_VALUE_PREFIX.length);
 };
 
+export const statusValueDescription = (value: StatusValue): string =>
+  ({
+    'status-value:pending': 'Stories with pending status',
+    'status-value:success': 'Stories with passing tests',
+    'status-value:new': 'Newly added stories',
+    'status-value:modified': 'Stories closely linked to code changes',
+    'status-value:affected': 'Stories likely to be affected by code changes',
+    'status-value:warning': 'Stories with warnings',
+    'status-value:error': 'Stories with failing tests',
+    'status-value:unknown': 'Stories with unknown status',
+  })[value];
+
 export type StatusTypeId = string;
 export type StatusByTypeId = Record<StatusTypeId, Status>;
 export type StatusesByStoryIdAndTypeId = Record<StoryId, StatusByTypeId>;
diff --git a/code/core/src/shared/utils/story-index-filters.ts b/code/core/src/shared/utils/story-index-filters.ts
new file mode 100644
index 000000000000..0c2476bb9fb1
--- /dev/null
+++ b/code/core/src/shared/utils/story-index-filters.ts
@@ -0,0 +1,20 @@
+interface ActiveFiltersInput {
+  includedTagFilters?: readonly unknown[];
+  excludedTagFilters?: readonly unknown[];
+  includedStatusFilters?: readonly unknown[];
+  excludedStatusFilters?: readonly unknown[];
+}
+
+export const getActiveFilterCount = ({
+  includedTagFilters,
+  excludedTagFilters,
+  includedStatusFilters,
+  excludedStatusFilters,
+}: ActiveFiltersInput): number =>
+  (includedTagFilters?.length ?? 0) +
+  (excludedTagFilters?.length ?? 0) +
+  (includedStatusFilters?.length ?? 0) +
+  (excludedStatusFilters?.length ?? 0);
+
+export const hasActiveFilters = (filters: ActiveFiltersInput): boolean =>
+  getActiveFilterCount(filters) > 0;
diff --git a/code/core/src/types/modules/core-common.ts b/code/core/src/types/modules/core-common.ts
index f1ed67e754f9..0a24d06dd756 100644
--- a/code/core/src/types/modules/core-common.ts
+++ b/code/core/src/types/modules/core-common.ts
@@ -158,6 +158,29 @@ export interface BuilderResult {
   stats?: Stats;
 }
 
+/**
+ * Builder-supplied module resolution config consumed by Storybook's change-detection
+ * dependency graph (and any future module-resolver consumer in core).
+ *
+ * Shape mirrors a subset of Vite's `resolve.*` options and is intentionally
+ * builder-agnostic — webpack/rspack adapters surface the same fields.
+ */
+export interface ModuleResolveConfig {
+  /** Project root (where Storybook is started from). */
+  projectRoot: string;
+  /**
+   * Builder-supplied alias map. Accepts both Vite shapes:
+   *   - `Record<string, string>` (object form)
+   *   - `Array<{ find: string | RegExp; replacement: string }>` (array form, supports regex)
+   *
+   * Callers may treat unresolvable specifiers (including unsupported regex aliases) as
+   * terminal.
+   */
+  alias?: Record<string, string> | Array<{ find: string | RegExp; replacement: string }>;
+  /** Conditions for package `exports` resolution. */
+  conditions?: string[];
+}
+
 export type PackageJson = PackageJsonFromTypeFest & Record<string, any>;
 
 // TODO: This could be exported to the outside world and used in `options.ts` file of each `@storybook/APP`
@@ -276,26 +299,11 @@ export interface Builder<Config, BuilderStats extends Stats = Stats> {
   bail: (e?: Error) => Promise<void>;
   corePresets?: string[];
   overridePresets?: string[];
-  onModuleGraphChange?(cb: (event: ModuleGraphChangeEvent) => void): () => void;
-}
-
-/**
- * Builder-agnostic module graph for dependency tracking. Modeled after Vite's module graph.
- * The same file can be imported in multiple ways (e.g. based on query params or import context),
- * each representing a unique module identity, hence the value is a Set<ModuleNode>.
- */
-export type ModuleGraph = Map<ModuleNode['file'], Set<ModuleNode>>;
-
-export type ModuleGraphChangeEvent =
-  | { type: 'moduleGraph'; moduleGraph: ModuleGraph }
-  | { type: 'unavailable'; reason: string; error?: Error }
-  | { type: 'error'; error: Error };
-
-export interface ModuleNode {
-  file: string;
-  type: 'js' | 'css' | 'asset';
-  importers: Set<ModuleNode>;
-  importedModules: Set<ModuleNode>;
+  /**
+   * Returns a change-detection adapter the core change-detection service uses to (a) read
+   * builder resolve config (alias, root, conditions), and (b) subscribe to file-system events.
+   */
+  changeDetectionAdapter?(): import('../../core-server/change-detection/adapters/types.ts').ChangeDetectionAdapter;
 }
 
 /** Options for TypeScript usage within Storybook. */
@@ -594,6 +602,27 @@ export interface StorybookConfigRaw {
 
   experimental_indexers?: Indexer[];
 
+  /**
+   * Register parsers that extract import edges from non-JS/TS files (e.g. .vue, .svelte).
+   * Each parser claims one or more file extensions. Last registration wins on collision.
+   * Lazy-load heavy SFC compilers inside the parser body — the function is awaited on first
+   * use.
+   *
+   * Used by Storybook's change-detection dependency graph. May be reused by other consumers
+   * in the future (static build, dependency analysis CLIs).
+   *
+   * @experimental Subject to change before stable release.
+   */
+  experimental_importParsers?:
+    | import('../../core-server/change-detection/parser-registry/types.ts').ImportParser[]
+    | ((
+        existing: import('../../core-server/change-detection/parser-registry/types.ts').ImportParser[]
+      ) =>
+        | import('../../core-server/change-detection/parser-registry/types.ts').ImportParser[]
+        | Promise<
+            import('../../core-server/change-detection/parser-registry/types.ts').ImportParser[]
+          >);
+
   storyIndexGenerator?: StoryIndexGenerator;
 
   experimental_devServer?: ServerApp;
diff --git a/code/core/vitest.config.ts b/code/core/vitest.config.ts
index 93492167e8c8..31f6693b6e58 100644
--- a/code/core/vitest.config.ts
+++ b/code/core/vitest.config.ts
@@ -5,11 +5,30 @@ import { vitestCommonConfig } from '../vitest.shared.ts';
 export default mergeConfig(
   vitestCommonConfig,
   defineConfig({
+    // oxc-parser / oxc-resolver ship `browser` entry points that import WASM bindings which
+    // are not installed in this monorepo. Force Vite/Vitest to resolve them via their Node
+    // entry points (index.js) during tests and benchmarks.
+    resolve: {
+      conditions: ['node'],
+      mainFields: ['main'],
+    },
+    ssr: {
+      external: ['oxc-parser', 'oxc-resolver'],
+    },
     test: {
+      name: 'core',
       typecheck: {
         enabled: true,
         ignoreSourceErrors: true,
       },
+      server: {
+        deps: {
+          external: ['oxc-parser', 'oxc-resolver'],
+        },
+      },
+      benchmark: {
+        include: ['**/*.bench.ts'],
+      },
     },
   })
 );
diff --git a/code/e2e-tests/change-detection.spec.ts b/code/e2e-tests/change-detection.spec.ts
new file mode 100644
index 000000000000..a2c80154ce62
--- /dev/null
+++ b/code/e2e-tests/change-detection.spec.ts
@@ -0,0 +1,189 @@
+import { expect, test } from '@playwright/test';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { SbPage } from './util.ts';
+
+/**
+ * Change Detection E2E tests.
+ *
+ * Prerequisites:
+ *   1. STORYBOOK_URL — URL of a running Storybook dev server
+ *   2. STORYBOOK_SANDBOX_DIR — path to the sandbox root
+ *      (e.g. ../storybook-sandboxes/react-vite-default-ts)
+ *   3. The sandbox's .storybook/main.ts must have: features: { changeDetection: true }
+ *   4. STORYBOOK_TEMPLATE_NAME must be one of the supported templates (or be unset for local runs)
+ *   5. The sandbox must already have a git repo with an initial commit — this is handled
+ *      automatically by the sandbox generation task (scripts/tasks/sandbox.ts).
+ *
+ * Supported templates: react-vite/default-ts, nextjs-vite/default-ts,
+ *                      react-webpack/default-ts, nextjs/default-ts
+ */
+
+const storybookUrl = process.env.STORYBOOK_URL || 'http://localhost:8001';
+const sandboxDir = process.env.STORYBOOK_SANDBOX_DIR || '';
+const type = process.env.STORYBOOK_TYPE || 'dev';
+const templateName = process.env.STORYBOOK_TEMPLATE_NAME || '';
+
+const CHANGE_DETECTION_TIMEOUT = 15_000;
+
+// Resolve paths eagerly so test.skip() calls need no if-conditionals inside tests.
+const headerStoriesPath =
+  sandboxDir &&
+  ([
+    path.join(sandboxDir, 'src/stories/Header.stories.ts'),
+    path.join(sandboxDir, 'src/stories/Header.stories.tsx'),
+    path.join(sandboxDir, 'src/stories/Header.stories.svelte'),
+  ].find((p) => fs.existsSync(p)) ??
+    null);
+
+const buttonComponentPath =
+  sandboxDir &&
+  ([
+    path.join(sandboxDir, 'src/stories/Button.tsx'),
+    path.join(sandboxDir, 'src/stories/Button.svelte'),
+    path.join(sandboxDir, 'src/stories/Button.vue'),
+  ].find((p) => fs.existsSync(p)) ??
+    null);
+
+test.describe('Change Detection', () => {
+  test.skip(!sandboxDir, 'Set STORYBOOK_SANDBOX_DIR to run change detection tests');
+  test.skip(type !== 'dev', 'Change detection only runs in dev mode');
+  const SUPPORTED_TEMPLATES = [
+    'react-vite/default-ts',
+    'nextjs-vite/default-ts',
+    'react-webpack/default-ts',
+    'nextjs/default-ts',
+    'svelte-vite/default-ts',
+    'vue3-vite/default-ts',
+  ];
+  test.skip(
+    !!templateName && !SUPPORTED_TEMPLATES.includes(templateName),
+    `Change detection E2E tests only run for: ${SUPPORTED_TEMPLATES.join(', ')}`
+  );
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto(`${storybookUrl}/?path=/story/example-button--primary`);
+    await new SbPage(page, expect).waitUntilLoaded();
+  });
+
+  test('shows "new" status for an untracked story file (Svelte)', async ({ page }) => {
+    test.skip(
+      templateName !== 'svelte-vite/default-ts',
+      'This test is only relevant for Svelte, which supports untracked files in the sandbox setup'
+    );
+    const newStoryPath = path.join(sandboxDir, 'src/stories/ChangeDetectionNew.stories.svelte');
+
+    console.log({ newStoryPath });
+
+    try {
+      fs.writeFileSync(
+        newStoryPath,
+        [
+          '<script module>',
+          "  import { defineMeta } from '@storybook/addon-svelte-csf';",
+          "  import Button from './Button.svelte';",
+          "  import { fn } from 'storybook/test';",
+          '',
+          '  const { Story } = defineMeta({',
+          "    title: 'Example/ChangeDetectionNew',",
+          '    component: Button,',
+          "    tags: ['autodocs'],",
+          '    argTypes: {',
+          "      backgroundColor: { control: 'color' },",
+          '      size: {',
+          "        control: { type: 'select' },",
+          "        options: ['small', 'medium', 'large'],",
+          '      },',
+          '    },',
+          '    args: {',
+          '      onclick: fn(),',
+          '    },',
+          '  });',
+          '</script>',
+          '',
+          '<Story name="Primary" args={{ primary: true, label: \'Button\' }} />',
+          '',
+          '<Story name="Secondary" args={{ label: \'Button\' }} />',
+        ].join('\n')
+      );
+
+      // New stories roll up to "Change status: New" on the parent component node
+      await expect(page.locator('[aria-label="Change status: New"]').first()).toBeVisible({
+        timeout: CHANGE_DETECTION_TIMEOUT,
+      });
+    } finally {
+      fs.rmSync(newStoryPath, { force: true });
+    }
+  });
+
+  test('shows "new" status for an untracked story file (TypeScript)', async ({ page }) => {
+    test.skip(
+      templateName === 'svelte-vite/default-ts',
+      'This test only works for TypeScript-based templates because it relies on creating a new .stories.ts file'
+    );
+    const newStoryPath = path.join(sandboxDir, 'src/stories/ChangeDetectionNew.stories.ts');
+
+    console.log({ newStoryPath });
+
+    try {
+      fs.writeFileSync(
+        newStoryPath,
+        [
+          "const meta = { title: 'Example/ChangeDetectionNew' }",
+          'export default meta;',
+          '',
+          'export const Default = {};',
+        ].join('\n')
+      );
+
+      // New stories roll up to "Change status: New" on the parent component node
+      await expect(page.locator('[aria-label="Change status: New"]').first()).toBeVisible({
+        timeout: CHANGE_DETECTION_TIMEOUT,
+      });
+    } finally {
+      fs.rmSync(newStoryPath, { force: true });
+    }
+  });
+
+  test('shows "modified" status for a changed story file', async ({ page }) => {
+    test.skip(!headerStoriesPath, 'Header.stories file not found in STORYBOOK_SANDBOX_DIR');
+
+    const storyPath = headerStoriesPath as string;
+    const original = fs.readFileSync(storyPath, 'utf-8');
+
+    console.log({ storyPath });
+
+    try {
+      fs.writeFileSync(storyPath, `${original}\n// change-detection-e2e-modified`);
+
+      await expect(
+        page.locator('[data-item-id="example-header"] [aria-label="Change status: Modified"]')
+      ).toBeVisible({ timeout: CHANGE_DETECTION_TIMEOUT });
+    } finally {
+      fs.writeFileSync(storyPath, original);
+    }
+  });
+
+  test('shows "related" status for stories whose dependency changed', async ({ page }) => {
+    test.skip(!buttonComponentPath, 'Button component not found in STORYBOOK_SANDBOX_DIR');
+
+    const componentPath = buttonComponentPath as string;
+    const original = fs.readFileSync(componentPath, 'utf-8');
+    // eslint-disable-next-line playwright/no-conditional-in-test
+    const comment = componentPath.endsWith('.svelte')
+      ? '\n<!-- change-detection-e2e-affected -->'
+      : '\n// change-detection-e2e-affected';
+
+    try {
+      fs.writeFileSync(componentPath, `${original}${comment}`);
+
+      // Header.stories is depth-2 from Button.tsx (via Header.tsx); depth-1 Button.stories gets "Modified"
+      await expect(
+        page.locator('[data-item-id="example-header"] [aria-label="Change status: Affected"]')
+      ).toBeVisible({ timeout: CHANGE_DETECTION_TIMEOUT });
+    } finally {
+      fs.writeFileSync(componentPath, original);
+    }
+  });
+});
diff --git a/code/lib/cli-storybook/src/sandbox-templates.ts b/code/lib/cli-storybook/src/sandbox-templates.ts
index c169252cf1da..dae8d4e5e079 100644
--- a/code/lib/cli-storybook/src/sandbox-templates.ts
+++ b/code/lib/cli-storybook/src/sandbox-templates.ts
@@ -246,6 +246,7 @@ export const baseTemplates = {
           experimentalRSC: true,
           developmentModeForBuild: true,
           experimentalTestSyntax: true,
+          changeDetection: true,
         },
       },
       extraDependencies: ['server-only', 'prop-types'],
@@ -343,6 +344,7 @@ export const baseTemplates = {
           experimentalRSC: true,
           developmentModeForBuild: true,
           experimentalTestSyntax: true,
+          changeDetection: true,
         },
       },
       extraDependencies: ['server-only', 'vite', 'prop-types'],
@@ -385,6 +387,7 @@ export const baseTemplates = {
         features: {
           developmentModeForBuild: true,
           experimentalTestSyntax: true,
+          changeDetection: true,
         },
       },
     },
diff --git a/code/lib/create-storybook/src/generators/REACT_NATIVE/metroConfig.test.ts b/code/lib/create-storybook/src/generators/REACT_NATIVE/metroConfig.test.ts
index ee91b9c0dac0..5d904e53c84b 100644
--- a/code/lib/create-storybook/src/generators/REACT_NATIVE/metroConfig.test.ts
+++ b/code/lib/create-storybook/src/generators/REACT_NATIVE/metroConfig.test.ts
@@ -2,6 +2,7 @@ import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
+import { format } from 'oxfmt';
 import { logger, prompt } from 'storybook/internal/node-logger';
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -19,6 +20,15 @@ import {
 
 vi.mock('storybook/internal/node-logger', { spy: true });
 
+const getFormattedDiff = async (before: string, after: string, filePath: string) => {
+  const [beforeResult, afterResult] = await Promise.all([
+    format(path.basename(filePath), before, { singleQuote: true }),
+    format(path.basename(filePath), after, { singleQuote: true }),
+  ]);
+
+  return getDiff(beforeResult.code, afterResult.code);
+};
+
 describe('metroConfig codemod', () => {
   let tempDir: string;
   let originalCwd: string;
@@ -56,10 +66,8 @@ describe('metroConfig codemod', () => {
 
     expect(result.status).toBe('updated');
     expect(after).not.toBe(before);
-    expect(getDiff(before, after)).toMatchInlineSnapshot(`
-      "+ const {
-      +   withStorybook,
-      + } = require('@storybook/react-native/withStorybook');
+    expect(await getFormattedDiff(before, after, filePath)).toMatchInlineSnapshot(`
+      "+ const { withStorybook } = require('@storybook/react-native/withStorybook');
       + 
       + 
         const defaultConfig = {};
@@ -84,32 +92,29 @@ describe('metroConfig codemod', () => {
 
     expect(result.status).toBe('updated');
     expect(after).not.toBe(before);
-    expect(getDiff(before, after)).toMatchInlineSnapshot(`
+    expect(await getFormattedDiff(before, after, filePath)).toMatchInlineSnapshot(`
       "- module.exports = withExpo(defaultConfig);
       - 
-      + const {
-      +   withStorybook,
-      + } = require('@storybook/react-native/withStorybook');
+      + const { withStorybook } = require('@storybook/react-native/withStorybook');
       + 
       + module.exports = withStorybook(withExpo(defaultConfig));
       + "
     `);
   });
 
-  it('wraps export default async function in ts config with ESM import', () => {
+  it('wraps export default async function in ts config with ESM import', async () => {
+    const filePath = path.join(tempDir, 'metro.config.ts');
     const before = `
 export default async function makeMetroConfig() {
   return { resolver: {} };
 }
 `;
-    const transformed = transformMetroConfigSource(before, path.join(tempDir, 'metro.config.ts'));
+    const transformed = transformMetroConfigSource(before, filePath);
 
     expect(transformed.action).toBe('updated');
     if (transformed.action === 'updated') {
-      expect(getDiff(before, transformed.code)).toMatchInlineSnapshot(`
-        "  
-          
-        - export default async function makeMetroConfig() {
+      expect(await getFormattedDiff(before, transformed.code, filePath)).toMatchInlineSnapshot(`
+        "- export default async function makeMetroConfig() {
         - 
         + import { withStorybook } from '@storybook/react-native/withStorybook';
         + export default withStorybook(async function makeMetroConfig() {
@@ -195,7 +200,8 @@ module.exports = config;
     }
   });
 
-  it('does not treat import/export text inside template literals as ESM for .ts import injection', () => {
+  it('does not treat import/export text inside template literals as ESM for .ts import injection', async () => {
+    const filePath = path.join(tempDir, 'metro.config.ts');
     const before = `
 const hint = \`
 import { something } from 'somewhere'
@@ -203,16 +209,12 @@ export default {}
 \`;
 module.exports = {};
 `;
-    const transformed = transformMetroConfigSource(before, path.join(tempDir, 'metro.config.ts'));
+    const transformed = transformMetroConfigSource(before, filePath);
 
     expect(transformed.action).toBe('updated');
     if (transformed.action === 'updated') {
-      expect(getDiff(before, transformed.code)).toMatchInlineSnapshot(`
-        "  
-          
-        + const {
-        +   withStorybook,
-        + } = require('@storybook/react-native/withStorybook');
+      expect(await getFormattedDiff(before, transformed.code, filePath)).toMatchInlineSnapshot(`
+        "+ const { withStorybook } = require('@storybook/react-native/withStorybook');
         + 
         + 
           const hint = \`
@@ -228,7 +230,8 @@ module.exports = {};
     }
   });
 
-  it('preserves TypeScript return type and type parameters on default exported functions', () => {
+  it('preserves TypeScript return type and type parameters on default exported functions', async () => {
+    const filePath = path.join(tempDir, 'metro.config.ts');
     const before = `
 import type { MetroConfig } from 'metro-config';
 
@@ -236,13 +239,12 @@ export default async function makeMetroConfig<T = string>(): Promise<MetroConfig
   return {} as MetroConfig;
 }
 `;
-    const transformed = transformMetroConfigSource(before, path.join(tempDir, 'metro.config.ts'));
+    const transformed = transformMetroConfigSource(before, filePath);
 
     expect(transformed.action).toBe('updated');
     if (transformed.action === 'updated') {
-      expect(getDiff(before, transformed.code)).toMatchInlineSnapshot(`
-        "  
-          import type { MetroConfig } from 'metro-config';
+      expect(await getFormattedDiff(before, transformed.code, filePath)).toMatchInlineSnapshot(`
+        "  import type { MetroConfig } from 'metro-config';
           
           
         - export default async function makeMetroConfig<T = string>(): Promise<MetroConfig> {
diff --git a/code/package.json b/code/package.json
index b2931a6253d6..2b6aeaff053b 100644
--- a/code/package.json
+++ b/code/package.json
@@ -196,5 +196,6 @@
         "Dependency Upgrades"
       ]
     ]
-  }
+  },
+  "deferredNextVersion": "10.4.0-alpha.17"
 }
diff --git a/code/renderers/svelte/src/parsers/index.ts b/code/renderers/svelte/src/parsers/index.ts
new file mode 100644
index 000000000000..e6d9f24d9330
--- /dev/null
+++ b/code/renderers/svelte/src/parsers/index.ts
@@ -0,0 +1 @@
+export { svelteImportParser } from './svelteImportParser.ts';
diff --git a/code/renderers/svelte/src/parsers/svelteImportParser.test.ts b/code/renderers/svelte/src/parsers/svelteImportParser.test.ts
new file mode 100644
index 000000000000..da913c7d257d
--- /dev/null
+++ b/code/renderers/svelte/src/parsers/svelteImportParser.test.ts
@@ -0,0 +1,248 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { ImportEdge, ImportParserContext } from 'storybook/internal/core-server';
+import { ChangeDetectionFailureError } from 'storybook/internal/core-server';
+
+import { svelteImportParser } from './svelteImportParser.ts';
+
+function makeContext(behavior: (source: string, virtualFilePath: string) => ImportEdge[]): {
+  ctx: ImportParserContext;
+  calls: { source: string; virtualFilePath: string }[];
+} {
+  const calls: { source: string; virtualFilePath: string }[] = [];
+  const ctx: ImportParserContext = {
+    parseScriptWithOxc: vi.fn(async (source: string, virtualFilePath: string) => {
+      calls.push({ source, virtualFilePath });
+      return behavior(source, virtualFilePath);
+    }),
+  };
+  return { ctx, calls };
+}
+
+describe('svelteImportParser', () => {
+  it('claims the `.svelte` extension', () => {
+    expect(svelteImportParser.extensions).toEqual(['.svelte']);
+  });
+
+  it('does NOT claim `.svelte.ts` / `.svelte.js` rune files (ParserRegistry routes those to oxc by last extension segment)', () => {
+    // `path.extname('/tmp/Rune.svelte.ts')` returns `.ts`, so rune files fall through
+    // to the built-in oxc parser. This assertion documents that contract: we must not
+    // register `.svelte.ts` / `.svelte.js` here.
+    expect(svelteImportParser.extensions).not.toContain('.svelte.ts');
+    expect(svelteImportParser.extensions).not.toContain('.svelte.js');
+  });
+
+  it('extracts imports from a regular <script> block', async () => {
+    const source = [
+      `<script>`,
+      `  import Button from './Button.svelte';`,
+      `  import { onMount } from 'svelte';`,
+      `</script>`,
+      ``,
+      `<div>hello</div>`,
+    ].join('\n');
+
+    const { ctx, calls } = makeContext((src) => {
+      if (src.includes(`from './Button.svelte'`)) {
+        return [
+          { specifier: './Button.svelte', kind: 'static' },
+          { specifier: 'svelte', kind: 'static' },
+        ];
+      }
+      return [];
+    });
+
+    const edges = await svelteImportParser.parse({ filePath: '/tmp/Foo.svelte', source }, ctx);
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.virtualFilePath).toBe('/tmp/Foo.svelte.script.js');
+    expect(calls[0]?.source).toContain(`import Button from './Button.svelte';`);
+    expect(calls[0]?.source).toContain(`import { onMount } from 'svelte';`);
+    expect(calls[0]?.source).not.toContain('<div>');
+    expect(edges).toEqual([
+      { specifier: './Button.svelte', kind: 'static' },
+      { specifier: 'svelte', kind: 'static' },
+    ]);
+  });
+
+  it('extracts imports from a <script module> block', async () => {
+    const source = [
+      `<script module>`,
+      `  import { store } from './store.ts';`,
+      `</script>`,
+      ``,
+      `<p>body</p>`,
+    ].join('\n');
+
+    const { ctx, calls } = makeContext((src) => {
+      if (src.includes(`from './store.ts'`)) {
+        return [{ specifier: './store.ts', kind: 'static' }];
+      }
+      return [];
+    });
+
+    const edges = await svelteImportParser.parse({ filePath: '/tmp/Bar.svelte', source }, ctx);
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.virtualFilePath).toBe('/tmp/Bar.svelte.script.js');
+    expect(calls[0]?.source).toContain(`import { store } from './store.ts';`);
+    expect(edges).toEqual([{ specifier: './store.ts', kind: 'static' }]);
+  });
+
+  it('extracts imports from BOTH instance and module scripts and dedupes', async () => {
+    const source = [
+      `<script module>`,
+      `  import { shared } from './shared.ts';`,
+      `  import Button from './Button.svelte';`,
+      `</script>`,
+      ``,
+      `<script>`,
+      `  import { onMount } from 'svelte';`,
+      `  import Button from './Button.svelte';`,
+      `</script>`,
+      ``,
+      `<div />`,
+    ].join('\n');
+
+    const { ctx, calls } = makeContext((src) => {
+      if (src.includes(`from './shared.ts'`)) {
+        return [
+          { specifier: './shared.ts', kind: 'static' },
+          { specifier: './Button.svelte', kind: 'static' },
+        ];
+      }
+      return [
+        { specifier: 'svelte', kind: 'static' },
+        { specifier: './Button.svelte', kind: 'static' },
+      ];
+    });
+
+    const edges = await svelteImportParser.parse({ filePath: '/tmp/Baz.svelte', source }, ctx);
+
+    expect(calls).toHaveLength(2);
+    expect(edges).toEqual([
+      { specifier: './shared.ts', kind: 'static' },
+      { specifier: './Button.svelte', kind: 'static' },
+      { specifier: 'svelte', kind: 'static' },
+    ]);
+  });
+
+  it('returns [] for a Svelte file with only markup and styles', async () => {
+    const source = [
+      `<div class="card">`,
+      `  <p>No scripts here.</p>`,
+      `</div>`,
+      ``,
+      `<style>`,
+      `  .card { color: red; }`,
+      `</style>`,
+    ].join('\n');
+
+    const { ctx, calls } = makeContext(() => []);
+
+    const edges = await svelteImportParser.parse({ filePath: '/tmp/Empty.svelte', source }, ctx);
+
+    expect(calls).toHaveLength(0);
+    expect(edges).toEqual([]);
+  });
+
+  it('forwards type-only import filtering to parseScriptWithOxc (no special-casing)', async () => {
+    // svelteImportParser does not know about type-only imports — that's oxc's job. We
+    // assert here that the parser hands the script verbatim to parseScriptWithOxc and
+    // returns exactly what oxc reports, so type-only filtering is preserved end to end.
+    const source = [
+      `<script lang="ts">`,
+      `  import type { Writable } from 'svelte/store';`,
+      `  import { writable } from 'svelte/store';`,
+      `</script>`,
+    ].join('\n');
+
+    const { ctx, calls } = makeContext(() => [{ specifier: 'svelte/store', kind: 'static' }]);
+
+    const edges = await svelteImportParser.parse({ filePath: '/tmp/Typed.svelte', source }, ctx);
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.source).toContain(`import type { Writable } from 'svelte/store';`);
+    expect(calls[0]?.source).toContain(`import { writable } from 'svelte/store';`);
+    expect(edges).toEqual([{ specifier: 'svelte/store', kind: 'static' }]);
+  });
+
+  it('parses a .stories.svelte (Svelte CSF) file the same way', async () => {
+    const source = [
+      `<script module>`,
+      `  import { defineMeta } from '@storybook/addon-svelte-csf';`,
+      `  import Button from './Button.svelte';`,
+      ``,
+      `  const { Story } = defineMeta({ component: Button });`,
+      `</script>`,
+      ``,
+      `<Story name="Primary" args={{}} />`,
+    ].join('\n');
+
+    const { ctx } = makeContext(() => [
+      { specifier: '@storybook/addon-svelte-csf', kind: 'static' },
+      { specifier: './Button.svelte', kind: 'static' },
+    ]);
+
+    const edges = await svelteImportParser.parse(
+      { filePath: '/tmp/Button.stories.svelte', source },
+      ctx
+    );
+
+    expect(edges).toEqual([
+      { specifier: '@storybook/addon-svelte-csf', kind: 'static' },
+      { specifier: './Button.svelte', kind: 'static' },
+    ]);
+  });
+
+  it('surfaces a malformed .svelte source as ChangeDetectionFailureError', async () => {
+    // Unclosed tag + bad expression — should cause svelte/compiler to throw.
+    const source = `<script>\n  import x from 'y\n</script`;
+
+    const { ctx } = makeContext(() => []);
+
+    await expect(
+      svelteImportParser.parse({ filePath: '/tmp/Broken.svelte', source }, ctx)
+    ).rejects.toBeInstanceOf(ChangeDetectionFailureError);
+  });
+
+  it('uses .script.js virtual extension when no lang attribute is set', async () => {
+    const source = [`<script>`, `  import x from './x.js';`, `</script>`].join('\n');
+
+    const { ctx, calls } = makeContext(() => [{ specifier: './x.js', kind: 'static' }]);
+
+    await svelteImportParser.parse({ filePath: '/tmp/NoLang.svelte', source }, ctx);
+
+    expect(calls[0]?.virtualFilePath).toBe('/tmp/NoLang.svelte.script.js');
+  });
+
+  it('uses .script.ts virtual extension when lang="ts"', async () => {
+    const source = [`<script lang="ts">`, `  import x from './x.ts';`, `</script>`].join('\n');
+
+    const { ctx, calls } = makeContext(() => [{ specifier: './x.ts', kind: 'static' }]);
+
+    await svelteImportParser.parse({ filePath: '/tmp/TypeScript.svelte', source }, ctx);
+
+    expect(calls[0]?.virtualFilePath).toBe('/tmp/TypeScript.svelte.script.ts');
+  });
+
+  it('uses .script.tsx virtual extension when lang="tsx"', async () => {
+    const source = [`<script lang="tsx">`, `  import x from './x.tsx';`, `</script>`].join('\n');
+
+    const { ctx, calls } = makeContext(() => [{ specifier: './x.tsx', kind: 'static' }]);
+
+    await svelteImportParser.parse({ filePath: '/tmp/TSX.svelte', source }, ctx);
+
+    expect(calls[0]?.virtualFilePath).toBe('/tmp/TSX.svelte.script.tsx');
+  });
+
+  it('uses .script.jsx virtual extension when lang="jsx"', async () => {
+    const source = [`<script lang="jsx">`, `  import x from './x.jsx';`, `</script>`].join('\n');
+
+    const { ctx, calls } = makeContext(() => [{ specifier: './x.jsx', kind: 'static' }]);
+
+    await svelteImportParser.parse({ filePath: '/tmp/JSX.svelte', source }, ctx);
+
+    expect(calls[0]?.virtualFilePath).toBe('/tmp/JSX.svelte.script.jsx');
+  });
+});
diff --git a/code/renderers/svelte/src/parsers/svelteImportParser.ts b/code/renderers/svelte/src/parsers/svelteImportParser.ts
new file mode 100644
index 000000000000..165a914ce157
--- /dev/null
+++ b/code/renderers/svelte/src/parsers/svelteImportParser.ts
@@ -0,0 +1,178 @@
+import {
+  ChangeDetectionFailureError,
+  type ImportEdge,
+  type ImportParser,
+} from 'storybook/internal/core-server';
+
+type SvelteCompiler = typeof import('svelte/compiler');
+
+let svelteCompilerPromise: Promise<SvelteCompiler> | undefined;
+
+async function getSvelteCompiler(): Promise<SvelteCompiler> {
+  if (!svelteCompilerPromise) {
+    svelteCompilerPromise = import('svelte/compiler').catch((error: unknown) => {
+      svelteCompilerPromise = undefined;
+      throw new ChangeDetectionFailureError(
+        `Failed to load 'svelte/compiler'; is 'svelte' installed? Original error: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+        error instanceof Error ? { cause: error } : undefined
+      );
+    });
+  }
+  return svelteCompilerPromise;
+}
+
+interface MaybeProgramRange {
+  start?: number;
+  end?: number;
+}
+
+/** Loose shape of a single attribute node from the Svelte AST (`Attribute[]` on `Script`). */
+interface MaybeAstAttribute {
+  name?: unknown;
+  /** `true` for boolean attrs; array of text/expression nodes for string attrs. */
+  value?: unknown;
+}
+
+interface MaybeScript {
+  content?: MaybeProgramRange | null;
+  /** Svelte AST `Script.attributes` — an array of `Attribute` nodes. */
+  attributes?: MaybeAstAttribute[] | null;
+}
+
+interface MaybeSvelteRoot {
+  instance?: MaybeScript | null;
+  module?: MaybeScript | null;
+}
+
+/**
+ * Reads the `lang` attribute from a Svelte AST `Script.attributes` array.
+ * Each attribute is `{ name, value }` where value is `true` (boolean attr) or an array
+ * of text/expression nodes — `[{ data: "ts" }]` for `lang="ts"`.
+ */
+function readLangFromAttributes(
+  attributes: MaybeAstAttribute[] | null | undefined
+): string | undefined {
+  if (!Array.isArray(attributes)) {
+    return undefined;
+  }
+  for (const attr of attributes) {
+    if (attr.name !== 'lang') {
+      continue;
+    }
+    // Boolean attribute (`lang` without value) — no practical meaning, skip.
+    if (attr.value === true) {
+      return undefined;
+    }
+    // String attribute: value is an array of text/expression nodes.
+    if (Array.isArray(attr.value) && attr.value.length > 0) {
+      const first = attr.value[0] as { data?: unknown } | undefined;
+      if (typeof first?.data === 'string') {
+        return first.data;
+      }
+    }
+    return undefined;
+  }
+  return undefined;
+}
+
+function extractScriptSource(
+  source: string,
+  script: MaybeScript | null | undefined
+): { scriptSource: string; lang: string | undefined } | undefined {
+  const range = script?.content;
+  if (!range || typeof range.start !== 'number' || typeof range.end !== 'number') {
+    return undefined;
+  }
+  if (range.start < 0 || range.end > source.length || range.end <= range.start) {
+    return undefined;
+  }
+  const lang = readLangFromAttributes(script?.attributes);
+  return { scriptSource: source.slice(range.start, range.end), lang };
+}
+
+/**
+ * Maps the `lang` attribute of a `<script>` block to a virtual file extension so oxc
+ * parses the extracted script in the right mode (TS superset vs plain JS, with/without JSX).
+ */
+function virtualExtensionForLang(lang: string | undefined): 'ts' | 'tsx' | 'jsx' | 'js' {
+  switch (lang) {
+    case 'ts':
+      return 'ts';
+    case 'tsx':
+      return 'tsx';
+    case 'jsx':
+      return 'jsx';
+    default:
+      // No lang or unrecognised value — plain JS is the safe default.
+      return 'js';
+  }
+}
+
+/**
+ * Parser plugin for Svelte single-file components. Delegates the heavy lifting of AST-level
+ * import extraction to the built-in oxc wrapper: we only crack the `.svelte` container,
+ * pull the `<script>` and `<script module>` bodies, and hand each one back to oxc via the
+ * {@link ctx.parseScriptWithOxc} service.
+ *
+ * Intentionally does NOT walk template markup. Storybook's change-detection graph tracks
+ * JS/TS import edges only; template-level component references would require rich AST
+ * handling that is out of scope for change detection today.
+ *
+ * The `svelte/compiler` dep is lazy-loaded so change-detection opt-outs do not pay the
+ * import cost. Svelte is a peer dep of `@storybook/svelte`, so it is always present in
+ * user projects that enable this parser.
+ */
+export const svelteImportParser: ImportParser = {
+  extensions: ['.svelte'],
+  async parse({ filePath, source }, ctx) {
+    const compiler = await getSvelteCompiler();
+
+    let ast: unknown;
+    try {
+      ast = compiler.parse(source, { filename: filePath, modern: true });
+    } catch (error) {
+      throw new ChangeDetectionFailureError(
+        `svelte/compiler failed to parse ${filePath}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+        error instanceof Error ? { cause: error } : undefined
+      );
+    }
+
+    const root = (ast ?? {}) as MaybeSvelteRoot;
+    // Process `<script module>` first so deduplication preserves source/execution order:
+    // module-scoped code initializes before the instance block.
+    const scripts: { scriptSource: string; lang: string | undefined }[] = [];
+    const moduleResult = extractScriptSource(source, root.module);
+    if (moduleResult !== undefined) {
+      scripts.push(moduleResult);
+    }
+    const instanceResult = extractScriptSource(source, root.instance);
+    if (instanceResult !== undefined) {
+      scripts.push(instanceResult);
+    }
+
+    if (scripts.length === 0) {
+      return [];
+    }
+
+    const edges: ImportEdge[] = [];
+    const seen = new Set<string>();
+    for (const { scriptSource, lang } of scripts) {
+      const ext = virtualExtensionForLang(lang);
+      const virtualFilePath = `${filePath}.script.${ext}`;
+      const scriptEdges = await ctx.parseScriptWithOxc(scriptSource, virtualFilePath);
+      for (const edge of scriptEdges) {
+        const key = `${edge.kind}:${edge.specifier}`;
+        if (seen.has(key)) {
+          continue;
+        }
+        seen.add(key);
+        edges.push(edge);
+      }
+    }
+    return edges;
+  },
+};
diff --git a/code/renderers/svelte/src/preset.ts b/code/renderers/svelte/src/preset.ts
index d152fa23307e..6b66f1a09d27 100644
--- a/code/renderers/svelte/src/preset.ts
+++ b/code/renderers/svelte/src/preset.ts
@@ -1,5 +1,6 @@
 import { fileURLToPath } from 'node:url';
 
+import type { ImportParser } from 'storybook/internal/core-server';
 import type { PresetProperty } from 'storybook/internal/types';
 
 export const previewAnnotations: PresetProperty<'previewAnnotations'> = async (
@@ -18,3 +19,10 @@ export const previewAnnotations: PresetProperty<'previewAnnotations'> = async (
         : []
     );
 };
+
+export const experimental_importParsers = async (
+  input: ImportParser[] = []
+): Promise<ImportParser[]> => {
+  const { svelteImportParser } = await import('./parsers/index.ts');
+  return [...input, svelteImportParser];
+};
diff --git a/code/renderers/vue3/src/parsers/index.ts b/code/renderers/vue3/src/parsers/index.ts
new file mode 100644
index 000000000000..d1314ffbab55
--- /dev/null
+++ b/code/renderers/vue3/src/parsers/index.ts
@@ -0,0 +1 @@
+export { vueImportParser } from './vueImportParser.ts';
diff --git a/code/renderers/vue3/src/parsers/vueImportParser.test.ts b/code/renderers/vue3/src/parsers/vueImportParser.test.ts
new file mode 100644
index 000000000000..894bfeabe513
--- /dev/null
+++ b/code/renderers/vue3/src/parsers/vueImportParser.test.ts
@@ -0,0 +1,201 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { ImportEdge, ImportParserContext } from 'storybook/internal/core-server';
+import { ChangeDetectionFailureError } from 'storybook/internal/core-server';
+
+import { vueImportParser } from './vueImportParser.ts';
+
+function makeContext(behavior: (source: string, virtualFilePath: string) => ImportEdge[]): {
+  ctx: ImportParserContext;
+  calls: { source: string; virtualFilePath: string }[];
+} {
+  const calls: { source: string; virtualFilePath: string }[] = [];
+  const ctx: ImportParserContext = {
+    parseScriptWithOxc: vi.fn(async (source: string, virtualFilePath: string) => {
+      calls.push({ source, virtualFilePath });
+      return behavior(source, virtualFilePath);
+    }),
+  };
+  return { ctx, calls };
+}
+
+describe('vueImportParser', () => {
+  it('claims the `.vue` extension', () => {
+    expect(vueImportParser.extensions).toEqual(['.vue']);
+  });
+
+  it('extracts imports from <script lang="ts">', async () => {
+    const source = [
+      `<template>`,
+      `  <div>{{ label }}</div>`,
+      `</template>`,
+      ``,
+      `<script lang="ts">`,
+      `import { defineComponent } from 'vue';`,
+      `import type { PropType } from 'vue';`,
+      ``,
+      `export default defineComponent({`,
+      `  props: { label: { type: String as PropType<string>, required: true } },`,
+      `});`,
+      `</script>`,
+    ].join('\n');
+
+    const { ctx, calls } = makeContext(() => [{ specifier: 'vue', kind: 'static' }]);
+
+    const edges = await vueImportParser.parse({ filePath: '/tmp/Button.vue', source }, ctx);
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.virtualFilePath).toBe('/tmp/Button.vue.script.ts');
+    expect(calls[0]?.source).toContain(`import { defineComponent } from 'vue';`);
+    expect(calls[0]?.source).toContain(`import type { PropType } from 'vue';`);
+    expect(calls[0]?.source).not.toContain('<template>');
+    expect(edges).toEqual([{ specifier: 'vue', kind: 'static' }]);
+  });
+
+  it('extracts imports from <script setup>', async () => {
+    const source = [
+      `<script setup>`,
+      `import Button from './Button.vue';`,
+      `import { ref } from 'vue';`,
+      ``,
+      `const open = ref(false);`,
+      `</script>`,
+      ``,
+      `<template>`,
+      `  <Button @click="open = !open" />`,
+      `</template>`,
+    ].join('\n');
+
+    const { ctx, calls } = makeContext(() => [
+      { specifier: './Button.vue', kind: 'static' },
+      { specifier: 'vue', kind: 'static' },
+    ]);
+
+    const edges = await vueImportParser.parse({ filePath: '/tmp/App.vue', source }, ctx);
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.virtualFilePath).toBe('/tmp/App.vue.script.js');
+    expect(calls[0]?.source).toContain(`import Button from './Button.vue';`);
+    expect(edges).toEqual([
+      { specifier: './Button.vue', kind: 'static' },
+      { specifier: 'vue', kind: 'static' },
+    ]);
+  });
+
+  it('extracts imports from BOTH <script> and <script setup> and dedupes', async () => {
+    const source = [
+      `<script lang="ts">`,
+      `import { defineOptions } from 'vue';`,
+      `import SharedHelper from './shared.ts';`,
+      `export default { name: 'Both' };`,
+      `</script>`,
+      ``,
+      `<script setup lang="ts">`,
+      `import SharedHelper from './shared.ts';`,
+      `import Button from './Button.vue';`,
+      `</script>`,
+      ``,
+      `<template><Button /></template>`,
+    ].join('\n');
+
+    const { ctx, calls } = makeContext((src) => {
+      if (src.includes('defineOptions')) {
+        return [
+          { specifier: 'vue', kind: 'static' },
+          { specifier: './shared.ts', kind: 'static' },
+        ];
+      }
+      return [
+        { specifier: './shared.ts', kind: 'static' },
+        { specifier: './Button.vue', kind: 'static' },
+      ];
+    });
+
+    const edges = await vueImportParser.parse({ filePath: '/tmp/Both.vue', source }, ctx);
+
+    expect(calls).toHaveLength(2);
+    expect(calls[0]?.virtualFilePath).toBe('/tmp/Both.vue.script.ts');
+    expect(calls[1]?.virtualFilePath).toBe('/tmp/Both.vue.script.ts');
+    expect(edges).toEqual([
+      { specifier: 'vue', kind: 'static' },
+      { specifier: './shared.ts', kind: 'static' },
+      { specifier: './Button.vue', kind: 'static' },
+    ]);
+  });
+
+  it('returns [] for a Vue file with only <template> and <style>', async () => {
+    const source = [
+      `<template>`,
+      `  <div class="empty">no scripts here</div>`,
+      `</template>`,
+      ``,
+      `<style scoped>`,
+      `.empty { color: gray; }`,
+      `</style>`,
+    ].join('\n');
+
+    const { ctx, calls } = makeContext(() => []);
+
+    const edges = await vueImportParser.parse({ filePath: '/tmp/Empty.vue', source }, ctx);
+
+    expect(calls).toHaveLength(0);
+    expect(edges).toEqual([]);
+  });
+
+  it('uses .js virtual extension when lang is absent', async () => {
+    const source = [
+      `<script>`,
+      `import { h } from 'vue';`,
+      `export default { render: () => h('div') };`,
+      `</script>`,
+    ].join('\n');
+
+    const { ctx, calls } = makeContext(() => [{ specifier: 'vue', kind: 'static' }]);
+
+    await vueImportParser.parse({ filePath: '/tmp/Plain.vue', source }, ctx);
+
+    expect(calls[0]?.virtualFilePath).toBe('/tmp/Plain.vue.script.js');
+  });
+
+  it('does NOT extract imports from <template> expressions', async () => {
+    // Template imports (via `:is="SomeComponent"` or JSX-like expressions inside the
+    // template) are out of scope. Only <script>/<script setup> should reach the oxc
+    // wrapper — use a unique marker that only appears in the template and assert the
+    // parsed script text never contains it.
+    const source = [
+      `<template>`,
+      `  <component :is="TEMPLATE_ONLY_MARKER" />`,
+      `  <span>some-template-only-literal</span>`,
+      `</template>`,
+      ``,
+      `<script setup lang="ts">`,
+      `import { ref } from 'vue';`,
+      `const x = ref(null);`,
+      `</script>`,
+    ].join('\n');
+
+    const { ctx, calls } = makeContext(() => [{ specifier: 'vue', kind: 'static' }]);
+
+    await vueImportParser.parse({ filePath: '/tmp/TemplateOnly.vue', source }, ctx);
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.source).toContain(`import { ref } from 'vue';`);
+    expect(calls[0]?.source).not.toContain('TEMPLATE_ONLY_MARKER');
+    expect(calls[0]?.source).not.toContain('some-template-only-literal');
+  });
+
+  it('surfaces a malformed .vue source as ChangeDetectionFailureError', async () => {
+    // Unclosed <script> tag should produce a compiler error that we wrap.
+    const source = [
+      `<script setup lang="ts">`,
+      `import { ref } from 'vue';`,
+      `const open = ref(`,
+    ].join('\n');
+
+    const { ctx } = makeContext(() => []);
+
+    await expect(
+      vueImportParser.parse({ filePath: '/tmp/Broken.vue', source }, ctx)
+    ).rejects.toBeInstanceOf(ChangeDetectionFailureError);
+  });
+});
diff --git a/code/renderers/vue3/src/parsers/vueImportParser.ts b/code/renderers/vue3/src/parsers/vueImportParser.ts
new file mode 100644
index 000000000000..c940f13295fb
--- /dev/null
+++ b/code/renderers/vue3/src/parsers/vueImportParser.ts
@@ -0,0 +1,120 @@
+import {
+  ChangeDetectionFailureError,
+  type ImportEdge,
+  type ImportParser,
+} from 'storybook/internal/core-server';
+
+// Vue 3.2.13+ re-exports `@vue/compiler-sfc` as `vue/compiler-sfc`, so we do NOT need
+// an explicit `@vue/compiler-sfc` dependency here. `vue` is already a peer dep of the
+// renderer and is guaranteed to be installed in any user project that uses Storybook
+// for Vue.
+type VueCompilerSfc = typeof import('vue/compiler-sfc');
+
+let compilerSfcPromise: Promise<VueCompilerSfc> | undefined;
+
+async function getCompilerSfc(): Promise<VueCompilerSfc> {
+  if (!compilerSfcPromise) {
+    compilerSfcPromise = import('vue/compiler-sfc').catch((error: unknown) => {
+      compilerSfcPromise = undefined;
+      throw new ChangeDetectionFailureError(
+        `Failed to load 'vue/compiler-sfc'. Original error: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+        error instanceof Error ? { cause: error } : undefined
+      );
+    });
+  }
+  return compilerSfcPromise;
+}
+
+function virtualExtensionForLang(lang: string | undefined): 'ts' | 'tsx' | 'js' | 'jsx' {
+  // The virtual extension only controls how oxc parses the extracted script text —
+  // TS/TSX both enable the TS superset, JS/JSX tell oxc to enable JSX syntax without
+  // types. Everything else (markdown loaders, SCSS, etc.) is NOT script content and
+  // we will not see it here because vue/compiler-sfc only surfaces JS-family langs
+  // under `descriptor.script{,Setup}`.
+  switch (lang) {
+    case 'ts':
+      return 'ts';
+    case 'tsx':
+      return 'tsx';
+    case 'jsx':
+      return 'jsx';
+    default:
+      return 'js';
+  }
+}
+
+/**
+ * Parser plugin for Vue single-file components. Cracks the `.vue` container via
+ * `vue/compiler-sfc` and delegates actual import extraction to the built-in oxc
+ * wrapper via {@link ctx.parseScriptWithOxc}.
+ *
+ * Handles both `<script>` and `<script setup>` blocks; `lang="ts"`/`lang="tsx"` is
+ * honoured by picking the right virtual extension so oxc parses in TS mode. Template
+ * imports (`<template>` expressions, `:is="..."` tag references) are NOT extracted —
+ * Storybook's change-detection graph is a JS/TS import graph only.
+ *
+ * The `vue/compiler-sfc` dep is lazy-loaded so change-detection opt-outs do not pay
+ * the import cost. It resolves to the user's installed `vue` package, which is a peer
+ * dep of `@storybook/vue3`.
+ */
+export const vueImportParser: ImportParser = {
+  extensions: ['.vue'],
+  async parse({ filePath, source }, ctx) {
+    const sfc = await getCompilerSfc();
+
+    let parsed: Awaited<ReturnType<typeof sfc.parse>>;
+    try {
+      parsed = sfc.parse(source, { filename: filePath });
+    } catch (error) {
+      throw new ChangeDetectionFailureError(
+        `vue/compiler-sfc failed to parse ${filePath}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+        error instanceof Error ? { cause: error } : undefined
+      );
+    }
+
+    if (parsed.errors.length > 0) {
+      const first = parsed.errors[0];
+      const message = first instanceof Error ? first.message : String(first);
+      throw new ChangeDetectionFailureError(
+        `vue/compiler-sfc reported errors for ${filePath}: ${message}`
+      );
+    }
+
+    const { descriptor } = parsed;
+    const blocks: { content: string; lang: string | undefined }[] = [];
+    if (descriptor.script && descriptor.script.content.length > 0) {
+      blocks.push({ content: descriptor.script.content, lang: descriptor.script.lang });
+    }
+    if (descriptor.scriptSetup && descriptor.scriptSetup.content.length > 0) {
+      blocks.push({
+        content: descriptor.scriptSetup.content,
+        lang: descriptor.scriptSetup.lang,
+      });
+    }
+
+    if (blocks.length === 0) {
+      return [];
+    }
+
+    const edges: ImportEdge[] = [];
+    const seen = new Set<string>();
+    for (const block of blocks) {
+      const ext = virtualExtensionForLang(block.lang);
+      const virtualFilePath = `${filePath}.script.${ext}`;
+      const scriptEdges = await ctx.parseScriptWithOxc(block.content, virtualFilePath);
+      for (const edge of scriptEdges) {
+        const key = `${edge.kind}:${edge.specifier}`;
+        if (seen.has(key)) {
+          continue;
+        }
+        seen.add(key);
+        edges.push(edge);
+      }
+    }
+    return edges;
+  },
+};
diff --git a/code/renderers/vue3/src/preset.ts b/code/renderers/vue3/src/preset.ts
index 7d688e4d3627..05cbd9eb9e79 100644
--- a/code/renderers/vue3/src/preset.ts
+++ b/code/renderers/vue3/src/preset.ts
@@ -1,5 +1,6 @@
 import { fileURLToPath } from 'node:url';
 
+import type { ImportParser } from 'storybook/internal/core-server';
 import type { PresetProperty } from 'storybook/internal/types';
 
 export const previewAnnotations: PresetProperty<'previewAnnotations'> = async (
@@ -16,3 +17,10 @@ export const previewAnnotations: PresetProperty<'previewAnnotations'> = async (
       docsEnabled ? [fileURLToPath(import.meta.resolve('@storybook/vue3/entry-preview-docs'))] : []
     );
 };
+
+export const experimental_importParsers = async (
+  input: ImportParser[] = []
+): Promise<ImportParser[]> => {
+  const { vueImportParser } = await import('./parsers/index.ts');
+  return [...input, vueImportParser];
+};
diff --git a/code/vitest.config.storybook.ts b/code/vitest.config.storybook.ts
index 2088e69634ae..f37246bce275 100644
--- a/code/vitest.config.storybook.ts
+++ b/code/vitest.config.storybook.ts
@@ -34,6 +34,7 @@ export default defineProject({
       ...defaultExclude,
       'node_modules/**',
       '**/__mockdata__/**',
+      '**/*.bench.ts', // benchmark files are Node-only; never run in the browser project
       '**/Zoom.stories.tsx', // expected to fail in Vitest because of fetching /iframe.html to cause ECONNREFUSED
       './addons/docs/src/blocks/**', // won't work because of https://github.com/storybookjs/storybook/issues/29783
     ],
diff --git a/docs/configure/user-interface/change-detection.mdx b/docs/configure/user-interface/change-detection.mdx
index ee6a2f36d3d1..322af02702fc 100644
--- a/docs/configure/user-interface/change-detection.mdx
+++ b/docs/configure/user-interface/change-detection.mdx
@@ -56,6 +56,53 @@ Change detection is enabled by default. To disable it, set [`features.changeDete
 
 <CodeSnippets path="main-config-features-change-detection.md" />
 
+## Troubleshooting
+
+If status icons don't appear in your sidebar, check the following:
+
+- The dev server terminal log for messages prefixed with `Change detection:` — startup errors, unsupported builder warnings, and parse failures all surface there.
+- That you are running `storybook dev` against a Vite-based framework (the only currently supported builder).
+- That your project is inside a git repository.
+- That `features.changeDetection` is not set to `false` in your Storybook configuration.
+
+### Workspace sibling packages not tracked in monorepos
+
+In a monorepo, when a story imports a workspace sibling package (e.g., `@myorg/ui` declared as `"workspace:*"` in `package.json`), the dependency may not be tracked, meaning changes to that sibling won't trigger a story reload. There are two root causes:
+
+**Built output missing at dev time.** Workspace packages typically point their `exports` or `main` fields to compiled output (`./dist/index.js`, `./esm/index.mjs`, etc.) that doesn't exist until the package is built. Storybook's resolver finds the symlink in `node_modules` but can't resolve the entry file, so it treats the import as untrackable. Even when the package has been built, its output directories are usually `.gitignore`d, meaning the resolved files are outside the set of watched source files and changes to them would never trigger a story reload.
+
+**Per-package `tsconfig.json` blocking root paths.** Many monorepos define workspace path aliases in the root `tsconfig.json` (e.g., `"@myorg/*": ["./packages/@myorg/*/src"]`) so that bundlers resolve imports directly to source. If a package has its own `tsconfig.json` that doesn't extend root, Storybook's resolver finds that file first during its directory walk-up and never sees the root-level path mappings.
+
+To ensure cross-workspace dependencies are tracked correctly, add `paths` entries to your root `tsconfig.json` pointing to the source directories of your workspace packages:
+
+```json title="tsconfig.json"
+{
+  "compilerOptions": {
+    "paths": {
+      "@myorg/*": ["./packages/@myorg/*/src"]
+    }
+  }
+}
+```
+
+Storybook uses these mappings as a fallback when per-file resolution does not find the module.
+
+### Many unrelated stories marked as related after a single change
+
+If a change to one component (e.g., `Breadcrumb`) causes every story that imports from a shared package (e.g., `@myorg/ui`) to be marked as **related**, the package is using a barrel file — a single `index.ts` that re-exports everything. Storybook's dependency graph tracks file-level dependencies, not export-level ones. A story that imports `import { Button } from '@myorg/ui'` depends on the resolved barrel file. When `Breadcrumb.tsx` changes, the barrel file is considered changed (it transitively imports it), so all stories depending on that barrel are marked related.
+
+This is a fundamental limitation of file-level dependency tracking. The only way to eliminate false positives is to import components from their direct source paths instead of the barrel:
+
+```ts
+// Instead of the barrel import:
+import { Button } from '@myorg/ui';
+
+// Import directly from the component's source:
+import { Button } from '@myorg/ui/Button';
+```
+
+Whether this is practical depends on the library. Libraries that publish deep-import paths (or that you own and can restructure) allow this workaround; libraries that intentionally expose only a barrel do not.
+
 ## How it works
 
-When you run `storybook dev`, Storybook subscribes to the builder's module graph via an `onModuleGraphChange` hook. A git diff provider watches your working tree for changes and runs `git diff` to identify modified or new files. Storybook then traces each changed file through the module import graph (by following `import` statements) to find all story files that depend on it — directly or transitively. Stories with the shortest import distance are marked **modified**; those at greater distance are marked **related**. New untracked files are marked **new**.
+When you run `storybook dev`, Storybook builds its own dependency graph by parsing each story file (and its imports) with [oxc](https://oxc.rs/) and resolves module specifiers through the builder's resolve config. The builder ships a small change-detection adapter that forwards file-system events into Storybook so the graph stays current. A git diff provider watches your working tree for changes and runs `git diff` to identify modified or new files. Storybook then traces each changed file through the dependency graph to find all story files that depend on it — directly or transitively. Stories with the shortest import distance are marked **modified**; those at greater distance are marked **related**. New untracked files are marked **new**.
diff --git a/scripts/task.ts b/scripts/task.ts
index cd1a7437bbfc..02df2448d8ef 100644
--- a/scripts/task.ts
+++ b/scripts/task.ts
@@ -536,7 +536,7 @@ async function run() {
           errorTitle += ` for ${picocolors.bgCyan(picocolors.white(details.key))}:`;
         }
         logger.error(errorTitle);
-        logger.error(JSON.stringify(err, null, 2));
+        logger.error(err);
 
         if (process.env.CI) {
           const separator = '\n--------------------------------------------\n';
diff --git a/scripts/tasks/dev.ts b/scripts/tasks/dev.ts
index 44af79513472..1b419704b722 100644
--- a/scripts/tasks/dev.ts
+++ b/scripts/tasks/dev.ts
@@ -1,3 +1,7 @@
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
 import waitOn from 'wait-on';
 
 import type { AllTemplatesKey } from '../../code/lib/cli-storybook/src/sandbox-templates.ts';
@@ -8,6 +12,34 @@ import { exec } from '../utils/exec.ts';
 import { isNxTaskExecution } from '../utils/nx.ts';
 import { prepareSandbox } from '../prepare-sandbox.ts';
 
+/**
+ * Initialise a git repo with an initial commit in the sandbox so the Storybook dev server can
+ * use change detection from the moment it starts (git diff requires at least one commit).
+ *
+ * Idempotent — skips `git init` if `.git` already exists, skips the initial commit if HEAD
+ * already points to one. Chromatic and publishing flows run in dedicated jobs with their own
+ * checkout, so initialising git inside the dev sandbox does not affect them.
+ */
+function initGitForChangeDetection(sandboxDir: string): void {
+  const gitEnv = {
+    ...process.env,
+    GIT_AUTHOR_NAME: 'Storybook Sandbox',
+    GIT_AUTHOR_EMAIL: 'sandbox@storybook.js',
+    GIT_COMMITTER_NAME: 'Storybook Sandbox',
+    GIT_COMMITTER_EMAIL: 'sandbox@storybook.js',
+  };
+  const gitOpts = { cwd: sandboxDir, stdio: 'pipe' as const, env: gitEnv };
+  if (!existsSync(join(sandboxDir, '.git'))) {
+    execSync('git init', gitOpts);
+  }
+  try {
+    execSync('git rev-parse HEAD', { cwd: sandboxDir, stdio: 'pipe' });
+  } catch {
+    execSync('git add -A', gitOpts);
+    execSync('git commit --allow-empty -m "Initial sandbox commit" --no-verify', gitOpts);
+  }
+}
+
 export const PORT = process.env.STORYBOOK_SERVE_PORT
   ? parseInt(process.env.STORYBOOK_SERVE_PORT, 10)
   : 6006;
@@ -31,6 +63,17 @@ export const dev: Task = {
   },
   async run({ sandboxDir, key, selectedTask }, { dryRun, debug, link }) {
     await prepareSandbox({ key, link });
+
+    if (!dryRun) {
+      try {
+        initGitForChangeDetection(sandboxDir);
+      } catch (e) {
+        console.warn(
+          `Failed to initialise git in sandbox for change detection: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+
     const controller = new AbortController();
     const port = getDevPort(key);
     const devCommand = `yarn storybook --port ${port}${selectedTask === 'dev' ? '' : ' --ci'}`;
diff --git a/yarn.lock b/yarn.lock
index 5ede19545246..39d0c4d5aa93 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2326,6 +2326,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@emnapi/core@npm:1.9.2":
+  version: 1.9.2
+  resolution: "@emnapi/core@npm:1.9.2"
+  dependencies:
+    "@emnapi/wasi-threads": "npm:1.2.1"
+    tslib: "npm:^2.4.0"
+  checksum: 10c0/5500393f953951bad0768fafaa9191f2d938956b20c6d6a79e5ab696a613a25ce6ad23422bc18e86e6ce8deb147619d8d0d7d413a69f84adc01a6633cc353cd9
+  languageName: node
+  linkType: hard
+
 "@emnapi/runtime@npm:1.10.0, @emnapi/runtime@npm:^1.1.0, @emnapi/runtime@npm:^1.4.3, @emnapi/runtime@npm:^1.7.0":
   version: 1.10.0
   resolution: "@emnapi/runtime@npm:1.10.0"
@@ -2335,6 +2345,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@emnapi/runtime@npm:1.9.2":
+  version: 1.9.2
+  resolution: "@emnapi/runtime@npm:1.9.2"
+  dependencies:
+    tslib: "npm:^2.4.0"
+  checksum: 10c0/61c3a59e0c36784558b8d58eb02bd04815aa5fb0dbfbaf84d1b3050a78aa0cc63ea129ae806bd1e48062bfeb7fc36eb0e5431740d62f64ea51bdf426404b8caa
+  languageName: node
+  linkType: hard
+
 "@emnapi/wasi-threads@npm:1.2.1":
   version: 1.2.1
   resolution: "@emnapi/wasi-threads@npm:1.2.1"
@@ -3961,7 +3980,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@napi-rs/wasm-runtime@npm:^1.0.7, @napi-rs/wasm-runtime@npm:^1.1.4":
+"@napi-rs/wasm-runtime@npm:^1.1.1, @napi-rs/wasm-runtime@npm:^1.1.4":
   version: 1.1.4
   resolution: "@napi-rs/wasm-runtime@npm:1.1.4"
   dependencies:
@@ -4832,144 +4851,295 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@oxc-project/types@npm:=0.127.0":
+"@oxc-parser/binding-android-arm-eabi@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-android-arm-eabi@npm:0.127.0"
+  conditions: os=android & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-android-arm64@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-android-arm64@npm:0.127.0"
+  conditions: os=android & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-darwin-arm64@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-darwin-arm64@npm:0.127.0"
+  conditions: os=darwin & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-darwin-x64@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-darwin-x64@npm:0.127.0"
+  conditions: os=darwin & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-freebsd-x64@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-freebsd-x64@npm:0.127.0"
+  conditions: os=freebsd & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-linux-arm-gnueabihf@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-linux-arm-gnueabihf@npm:0.127.0"
+  conditions: os=linux & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-linux-arm-musleabihf@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-linux-arm-musleabihf@npm:0.127.0"
+  conditions: os=linux & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-linux-arm64-gnu@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-linux-arm64-gnu@npm:0.127.0"
+  conditions: os=linux & cpu=arm64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-linux-arm64-musl@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-linux-arm64-musl@npm:0.127.0"
+  conditions: os=linux & cpu=arm64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-linux-ppc64-gnu@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-linux-ppc64-gnu@npm:0.127.0"
+  conditions: os=linux & cpu=ppc64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-linux-riscv64-gnu@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-linux-riscv64-gnu@npm:0.127.0"
+  conditions: os=linux & cpu=riscv64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-linux-riscv64-musl@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-linux-riscv64-musl@npm:0.127.0"
+  conditions: os=linux & cpu=riscv64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-linux-s390x-gnu@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-linux-s390x-gnu@npm:0.127.0"
+  conditions: os=linux & cpu=s390x & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-linux-x64-gnu@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-linux-x64-gnu@npm:0.127.0"
+  conditions: os=linux & cpu=x64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-linux-x64-musl@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-linux-x64-musl@npm:0.127.0"
+  conditions: os=linux & cpu=x64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-openharmony-arm64@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-openharmony-arm64@npm:0.127.0"
+  conditions: os=openharmony & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-wasm32-wasi@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-wasm32-wasi@npm:0.127.0"
+  dependencies:
+    "@emnapi/core": "npm:1.9.2"
+    "@emnapi/runtime": "npm:1.9.2"
+    "@napi-rs/wasm-runtime": "npm:^1.1.4"
+  conditions: cpu=wasm32
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-win32-arm64-msvc@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-win32-arm64-msvc@npm:0.127.0"
+  conditions: os=win32 & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-win32-ia32-msvc@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-win32-ia32-msvc@npm:0.127.0"
+  conditions: os=win32 & cpu=ia32
+  languageName: node
+  linkType: hard
+
+"@oxc-parser/binding-win32-x64-msvc@npm:0.127.0":
+  version: 0.127.0
+  resolution: "@oxc-parser/binding-win32-x64-msvc@npm:0.127.0"
+  conditions: os=win32 & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@oxc-project/types@npm:=0.127.0, @oxc-project/types@npm:^0.127.0":
   version: 0.127.0
   resolution: "@oxc-project/types@npm:0.127.0"
   checksum: 10c0/52c0947ac64a9ca119fe971f947e784a35ecd14a072fa3f542a58a5f6c42010b53f2bf92731e39b9899b83c990a9517bbd29d1e5a5b7b489e52616685c6a9278
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-android-arm-eabi@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-android-arm-eabi@npm:11.14.0"
+"@oxc-resolver/binding-android-arm-eabi@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-android-arm-eabi@npm:11.19.1"
   conditions: os=android & cpu=arm
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-android-arm64@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-android-arm64@npm:11.14.0"
+"@oxc-resolver/binding-android-arm64@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-android-arm64@npm:11.19.1"
   conditions: os=android & cpu=arm64
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-darwin-arm64@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-darwin-arm64@npm:11.14.0"
+"@oxc-resolver/binding-darwin-arm64@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-darwin-arm64@npm:11.19.1"
   conditions: os=darwin & cpu=arm64
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-darwin-x64@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-darwin-x64@npm:11.14.0"
+"@oxc-resolver/binding-darwin-x64@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-darwin-x64@npm:11.19.1"
   conditions: os=darwin & cpu=x64
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-freebsd-x64@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-freebsd-x64@npm:11.14.0"
+"@oxc-resolver/binding-freebsd-x64@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-freebsd-x64@npm:11.19.1"
   conditions: os=freebsd & cpu=x64
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-linux-arm-gnueabihf@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-linux-arm-gnueabihf@npm:11.14.0"
+"@oxc-resolver/binding-linux-arm-gnueabihf@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-arm-gnueabihf@npm:11.19.1"
   conditions: os=linux & cpu=arm
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-linux-arm-musleabihf@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-linux-arm-musleabihf@npm:11.14.0"
+"@oxc-resolver/binding-linux-arm-musleabihf@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-arm-musleabihf@npm:11.19.1"
   conditions: os=linux & cpu=arm
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-linux-arm64-gnu@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-linux-arm64-gnu@npm:11.14.0"
+"@oxc-resolver/binding-linux-arm64-gnu@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-arm64-gnu@npm:11.19.1"
   conditions: os=linux & cpu=arm64 & libc=glibc
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-linux-arm64-musl@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-linux-arm64-musl@npm:11.14.0"
+"@oxc-resolver/binding-linux-arm64-musl@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-arm64-musl@npm:11.19.1"
   conditions: os=linux & cpu=arm64 & libc=musl
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-linux-ppc64-gnu@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-linux-ppc64-gnu@npm:11.14.0"
+"@oxc-resolver/binding-linux-ppc64-gnu@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-ppc64-gnu@npm:11.19.1"
   conditions: os=linux & cpu=ppc64 & libc=glibc
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-linux-riscv64-gnu@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-linux-riscv64-gnu@npm:11.14.0"
+"@oxc-resolver/binding-linux-riscv64-gnu@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-riscv64-gnu@npm:11.19.1"
   conditions: os=linux & cpu=riscv64 & libc=glibc
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-linux-riscv64-musl@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-linux-riscv64-musl@npm:11.14.0"
+"@oxc-resolver/binding-linux-riscv64-musl@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-riscv64-musl@npm:11.19.1"
   conditions: os=linux & cpu=riscv64 & libc=musl
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-linux-s390x-gnu@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-linux-s390x-gnu@npm:11.14.0"
+"@oxc-resolver/binding-linux-s390x-gnu@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-s390x-gnu@npm:11.19.1"
   conditions: os=linux & cpu=s390x & libc=glibc
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-linux-x64-gnu@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-linux-x64-gnu@npm:11.14.0"
+"@oxc-resolver/binding-linux-x64-gnu@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-x64-gnu@npm:11.19.1"
   conditions: os=linux & cpu=x64 & libc=glibc
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-linux-x64-musl@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-linux-x64-musl@npm:11.14.0"
+"@oxc-resolver/binding-linux-x64-musl@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-x64-musl@npm:11.19.1"
   conditions: os=linux & cpu=x64 & libc=musl
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-wasm32-wasi@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-wasm32-wasi@npm:11.14.0"
+"@oxc-resolver/binding-openharmony-arm64@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-openharmony-arm64@npm:11.19.1"
+  conditions: os=openharmony & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-wasm32-wasi@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-wasm32-wasi@npm:11.19.1"
   dependencies:
-    "@napi-rs/wasm-runtime": "npm:^1.0.7"
+    "@napi-rs/wasm-runtime": "npm:^1.1.1"
   conditions: cpu=wasm32
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-win32-arm64-msvc@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-win32-arm64-msvc@npm:11.14.0"
+"@oxc-resolver/binding-win32-arm64-msvc@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-win32-arm64-msvc@npm:11.19.1"
   conditions: os=win32 & cpu=arm64
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-win32-ia32-msvc@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-win32-ia32-msvc@npm:11.14.0"
+"@oxc-resolver/binding-win32-ia32-msvc@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-win32-ia32-msvc@npm:11.19.1"
   conditions: os=win32 & cpu=ia32
   languageName: node
   linkType: hard
 
-"@oxc-resolver/binding-win32-x64-msvc@npm:11.14.0":
-  version: 11.14.0
-  resolution: "@oxc-resolver/binding-win32-x64-msvc@npm:11.14.0"
+"@oxc-resolver/binding-win32-x64-msvc@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-win32-x64-msvc@npm:11.19.1"
   conditions: os=win32 & cpu=x64
   languageName: node
   linkType: hard
@@ -24708,29 +24878,100 @@ __metadata:
   languageName: node
   linkType: hard
 
-"oxc-resolver@npm:^11.13.2":
-  version: 11.14.0
-  resolution: "oxc-resolver@npm:11.14.0"
-  dependencies:
-    "@oxc-resolver/binding-android-arm-eabi": "npm:11.14.0"
-    "@oxc-resolver/binding-android-arm64": "npm:11.14.0"
-    "@oxc-resolver/binding-darwin-arm64": "npm:11.14.0"
-    "@oxc-resolver/binding-darwin-x64": "npm:11.14.0"
-    "@oxc-resolver/binding-freebsd-x64": "npm:11.14.0"
-    "@oxc-resolver/binding-linux-arm-gnueabihf": "npm:11.14.0"
-    "@oxc-resolver/binding-linux-arm-musleabihf": "npm:11.14.0"
-    "@oxc-resolver/binding-linux-arm64-gnu": "npm:11.14.0"
-    "@oxc-resolver/binding-linux-arm64-musl": "npm:11.14.0"
-    "@oxc-resolver/binding-linux-ppc64-gnu": "npm:11.14.0"
-    "@oxc-resolver/binding-linux-riscv64-gnu": "npm:11.14.0"
-    "@oxc-resolver/binding-linux-riscv64-musl": "npm:11.14.0"
-    "@oxc-resolver/binding-linux-s390x-gnu": "npm:11.14.0"
-    "@oxc-resolver/binding-linux-x64-gnu": "npm:11.14.0"
-    "@oxc-resolver/binding-linux-x64-musl": "npm:11.14.0"
-    "@oxc-resolver/binding-wasm32-wasi": "npm:11.14.0"
-    "@oxc-resolver/binding-win32-arm64-msvc": "npm:11.14.0"
-    "@oxc-resolver/binding-win32-ia32-msvc": "npm:11.14.0"
-    "@oxc-resolver/binding-win32-x64-msvc": "npm:11.14.0"
+"oxc-parser@npm:^0.127.0":
+  version: 0.127.0
+  resolution: "oxc-parser@npm:0.127.0"
+  dependencies:
+    "@oxc-parser/binding-android-arm-eabi": "npm:0.127.0"
+    "@oxc-parser/binding-android-arm64": "npm:0.127.0"
+    "@oxc-parser/binding-darwin-arm64": "npm:0.127.0"
+    "@oxc-parser/binding-darwin-x64": "npm:0.127.0"
+    "@oxc-parser/binding-freebsd-x64": "npm:0.127.0"
+    "@oxc-parser/binding-linux-arm-gnueabihf": "npm:0.127.0"
+    "@oxc-parser/binding-linux-arm-musleabihf": "npm:0.127.0"
+    "@oxc-parser/binding-linux-arm64-gnu": "npm:0.127.0"
+    "@oxc-parser/binding-linux-arm64-musl": "npm:0.127.0"
+    "@oxc-parser/binding-linux-ppc64-gnu": "npm:0.127.0"
+    "@oxc-parser/binding-linux-riscv64-gnu": "npm:0.127.0"
+    "@oxc-parser/binding-linux-riscv64-musl": "npm:0.127.0"
+    "@oxc-parser/binding-linux-s390x-gnu": "npm:0.127.0"
+    "@oxc-parser/binding-linux-x64-gnu": "npm:0.127.0"
+    "@oxc-parser/binding-linux-x64-musl": "npm:0.127.0"
+    "@oxc-parser/binding-openharmony-arm64": "npm:0.127.0"
+    "@oxc-parser/binding-wasm32-wasi": "npm:0.127.0"
+    "@oxc-parser/binding-win32-arm64-msvc": "npm:0.127.0"
+    "@oxc-parser/binding-win32-ia32-msvc": "npm:0.127.0"
+    "@oxc-parser/binding-win32-x64-msvc": "npm:0.127.0"
+    "@oxc-project/types": "npm:^0.127.0"
+  dependenciesMeta:
+    "@oxc-parser/binding-android-arm-eabi":
+      optional: true
+    "@oxc-parser/binding-android-arm64":
+      optional: true
+    "@oxc-parser/binding-darwin-arm64":
+      optional: true
+    "@oxc-parser/binding-darwin-x64":
+      optional: true
+    "@oxc-parser/binding-freebsd-x64":
+      optional: true
+    "@oxc-parser/binding-linux-arm-gnueabihf":
+      optional: true
+    "@oxc-parser/binding-linux-arm-musleabihf":
+      optional: true
+    "@oxc-parser/binding-linux-arm64-gnu":
+      optional: true
+    "@oxc-parser/binding-linux-arm64-musl":
+      optional: true
+    "@oxc-parser/binding-linux-ppc64-gnu":
+      optional: true
+    "@oxc-parser/binding-linux-riscv64-gnu":
+      optional: true
+    "@oxc-parser/binding-linux-riscv64-musl":
+      optional: true
+    "@oxc-parser/binding-linux-s390x-gnu":
+      optional: true
+    "@oxc-parser/binding-linux-x64-gnu":
+      optional: true
+    "@oxc-parser/binding-linux-x64-musl":
+      optional: true
+    "@oxc-parser/binding-openharmony-arm64":
+      optional: true
+    "@oxc-parser/binding-wasm32-wasi":
+      optional: true
+    "@oxc-parser/binding-win32-arm64-msvc":
+      optional: true
+    "@oxc-parser/binding-win32-ia32-msvc":
+      optional: true
+    "@oxc-parser/binding-win32-x64-msvc":
+      optional: true
+  checksum: 10c0/9d109fb3a79c0862a36434cc01c8c0e8f6cf5f1efe9369e02d2183fd518479b10262cf092da2e7f8328befae446afa05ccf742ce12f8346d81429c8f2cdf1651
+  languageName: node
+  linkType: hard
+
+"oxc-resolver@npm:^11.13.2, oxc-resolver@npm:^11.19.1":
+  version: 11.19.1
+  resolution: "oxc-resolver@npm:11.19.1"
+  dependencies:
+    "@oxc-resolver/binding-android-arm-eabi": "npm:11.19.1"
+    "@oxc-resolver/binding-android-arm64": "npm:11.19.1"
+    "@oxc-resolver/binding-darwin-arm64": "npm:11.19.1"
+    "@oxc-resolver/binding-darwin-x64": "npm:11.19.1"
+    "@oxc-resolver/binding-freebsd-x64": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-arm-gnueabihf": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-arm-musleabihf": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-arm64-gnu": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-arm64-musl": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-ppc64-gnu": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-riscv64-gnu": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-riscv64-musl": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-s390x-gnu": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-x64-gnu": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-x64-musl": "npm:11.19.1"
+    "@oxc-resolver/binding-openharmony-arm64": "npm:11.19.1"
+    "@oxc-resolver/binding-wasm32-wasi": "npm:11.19.1"
+    "@oxc-resolver/binding-win32-arm64-msvc": "npm:11.19.1"
+    "@oxc-resolver/binding-win32-ia32-msvc": "npm:11.19.1"
+    "@oxc-resolver/binding-win32-x64-msvc": "npm:11.19.1"
   dependenciesMeta:
     "@oxc-resolver/binding-android-arm-eabi":
       optional: true
@@ -24762,6 +25003,8 @@ __metadata:
       optional: true
     "@oxc-resolver/binding-linux-x64-musl":
       optional: true
+    "@oxc-resolver/binding-openharmony-arm64":
+      optional: true
     "@oxc-resolver/binding-wasm32-wasi":
       optional: true
     "@oxc-resolver/binding-win32-arm64-msvc":
@@ -24770,7 +25013,7 @@ __metadata:
       optional: true
     "@oxc-resolver/binding-win32-x64-msvc":
       optional: true
-  checksum: 10c0/07fc64fc69462860d7e1dcb32d10880670cd777936d99721b523e8d095df8240fa01ee624aafc19978010b7b788bfb53202cea2b70efe5fc43bc1d1296025e6b
+  checksum: 10c0/8ac4eaffa9c0bcbb9f4f4a2b43786457ec5a68684d8776cb78b5a15ce3d1a79d3e67262aa3c635f98a0c1cd6cd56a31fcb05bffb9a286100056e4ab06b928833
   languageName: node
   linkType: hard
 
@@ -29411,6 +29654,8 @@ __metadata:
     nanoid: "npm:^4.0.2"
     npmlog: "npm:^7.0.0"
     open: "npm:^10.2.0"
+    oxc-parser: "npm:^0.127.0"
+    oxc-resolver: "npm:^11.19.1"
     p-limit: "npm:^7.2.0"
     package-manager-detector: "npm:^1.1.0"
     picocolors: "npm:^1.1.0"