@equinor/fusion-framework-vitest-plugin-react-app 1.0.0 → 1.0.1

package/docs/why-browser-mode.md

@@ -1,128 +0,0 @@
-# Why Browser Mode is the default
-
-`@equinor/fusion-framework-vitest-plugin-react-app` runs component and hook tests in headless
-Chromium by default. A real browser gives these tests more accurate DOM behavior, but it is
-slower than `happy-dom` or `jsdom`.
-
-This guide explains that tradeoff and shows how to use a different browser or renderer when a
-test does not need Chromium.
-
-## Performance
-
-A real browser is slower than DOM emulation. `happy-dom` and `jsdom` run in the same Node process
-as the test. Browser Mode starts Chromium through Playwright and communicates with that browser
-process.
-
-Choose Browser Mode for fidelity, not speed. Keep fast unit tests on Node or DOM emulation when
-they do not need browser behavior.
-
-## Why use a real browser
-
-- **React compatibility:** the previous React test setup failed after its React 19 peer
-  dependency update. The repository then moved those tests to Vitest Browser Mode. See the
-  `packages/utils/observable` 8.4.4 changelog and migration commit `059aefae5d`.
-- **Real framework execution:** tests control external boundaries and seed module state through
-  [Module mocks](module-mocks.md), while the actual module configuration, lifecycle, providers,
-  and rendering behavior still run.
-- **Browser fidelity:** Chromium provides real layout, `ResizeObserver`, custom elements, and
-  Shadow DOM — behavior `happy-dom` and `jsdom` only approximate.
-
-> [!WARNING]
-> A DOM-emulation gap is usually patched one of two ways: a polyfill standing in for the missing
-> browser API, or a component replacement that avoids exercising it at all. Both are test-only
-> code with no equivalent in production, and both defeat the point of the test: a polyfill can
-> drift from real browser behavior unnoticed, and a mocked component only proves the *mock*
-> renders correctly, never the real one. A passing test built on either can still fail — or
-> silently lie — against the real component. Treat every DOM-emulation workaround as debt to
-> remove, not a pattern to reach for.
-
-A real browser does not eliminate every workaround: AG Grid license messages and Lit dev-mode
-warnings are console noise from real Chromium runs, not DOM-emulation gaps, and suppressing them
-carries none of the risk above (see [Module mocks](module-mocks.md) for the supported way to
-seed module state instead of replacing a component). Remove a DOM-emulation-only workaround only
-after confirming the affected test still passes against the real component in Browser Mode.
-
-## Choose a different runtime
-
-You can change either the browser provider or the renderer:
-
-- Stay in Browser Mode and replace Playwright with another Vitest browser provider.
-- Keep the Fusion module setup but render with `happy-dom` or `jsdom`.
-
-### Use another browser provider
-
-Pass `test.browser.provider` to `defineProject` to replace Playwright while staying in Browser
-Mode. This example uses WebdriverIO:
-
-```ts
-import { defineProject } from '@equinor/fusion-framework-vitest-plugin-react-app/config';
-import { webdriverio } from '@vitest/browser-webdriverio';
-
-export default defineProject({
-  test: { browser: { provider: webdriverio() } },
-});
-```
-
-See [Configuration](configuration.md) for the complete `defineProject` behavior.
-
-### Use happy-dom or jsdom
-
-> [!CAUTION]
-> Rendering with `happy-dom` or `jsdom` reintroduces the DOM-emulation tradeoff above: any gap
-> between the emulation and a real browser has to be closed with a polyfill or a component
-> replacement, not fixed. Only take this path for a component or hook that provably does not
-> need browser fidelity — otherwise stay in Browser Mode.
-
-The Fusion module setup does not depend on Browser Mode. Build the same provider tree and pass it
-to another renderer. The example below uses `@testing-library/react` on `happy-dom`:
-
-```tsx
-import { render } from '@testing-library/react';
-import { mockFramework } from '@equinor/fusion-framework/mock';
-import { enableAppManifestMock, mockAppModules } from '@equinor/fusion-framework-app/mock';
-import { FrameworkProvider } from '@equinor/fusion-framework-react';
-import { ModuleProvider } from '@equinor/fusion-framework-react-module';
-import type { AppModule } from '@equinor/fusion-framework-module-app';
-import type { ReactElement } from 'react';
-
-const env = {
-  manifest: {
-    appKey: 'test-app',
-    displayName: 'Test App',
-    description: 'Test app',
-    type: 'standalone',
-  },
-} as const;
-
-async function renderWithHappyDom(ui: ReactElement) {
-  const framework = await mockFramework<[AppModule]>((configurator) =>
-    enableAppManifestMock(configurator, env),
-  );
-  const app = await mockAppModules(undefined, env, framework);
-  return render(ui, {
-    wrapper: ({ children }) => (
-      <FrameworkProvider value={framework}>
-        <ModuleProvider value={app}>{children}</ModuleProvider>
-      </FrameworkProvider>
-    ),
-  });
-}
-```
-
-Run the test in a Vitest project with `environment: 'happy-dom'` instead of
-`browser.enabled`. Use a separate project if the same app also has Browser Mode tests.
-
-Call the same `enable*Mock` functions from the `mockAppModules` configuration callback. These
-mocks configure Fusion modules and do not depend on the renderer. `renderHook` from
-`@testing-library/react` can use the same wrapper for hook tests.
-
-Use Browser Mode when browser behavior matters. Use `happy-dom`, `jsdom`, or no DOM for focused
-tests that only need application logic or simple rendering.
-
-## Related documentation
-
-- [Overview](overview.md)
-- [Configuration](configuration.md)
-- [Module mocks](module-mocks.md)
-- [Migrate an existing app to Fusion Vitest](migrating-an-existing-app.md)
-- [Choose a Fusion testing layer](../../../framework/docs/testing-choosing-a-layer.md)

package/src/__tests__/app-test-vite-plugin.test.ts

@@ -1,109 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { appTestVitePlugin } from '../index.js';
-
-type ResolveIdHook = (id: string) => string | null | undefined;
-type LoadHook = (id: string) => string | null | undefined | Promise<string | null | undefined>;
-type ConfigResolvedHook = (config: { root: string }) => void;
-
-describe('appTestVitePlugin', () => {
-  let dir: string;
-
-  beforeEach(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'fusion-vitest-plugin-react-app-'));
-    await writeFile(
-      join(dir, 'package.json'),
-      JSON.stringify({ name: '@equinor/my-app', version: '1.2.3' }),
-    );
-  });
-
-  afterEach(async () => {
-    await rm(dir, { recursive: true, force: true });
-  });
-
-  it('claims only its two virtual specifiers, leaving everything else unresolved', () => {
-    const plugin = appTestVitePlugin({ entrypoint: dir });
-    const resolveId = plugin.resolveId as ResolveIdHook;
-
-    expect(resolveId('virtual:fusion-app-test-env')).toBe('\0virtual:fusion-app-test-env');
-    expect(resolveId('virtual:fusion-app-test-configure')).toBe(
-      '\0virtual:fusion-app-test-configure',
-    );
-    expect(resolveId('some-other-module')).toBeNull();
-  });
-
-  it('serves the resolved manifest/config as the env virtual module', async () => {
-    const plugin = appTestVitePlugin({ entrypoint: dir });
-    const load = plugin.load as LoadHook;
-
-    const source = await load('\0virtual:fusion-app-test-env');
-
-    expect(source).toContain('"appKey":"my-app"');
-    expect(source).toContain('export const config = {"environment":{}};');
-  });
-
-  it('serves an undefined configure export when no config file exists', async () => {
-    const plugin = appTestVitePlugin({ entrypoint: dir });
-    const load = plugin.load as LoadHook;
-
-    const source = await load('\0virtual:fusion-app-test-configure');
-
-    expect(source).toBe('export const configure = undefined;');
-  });
-
-  it('resolves the app from the Vitest project root when no entrypoint is provided', async () => {
-    await mkdir(join(dir, 'src'), { recursive: true });
-    await writeFile(join(dir, 'src', 'index.ts'), 'export {};');
-    await writeFile(join(dir, 'src', 'config.ts'), 'export default () => undefined;');
-    const plugin = appTestVitePlugin();
-    const configResolved = plugin.configResolved as ConfigResolvedHook;
-    const load = plugin.load as LoadHook;
-
-    configResolved({ root: dir });
-
-    expect(await load('\0virtual:fusion-app-test-env')).toContain('"appKey":"my-app"');
-    expect(await load('\0virtual:fusion-app-test-configure')).toBe(
-      `export { default as configure } from ${JSON.stringify(join(dir, 'src', 'config.ts'))};`,
-    );
-  });
-
-  it('re-exports the default candidate config file as the configure virtual module', async () => {
-    await mkdir(join(dir, 'src'), { recursive: true });
-    await writeFile(join(dir, 'src', 'config.ts'), 'export default () => undefined;');
-    const plugin = appTestVitePlugin({ entrypoint: dir });
-    const load = plugin.load as LoadHook;
-
-    const source = await load('\0virtual:fusion-app-test-configure');
-
-    expect(source).toBe(
-      `export { default as configure } from ${JSON.stringify(join(dir, 'src', 'config.ts'))};`,
-    );
-  });
-
-  it('re-exports an explicitly requested configure file', async () => {
-    await writeFile(join(dir, 'my-config.ts'), 'export default () => undefined;');
-    const plugin = appTestVitePlugin({ entrypoint: dir, configure: 'my-config.ts' });
-    const load = plugin.load as LoadHook;
-
-    const source = await load('\0virtual:fusion-app-test-configure');
-
-    expect(source).toBe(
-      `export { default as configure } from ${JSON.stringify(join(dir, 'my-config.ts'))};`,
-    );
-  });
-
-  it('throws when an explicitly requested configure file does not exist', () => {
-    expect(() => appTestVitePlugin({ entrypoint: dir, configure: 'missing.ts' })).toThrow();
-  });
-
-  it('returns null for module ids other than its own virtual specifiers', async () => {
-    const plugin = appTestVitePlugin({ entrypoint: dir });
-    const load = plugin.load as LoadHook;
-
-    expect(await load('some-other-module')).toBeNull();
-  });
-});

package/src/__tests__/merge-env-config.test.ts

@@ -1,67 +0,0 @@
-import { AppConfig } from '@equinor/fusion-framework-module-app';
-import type { AppEnv } from '@equinor/fusion-framework-app';
-import { describe, expect, it } from 'vitest';
-
-import { mergeEnvConfig } from '../merge-env-config.js';
-
-describe('mergeEnvConfig', () => {
-  const baseEnv: AppEnv = {
-    manifest: {
-      appKey: 'test-app',
-      displayName: 'Test App',
-      description: 'A test application',
-      type: 'standalone',
-    },
-    config: new AppConfig({
-      environment: { foo: 'bar' },
-      endpoints: { api: { url: 'https://api.example.com', scopes: ['api.read'] } },
-    }),
-  };
-
-  it('adds a new endpoint without dropping existing ones', () => {
-    const merged = mergeEnvConfig(baseEnv, {
-      endpoints: { 'cpr-api': { url: 'https://cpr.example.com' } },
-    });
-
-    expect(merged.config?.endpoints).toEqual({
-      api: { url: 'https://api.example.com', scopes: ['api.read'] },
-      'cpr-api': { url: 'https://cpr.example.com', scopes: [] },
-    });
-  });
-
-  it('overrides one field of an existing endpoint, keeping the rest', () => {
-    const merged = mergeEnvConfig(baseEnv, {
-      endpoints: { api: { url: 'https://fake.example.com' } },
-    });
-
-    expect(merged.config?.endpoints.api).toEqual({
-      url: 'https://fake.example.com',
-      scopes: ['api.read'],
-    });
-  });
-
-  it('merges environment overrides over the existing environment', () => {
-    const merged = mergeEnvConfig(baseEnv, { environment: { baz: 'qux' } });
-
-    expect(merged.config?.environment).toEqual({ foo: 'bar', baz: 'qux' });
-  });
-
-  it('leaves the original env and its config untouched', () => {
-    mergeEnvConfig(baseEnv, { endpoints: { api: { url: 'https://fake.example.com' } } });
-
-    expect(baseEnv.config?.endpoints.api).toEqual({
-      url: 'https://api.example.com',
-      scopes: ['api.read'],
-    });
-  });
-
-  it('handles an env with no existing config', () => {
-    const env: AppEnv = { manifest: baseEnv.manifest };
-    const merged = mergeEnvConfig(env, { endpoints: { api: { url: 'https://api.example.com' } } });
-
-    expect(merged.config?.endpoints).toEqual({
-      api: { url: 'https://api.example.com', scopes: [] },
-    });
-    expect(merged.config?.environment).toEqual({});
-  });
-});

package/src/__tests__/resolve-app-test-env.test.ts

@@ -1,83 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { resolveAppTestEnv } from '../resolve-app-test-env.js';
-
-describe('resolveAppTestEnv', () => {
-  let dir: string;
-
-  beforeEach(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'fusion-vitest-plugin-react-app-'));
-    await writeFile(
-      join(dir, 'package.json'),
-      JSON.stringify({ name: '@equinor/my-app', version: '1.2.3', description: 'a test app' }),
-    );
-  });
-
-  afterEach(async () => {
-    await rm(dir, { recursive: true, force: true });
-  });
-
-  it('falls back to a package-derived manifest and an empty config with no local files', async () => {
-    const { manifest, config } = await resolveAppTestEnv({ entrypoint: dir });
-
-    expect(manifest).toMatchObject({
-      appKey: 'my-app',
-      displayName: '@equinor/my-app',
-      description: 'a test app',
-      type: 'standalone',
-    });
-    expect(config).toEqual({ environment: {} });
-  });
-
-  it('merges a local app.manifest.ts and app.config.ts, same as ffc app build', async () => {
-    await writeFile(
-      join(dir, 'app.manifest.ts'),
-      "export default { displayName: 'My Custom App' };",
-    );
-    await writeFile(
-      join(dir, 'app.config.ts'),
-      "export default { environment: {}, endpoints: { api: { url: 'https://example.com' } } };",
-    );
-
-    const { manifest, config } = await resolveAppTestEnv({ entrypoint: dir });
-
-    expect(manifest).toMatchObject({ appKey: 'my-app', displayName: 'My Custom App' });
-    expect(config).toEqual({
-      environment: {},
-      endpoints: { api: { url: 'https://example.com', scopes: [] } },
-    });
-  });
-
-  it('applies an inline manifest/config function directly, same as a loaded file default export', async () => {
-    const { manifest, config } = await resolveAppTestEnv({
-      entrypoint: dir,
-      manifest: () => ({ displayName: 'Inline App' }),
-      config: () => ({
-        environment: {},
-        endpoints: { api: { url: 'https://inline.example.com' } },
-      }),
-    });
-
-    expect(manifest).toMatchObject({ appKey: 'my-app', displayName: 'Inline App' });
-    expect(config).toEqual({
-      environment: {},
-      endpoints: { api: { url: 'https://inline.example.com', scopes: [] } },
-    });
-  });
-
-  it('propagates an error for an explicitly requested manifest file that does not exist', async () => {
-    await expect(
-      resolveAppTestEnv({ entrypoint: dir, manifest: 'does-not-exist.manifest.ts' }),
-    ).rejects.toThrow();
-  });
-
-  it('propagates an error for an explicitly requested config file that does not exist', async () => {
-    await expect(
-      resolveAppTestEnv({ entrypoint: dir, config: 'does-not-exist.config.ts' }),
-    ).rejects.toThrow();
-  });
-});

package/src/app-test.ts

@@ -1,19 +0,0 @@
-export {
-  renderAppHook,
-  type RenderAppHookOptions,
-  type RenderAppHookResult,
-} from './render-app-hook';
-export {
-  renderAppComponent,
-  type RenderAppComponentOptions,
-  type RenderAppComponentResult,
-} from './render-app-component';
-export { testApp } from './test-app';
-export { mergeEnvConfig, type MergeEnvConfigOverrides } from './merge-env-config.js';
-export type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
-
-// `test`/`render` import virtual modules only served once `appTestVitePlugin`
-// (@equinor/fusion-framework-vitest-plugin-react-app) is registered — using any export from
-// this module requires the plugin registered in your `vitest.config.ts` `plugins`.
-export { test } from './test';
-export { render } from './render';

package/src/define-project.ts

@@ -1,91 +0,0 @@
-import { playwright } from '@vitest/browser-playwright';
-import {
-  defineProject as defineVitestProject,
-  mergeConfig,
-  type UserWorkspaceConfig,
-} from 'vitest/config';
-
-import { appTestVitePlugin } from './index.js';
-
-/**
- * A config override for {@link defineProject}: an object is deep-merged onto the default
- * config via Vite's own `mergeConfig`; a function receives the default config and returns the
- * config used outright, for changes `mergeConfig` can't express (e.g. removing a field).
- */
-export type AppTestConfigOverride =
-  | Partial<UserWorkspaceConfig>
-  | ((config: UserWorkspaceConfig) => UserWorkspaceConfig);
-
-/**
- * Builds a ready-to-export Vitest project config for testing a Fusion Framework React app:
- * registers {@link appTestVitePlugin} (with its own defaults) and wires up Vitest browser mode
- * with the Playwright/`chromium` provider, so a consuming app's own `vitest.config.ts` needs no
- * browser-provider boilerplate of its own.
- *
- * @remarks
- * Drop-in replacement for Vitest's own `defineProject` — same `export default`, just pre-wired.
- * Playwright/`chromium` is only the *default* — pass `override` to change or replace anything
- * (e.g. `test.name`, or swap `test.browser.provider` for a different `@vitest/browser-*`
- * provider) without hand-rolling `appTestVitePlugin`'s own wiring. The default `1024x768`
- * viewport matches a typical low-resolution Citrix session rather than Vitest's own
- * mobile-sized default; pass `test.browser.viewport` to use a different size.
- *
- * @example
- * ```ts
- * import { defineProject } from '@equinor/fusion-framework-vitest-plugin-react-app/config';
- * import { name, version } from './package.json' with { type: 'json' };
- *
- * export default defineProject({ test: { name: `${name}@${version}` } });
- * ```
- *
- * @example
- * Overriding the browser provider:
- * ```ts
- * import { webdriverio } from '@vitest/browser-webdriverio';
- *
- * export default defineProject({ test: { browser: { provider: webdriverio() } } });
- * ```
- *
- * @param override - Deep-merged onto the default config (a plain object), or applied to it
- * outright (a function receiving the default config); see {@link AppTestConfigOverride}.
- * @returns A Vitest project config, ready to `export default`.
- */
-export const defineProject = (override?: AppTestConfigOverride): UserWorkspaceConfig => {
-  const defaults: UserWorkspaceConfig = {
-    plugins: [appTestVitePlugin()],
-    test: {
-      include: ['src/**/*.{test,spec}.{ts,tsx}'],
-      browser: {
-        enabled: true,
-        provider: playwright(),
-        headless: true,
-        // most users run the app through Citrix at a low, fixed resolution rather than a
-        // resizable desktop window — default to that instead of Vitest's own mobile-sized viewport
-        viewport: { width: 1024, height: 768 },
-        instances: [{ browser: 'chromium' }],
-      },
-    },
-    // pre-transforms all source up front so deps only reached via lazy/code-split imports
-    // (e.g. route components) are discovered before the first test request, not mid-run —
-    // the latter forces Vite to reload the page and fails the in-flight test file import
-    // `.d.ts` files are excluded: a CJS-style declaration file (e.g. one using `export =`)
-    // fails the warmup scan when loaded as ESM
-    server: { warmup: { clientFiles: ['src/**/*.{ts,tsx}', '!src/**/*.d.ts'] } },
-    // same reasoning as `server.warmup` above, but for the esbuild dep scanner: without this,
-    // its default entry detection can miss code-split route files entirely, so a package only
-    // ever imported from one of those (e.g. react-router's own deps) is discovered mid-run
-    // instead of up front — statically crawling every source file (which esbuild's scanner
-    // follows through dynamic imports too) avoids that with no per-package name needed
-    optimizeDeps: { entries: ['src/**/*.{ts,tsx}', '!src/**/*.d.ts'] },
-  };
-  // a function replaces the config outright; a plain object deep-merges onto it via Vite's own mergeConfig
-  const resolved =
-    typeof override === 'function'
-      ? override(defaults)
-      : override
-        ? (mergeConfig(defaults, override) as UserWorkspaceConfig)
-        : defaults;
-  return defineVitestProject(resolved);
-};
-
-export default defineProject;

package/src/index.ts

@@ -1,124 +0,0 @@
-import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-import { FileNotFoundError } from '@equinor/fusion-imports';
-import type { Plugin } from 'vite';
-
-import { resolveAppTestEnv, type ResolveAppTestEnvOptions } from './resolve-app-test-env.js';
-
-const ENV_MODULE_ID = 'virtual:fusion-app-test-env';
-const CONFIGURE_MODULE_ID = 'virtual:fusion-app-test-configure';
-const RESOLVED_ENV_MODULE_ID = `\0${ENV_MODULE_ID}`;
-const RESOLVED_CONFIGURE_MODULE_ID = `\0${CONFIGURE_MODULE_ID}`;
-
-const DEFAULT_CONFIGURE_CANDIDATES = ['src/config.ts', 'src/config.tsx', 'src/config.js'];
-
-/**
- * Options for {@link appTestVitePlugin}.
- */
-export type AppTestVitePluginOptions = ResolveAppTestEnvOptions & {
-  /**
-   * Path (relative to `entrypoint`) to the app's module-configurator export, mirroring the
-   * `configure` argument passed to `makeComponent` in the app's own entry point. Defaults to the
-   * first of `src/config.ts`, `src/config.tsx`, `src/config.js` that exists.
-   *
-   * @remarks
-   * Unlike `manifest`/`config`, this can't be an inline function: it's live application code
-   * (with its own imports and closures) re-exported as-is into the test bundle rather than
-   * JSON-serialized data, so Vite needs a real file on disk to resolve and transform.
-   */
-  configure?: string;
-};
-
-/**
- * Vite plugin serving an application's manifest/config (resolved the same way `ffc app build`/
- * `ffc app dev` do) and its own module-configurator export as virtual modules, so
- * `@equinor/fusion-framework-vitest-plugin-react-app/test`'s `test`/`render` need no per-test
- * `env`/`configure` wiring.
- *
- * @remarks
- * A plain Vite plugin — Vitest configs are Vite configs, so this registers directly in your
- * own `vitest.config.ts`, no CLI command required:
- * ```ts
- * import { defineConfig } from 'vitest/config';
- * import { appTestVitePlugin } from '@equinor/fusion-framework-vitest-plugin-react-app';
- *
- * export default defineConfig({
- *   plugins: [appTestVitePlugin()],
- *   // ...your own browser-mode config
- * });
- * ```
- * Exposes two virtual modules: `virtual:fusion-app-test-env` (`manifest`/`config`, as JSON) and
- * `virtual:fusion-app-test-configure` (a re-export of the resolved `configure` module, or
- * `undefined` if none exists). Not intended to be imported directly by application code.
- *
- * @param options - Resolution options; `entrypoint` defaults to the current working directory.
- * @returns A Vite plugin instance.
- */
-export const appTestVitePlugin = (options?: AppTestVitePluginOptions): Plugin => {
-  const explicitEntrypoint = options?.entrypoint;
-  let entrypoint = explicitEntrypoint;
-  let configureModulePath = explicitEntrypoint
-    ? resolveConfigureModulePath(explicitEntrypoint, options?.configure)
-    : undefined;
-
-  return {
-    name: 'fusion:app-test',
-    configResolved(config) {
-      // Vitest resolves each workspace project's root from its config file, which identifies the app containing src/index.ts.
-      entrypoint ??= config.root;
-      configureModulePath ??= resolveConfigureModulePath(entrypoint, options?.configure);
-    },
-    resolveId(id) {
-      // claim only our two virtual specifiers, leave everything else to the normal resolvers
-      if (id === ENV_MODULE_ID) return RESOLVED_ENV_MODULE_ID;
-      // second virtual specifier, same rule as above
-      if (id === CONFIGURE_MODULE_ID) return RESOLVED_CONFIGURE_MODULE_ID;
-      return null;
-    },
-    async load(id) {
-      // serves manifest/config resolved lazily here, not at plugin-creation time, so options.entrypoint changes between test runs are respected
-      if (id === RESOLVED_ENV_MODULE_ID) {
-        const { manifest, config } = await resolveAppTestEnv({ ...options, entrypoint });
-        return [
-          `export const manifest = ${JSON.stringify(manifest)};`,
-          `export const config = ${JSON.stringify(config)};`,
-        ].join('\n');
-      }
-      // no conventional module means the app registers no extra modules, same as omitting `configure` from `makeComponent`
-      if (id === RESOLVED_CONFIGURE_MODULE_ID) {
-        return configureModulePath
-          ? `export { default as configure } from ${JSON.stringify(configureModulePath)};`
-          : 'export const configure = undefined;';
-      }
-      return null;
-    },
-  };
-};
-
-/**
- * Resolves the app's module-configurator file: the explicit `file` if given, otherwise the
- * first existing candidate in {@link DEFAULT_CONFIGURE_CANDIDATES}.
- *
- * @throws {@link FileNotFoundError} If an explicitly requested `file` does not exist — unlike
- * the convention-based lookup, a typo here should fail loudly instead of silently running the
- * test suite without the application's modules.
- */
-const resolveConfigureModulePath = (cwd: string, file?: string): string | undefined => {
-  // an explicit path is a user request, not a convention lookup, so a typo must fail loudly
-  if (file) {
-    const resolved = resolve(cwd, file);
-    // fail fast rather than silently falling back to "no configurator"
-    if (!existsSync(resolved)) {
-      throw new FileNotFoundError(`Configure module not found: ${resolved}`);
-    }
-    return resolved;
-  }
-  // first candidate that exists wins; none existing is a valid "no configurator" state
-  const found = DEFAULT_CONFIGURE_CANDIDATES.find((candidate) =>
-    existsSync(resolve(cwd, candidate)),
-  );
-  return found ? resolve(cwd, found) : undefined;
-};
-
-export default appTestVitePlugin;