@typed/vite-plugin 0.17.1 → 1.0.0-beta.2

package/README.md

@@ -0,0 +1,97 @@
+# @typed/vite-plugin
+
+> **Beta:** This package is in beta; APIs may change.
+
+`@typed/vite-plugin` provides a **one-stop Vite preset**: tsconfig path resolution, virtual modules (router + HttpApi from @typed/app), optional bundle analyzer, and Brotli compression. Use it as the main plugin array for typed-smol Vite projects.
+
+## Purpose
+
+`typedVitePlugin` is the recommended way to configure Vite for typed-smol apps. One call gives you: path resolution from `tsconfig.json`, virtual `router:` and `api:` imports that generate typed route matchers and API clients from convention-based source, optional bundle analysis, and Brotli compression for build output.
+
+## Capabilities
+
+| Area | What you get |
+|------|--------------|
+| **Router VM** | `router:./path` → typed Matcher from route files |
+| **HttpApi VM** | `api:./path` → typed Api + Client + OpenAPI (when `apiVmOptions` set) |
+| **TypeInfo** | Structural type-checking of route/endpoint contracts (when `createTypeInfoApiSession` provided) |
+| **tsconfig paths** | Path alias resolution (default: on) |
+| **Analyzer** | `dist/stats.html` treemap when `ANALYZE=1` |
+| **Compression** | Brotli `.br` for build output (default: on) |
+
+## Architecture
+
+```mermaid
+flowchart TB
+  subgraph plugins [Plugin array from typedVitePlugin]
+    Tsconfig[tsconfig paths]
+    VM[virtualModulesVitePlugin]
+    Viz[visualizer]
+    Comp[viteCompression]
+  end
+  subgraph vmResolver [VM resolver]
+    RouterVM[router VM]
+    ApiVM[HttpApi VM]
+  end
+  VM --> vmResolver
+```
+
+## Dependencies
+
+- `@typed/app`
+- `@typed/virtual-modules`
+- `@typed/virtual-modules-vite`
+
+Peer: `vite` (>=5).
+
+## Installation
+
+```bash
+pnpm add @typed/vite-plugin @typed/app
+```
+
+## Usage
+
+```ts
+import { defineConfig } from "vite";
+import { typedVitePlugin } from "@typed/vite-plugin";
+
+export default defineConfig({
+  plugins: typedVitePlugin(),
+});
+```
+
+For router VM type-checking, pass `createTypeInfoApiSession` (e.g. from a custom Vite plugin that builds a TypeScript program):
+
+```ts
+import { typedVitePlugin } from "@typed/vite-plugin";
+import { createTypeInfoApiSessionForApp } from "@typed/app";
+
+export default defineConfig({
+  plugins: typedVitePlugin({
+    createTypeInfoApiSession: ({ ts, program }) =>
+      createTypeInfoApiSessionForApp({ ts, program }),
+    routerVmOptions: {},
+    apiVmOptions: {},
+  }),
+});
+```
+
+## API overview
+
+- **`typedVitePlugin(options)`** — Returns an array of Vite plugins.
+- **`createTypedViteResolver(options)`** — Builds the virtual-module resolver (for tests or custom compositions).
+
+## Options
+
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `routerVmOptions` | `RouterVirtualModulePluginOptions` | `{}` | Options for the router VM plugin. |
+| `apiVmOptions` | `HttpApiVirtualModulePluginOptions` | — | When set, enables the HttpApi VM plugin. |
+| `createTypeInfoApiSession` | `CreateTypeInfoApiSession` | — | Required for router VM type-checking in dev. |
+| `tsconfig` | `string` | — | Path to `tsconfig.json` (relative to cwd or absolute). When set, both the Language Service session and vite-tsconfig-paths use this tsconfig. Default: auto-discovered from project root. |
+| `tsconfigPaths` | `boolean \| object` | `true` | Enable tsconfig path resolution. |
+| `analyze` | `boolean \| object` | `process.env.ANALYZE === '1'` | Enable bundle analyzer (dist/stats.html). |
+| `warnOnError` | `boolean` | `true` | Log virtual module resolution errors. |
+| `compression` | `boolean \| object` | `true` | Brotli compression for build output. |
+

package/dist/debugBuildPlugin.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Debug plugin for tracing build failures. Enabled when DEBUG_TYPED_BUILD=1.
+ * Logs config resolution and module resolution to diagnose realworld/counter build issues.
+ */
+import type { Plugin } from "vite";
+export declare function createDebugBuildPlugin(): Plugin;
+//# sourceMappingURL=debugBuildPlugin.d.ts.map

package/dist/debugBuildPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugBuildPlugin.d.ts","sourceRoot":"","sources":["../src/debugBuildPlugin.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAsBnC,wBAAgB,sBAAsB,IAAI,MAAM,CAmC/C"}

package/dist/debugBuildPlugin.js

@@ -0,0 +1,54 @@
+const LOG_URL = "http://127.0.0.1:7563/ingest/ae4c829f-512d-4a3a-9ef6-9b34461b49d9";
+const SESSION = "d02fd1";
+function log(msg, data, hypothesisId) {
+    // #region agent log
+    fetch(LOG_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-Debug-Session-Id": SESSION },
+        body: JSON.stringify({
+            sessionId: SESSION,
+            location: "debugBuildPlugin.ts",
+            message: msg,
+            data,
+            timestamp: Date.now(),
+            hypothesisId,
+        }),
+    }).catch(() => { });
+    // #endregion
+}
+export function createDebugBuildPlugin() {
+    return {
+        name: "typed:debug-build",
+        enforce: "pre",
+        config(config) {
+            // #region agent log
+            log("config() received", { hasBuild: !!config.build, hasRoot: !!config.root, base: config.base }, "H-counter-1");
+            // #endregion
+            return null;
+        },
+        configResolved(viteConfig) {
+            // #region agent log
+            log("configResolved", {
+                root: viteConfig.root,
+                base: viteConfig.base,
+                outDir: viteConfig.build?.outDir,
+                rollupInput: viteConfig.build?.rollupOptions?.input,
+                assetsDir: viteConfig.build?.assetsDir,
+            }, "H-counter-2");
+            // #endregion
+        },
+        resolveId(id, importer) {
+            if (id.includes("virtual-modules") || id.includes("@typed/virtual-modules")) {
+                // #region agent log
+                log("resolveId: virtual-modules requested", { id, importer: importer?.slice(-120) }, "H-realworld-1");
+                // #endregion
+            }
+            if (importer && importer.includes("node_modules/@typed/app") && !id.startsWith(".") && !id.startsWith("/")) {
+                // #region agent log
+                log("resolveId: from @typed/app", { id: id.slice(0, 80), importer: importer.slice(-100) }, "H-realworld-2");
+                // #endregion
+            }
+            return null;
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,5 +1,72 @@
-import typed from './vite-plugin.js';
-export default typed;
-export * from './vite-plugin.js';
-export { resolveTypedConfig } from './resolveTypedConfig.js';
+import { HttpApiVirtualModulePluginOptions, RouterVirtualModulePluginOptions } from "@typed/app";
+import type { CreateTypeInfoApiSession, VirtualModuleResolver } from "@typed/virtual-modules";
+import type { Plugin } from "vite";
+/** Options for vite-plugin-compression when compression is enabled. */
+export type TypedViteCompressionOptions = boolean | {
+    readonly algorithm?: "gzip" | "brotliCompress" | "deflate" | "deflateRaw";
+    readonly ext?: string;
+    readonly threshold?: number;
+    readonly [key: string]: unknown;
+};
+export interface TypedVitePluginOptions {
+    /**
+     * Options for the router VM plugin from @typed/app.
+     */
+    readonly routerVmOptions?: RouterVirtualModulePluginOptions;
+    /**
+     * Options for the HttpApi VM plugin from @typed/app. HttpApi VM plugin is always
+     * registered (router first, then HttpApi). Use this to customize its behavior.
+     */
+    readonly apiVmOptions?: HttpApiVirtualModulePluginOptions;
+    /**
+     * Session factory for TypeInfo API. When not provided, a Language Service-backed
+     * session is auto-created from the project's tsconfig (evolves as files change).
+     * Override for custom session setup.
+     */
+    readonly createTypeInfoApiSession?: CreateTypeInfoApiSession;
+    /**
+     * Path to tsconfig.json (relative to cwd or absolute). When set, both the
+     * Language Service session and vite-tsconfig-paths use this tsconfig.
+     * Default: auto-discovered from project root.
+     */
+    readonly tsconfig?: string;
+    /**
+     * Enable tsconfig path resolution. Default true.
+     */
+    readonly tsconfigPaths?: boolean | Record<string, unknown>;
+    /**
+     * Enable bundle analyzer. Default: process.env.ANALYZE === '1'.
+     */
+    readonly analyze?: boolean | {
+        filename?: string;
+        open?: boolean;
+        template?: string;
+    };
+    /**
+     * When true, virtual module resolution errors are logged. Default true.
+     */
+    readonly warnOnError?: boolean;
+    /**
+     * Enable Brotli compression for build. Default true.
+     * Set false to disable, or pass options to customize (algorithm, ext, threshold).
+     */
+    readonly compression?: TypedViteCompressionOptions;
+}
+/** Optional dependency injection for createTypedViteResolver (e.g. for tests). */
+export interface TypedViteResolverDependencies {
+    createHttpApiVirtualModulePlugin?: (opts: HttpApiVirtualModulePluginOptions) => import("@typed/virtual-modules").VirtualModulePlugin;
+}
+/**
+ * Invariant: ALL @typed/app VM plugins are always registered. There are no optional
+ * or conditional app plugins. When adding a new VM plugin to @typed/app, add it here.
+ */
+export declare function createTypedViteResolver(options?: TypedVitePluginOptions, dependencies?: TypedViteResolverDependencies): VirtualModuleResolver;
+/**
+ * Returns Vite plugins: tsconfig paths, virtual modules (@typed/app), and optional bundle analyzer.
+ * Use as: `defineConfig({ plugins: typedVitePlugin() })`.
+ *
+ * When called with no arguments, auto-discovers `typed.config.ts` in the project root.
+ * When called with explicit options, those take full precedence (config file is not loaded).
+ */
+export declare function typedVitePlugin(options?: TypedVitePluginOptions): Plugin[];
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,kBAAkB,CAAA;AAEpC,eAAe,KAAK,CAAA;AAEpB,cAAc,kBAAkB,CAAA;AAEhC,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAGL,iCAAiC,EAEjC,gCAAgC,EACjC,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAW9F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAInC,uEAAuE;AACvE,MAAM,MAAM,2BAA2B,GACnC,OAAO,GACP;IACE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,GAAG,YAAY,CAAC;IAC1E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC,CAAC;AAEN,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,gCAAgC,CAAC;IAE5D;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iCAAiC,CAAC;IAE1D;;;;OAIG;IACH,QAAQ,CAAC,wBAAwB,CAAC,EAAE,wBAAwB,CAAC;IAE7D;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE3B;;OAEG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE3D;;OAEG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAEtF;;OAEG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAE/B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,2BAA2B,CAAC;CACpD;AAED,kFAAkF;AAClF,MAAM,WAAW,6BAA6B;IAC5C,gCAAgC,CAAC,EAAE,CACjC,IAAI,EAAE,iCAAiC,KACpC,OAAO,wBAAwB,EAAE,mBAAmB,CAAC;CAC3D;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,GAAE,sBAA2B,EACpC,YAAY,CAAC,EAAE,6BAA6B,GAC3C,qBAAqB,CAQvB;AAgBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,MAAM,EAAE,CAgG1E"}

package/dist/index.js

@@ -1,5 +1,122 @@
-import typed from './vite-plugin.js';
-export default typed;
-export * from './vite-plugin.js';
-export { resolveTypedConfig } from './resolveTypedConfig.js';
-//# sourceMappingURL=index.js.map
+import { createHttpApiVirtualModulePlugin, createRouterVirtualModulePlugin, loadTypedConfig, } from "@typed/app";
+import { collectTypeTargetSpecsFromPlugins, createLanguageServiceSessionFactory, PluginManager, } from "@typed/virtual-modules";
+import { virtualModulesVitePlugin } from "@typed/virtual-modules-vite";
+import { dirname, relative, resolve } from "node:path";
+import process from "node:process";
+import { visualizer } from "rollup-plugin-visualizer";
+import ts from "typescript";
+import viteCompression from "vite-plugin-compression";
+import tsconfigPaths from "vite-tsconfig-paths";
+/**
+ * Invariant: ALL @typed/app VM plugins are always registered. There are no optional
+ * or conditional app plugins. When adding a new VM plugin to @typed/app, add it here.
+ */
+export function createTypedViteResolver(options = {}, dependencies) {
+    const httpApiFactory = dependencies?.createHttpApiVirtualModulePlugin ?? createHttpApiVirtualModulePlugin;
+    const plugins = [
+        createRouterVirtualModulePlugin(options.routerVmOptions ?? {}),
+        httpApiFactory(options.apiVmOptions ?? {}),
+    ];
+    return new PluginManager(plugins);
+}
+function optionsFromTypedConfig(config) {
+    return {
+        routerVmOptions: config.router ? { prefix: config.router.prefix } : undefined,
+        apiVmOptions: config.api
+            ? { prefix: config.api.prefix, pathPrefix: config.api.pathPrefix }
+            : undefined,
+        tsconfig: config.tsconfig,
+        tsconfigPaths: config.tsconfigPaths,
+        analyze: config.analyze,
+        warnOnError: config.warnOnError,
+        compression: config.compression,
+    };
+}
+/**
+ * Returns Vite plugins: tsconfig paths, virtual modules (@typed/app), and optional bundle analyzer.
+ * Use as: `defineConfig({ plugins: typedVitePlugin() })`.
+ *
+ * When called with no arguments, auto-discovers `typed.config.ts` in the project root.
+ * When called with explicit options, those take full precedence (config file is not loaded).
+ */
+export function typedVitePlugin(options) {
+    const resolvedOptions = (() => {
+        if (options)
+            return options;
+        const result = loadTypedConfig({ projectRoot: process.cwd(), ts });
+        if (result.status === "loaded")
+            return optionsFromTypedConfig(result.config);
+        return {};
+    })();
+    const resolver = createTypedViteResolver(resolvedOptions);
+    const analyze = resolvedOptions.analyze ?? (process.env.ANALYZE === "1" ? true : false);
+    let createTypeInfoApiSession = resolvedOptions.createTypeInfoApiSession;
+    if (createTypeInfoApiSession === undefined) {
+        try {
+            const manager = resolver;
+            const typeTargetSpecs = collectTypeTargetSpecsFromPlugins(manager.plugins);
+            const cwd = process.cwd();
+            const tsconfigPath = resolvedOptions.tsconfig
+                ? resolve(cwd, resolvedOptions.tsconfig)
+                : undefined;
+            const projectRoot = tsconfigPath ? dirname(tsconfigPath) : cwd;
+            createTypeInfoApiSession = createLanguageServiceSessionFactory({
+                ts,
+                projectRoot,
+                typeTargetSpecs,
+                tsconfigPath,
+            });
+        }
+        catch {
+            // Graceful degradation: no session, plugins get noop TypeInfoApi
+        }
+    }
+    const plugins = [];
+    if (resolvedOptions.tsconfigPaths !== false) {
+        const basePathsOpts = typeof resolvedOptions.tsconfigPaths === "object" ? resolvedOptions.tsconfigPaths : {};
+        const cwd = process.cwd();
+        const resolvedTsconfig = resolvedOptions.tsconfig
+            ? resolve(cwd, resolvedOptions.tsconfig)
+            : undefined;
+        const pathsOpts = resolvedTsconfig !== undefined
+            ? {
+                ...basePathsOpts,
+                root: cwd,
+                projects: [relative(cwd, resolvedTsconfig)],
+            }
+            : basePathsOpts;
+        plugins.push(tsconfigPaths(pathsOpts));
+    }
+    plugins.push(virtualModulesVitePlugin({
+        resolver,
+        createTypeInfoApiSession,
+        warnOnError: resolvedOptions.warnOnError ?? true,
+    }));
+    if (analyze) {
+        const vizOpts = typeof analyze === "object"
+            ? analyze
+            : { filename: "dist/stats.html", template: "treemap" };
+        plugins.push(visualizer({
+            filename: vizOpts.filename ?? "dist/stats.html",
+            open: vizOpts.open ?? false,
+            template: vizOpts.template ?? "treemap",
+        }));
+    }
+    const compression = resolvedOptions.compression ?? true;
+    if (compression !== false) {
+        const compressionOpts = typeof compression === "object"
+            ? {
+                algorithm: "brotliCompress",
+                ext: ".br",
+                threshold: 1024,
+                ...compression,
+            }
+            : {
+                algorithm: "brotliCompress",
+                ext: ".br",
+                threshold: 1024,
+            };
+        plugins.push(viteCompression(compressionOpts));
+    }
+    return plugins;
+}

package/package.json

@@ -1,42 +1,40 @@
 {
   "name": "@typed/vite-plugin",
-  "version": "0.17.1",
+  "version": "1.0.0-beta.2",
   "type": "module",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "typings": "dist/index.d.ts",
-  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/cjs/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./*": {
-      "import": "./dist/*.js",
-      "require": "./dist/cjs/*.js",
-      "types": "./dist/*.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
-    "@effect/data": "^0.17.6",
-    "@typed/virtual-module": "0.1.2",
-    "fast-glob": "^3.3.1",
-    "rollup-plugin-visualizer": "^5.9.2",
-    "vavite": "^2.0.2",
-    "vite": "^4.4.9",
+    "rollup-plugin-visualizer": "^5.12.0",
     "vite-plugin-compression": "^0.5.1",
-    "vite-tsconfig-paths": "^4.2.0"
+    "vite-tsconfig-paths": "^6.1.0",
+    "@typed/app": "1.0.0-beta.2",
+    "@typed/virtual-modules-vite": "1.0.0-beta.2",
+    "@typed/virtual-modules": "1.0.0-beta.2"
   },
-  "peerDependencies": {
-    "vite-node": "^0.28.3"
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "typescript": "5.9.3",
+    "vite": "^7.3.1",
+    "vitest": "4.0.18"
   },
-  "gitHead": "8cba441523534aa1bd327bd84eb0e71334bb914e",
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "typescript": ">=5.0.0",
+    "vite": ">=5.0.0"
   },
-  "sideEffects": false,
-  "devDependencies": {
-    "@types/node": "^20.5.6"
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "[ -d dist ] || rm -f tsconfig.tsbuildinfo; tsc",
+    "test": "vitest run --passWithNoTests"
   }
-}
+}

package/src/index.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Tests for typedVitePlugin and createTypedViteResolver: plugin order and options pass-through.
+ * See .docs/specs/httpapi-virtual-module-plugin/spec.md (Vite Plugin Integration Surface)
+ * and testing-strategy.md (typedVitePlugin registration order and option wiring).
+ */
+import { describe, expect, it } from "vitest";
+import { PluginManager } from "@typed/virtual-modules";
+import type { VirtualModulePlugin } from "@typed/virtual-modules";
+import {
+  createTypedViteResolver,
+  typedVitePlugin,
+  type HttpApiVirtualModulePluginOptions,
+} from "./index.js";
+
+function fakeHttpApiPlugin(opts: HttpApiVirtualModulePluginOptions): VirtualModulePlugin {
+  return {
+    name: "httpapi-virtual-module",
+    shouldResolve: () => false,
+    build: () => "",
+    _testOpts: opts,
+  } as VirtualModulePlugin & { _testOpts: HttpApiVirtualModulePluginOptions };
+}
+
+describe("createTypedViteResolver", () => {
+  it("always registers router and HttpApi VM plugins", () => {
+    const resolver = createTypedViteResolver({});
+    expect(resolver).toBeInstanceOf(PluginManager);
+    const manager = resolver as PluginManager;
+    expect(manager.plugins).toHaveLength(2);
+    expect(manager.plugins[0].name).toBe("router-virtual-module");
+    expect(manager.plugins[1].name).toBe("httpapi-virtual-module");
+  });
+
+  it("uses DI override for HttpApi plugin when provided", () => {
+    const resolver = createTypedViteResolver(
+      { apiVmOptions: { prefix: "api:" } },
+      { createHttpApiVirtualModulePlugin: fakeHttpApiPlugin },
+    );
+    const manager = resolver as PluginManager;
+    expect(manager.plugins).toHaveLength(2);
+    expect(manager.plugins[0].name).toBe("router-virtual-module");
+    expect(manager.plugins[1].name).toBe("httpapi-virtual-module");
+    const apiPlugin = manager.plugins[1] as VirtualModulePlugin & {
+      _testOpts: HttpApiVirtualModulePluginOptions;
+    };
+    expect(apiPlugin._testOpts).toEqual({ prefix: "api:" });
+  });
+
+  it("passes apiVmOptions through to createHttpApiVirtualModulePlugin", () => {
+    const opts: HttpApiVirtualModulePluginOptions = { custom: "value", count: 1 };
+    const resolver = createTypedViteResolver(
+      { apiVmOptions: opts },
+      { createHttpApiVirtualModulePlugin: fakeHttpApiPlugin },
+    );
+    const manager = resolver as PluginManager;
+    const apiPlugin = manager.plugins[1] as VirtualModulePlugin & {
+      _testOpts: HttpApiVirtualModulePluginOptions;
+    };
+    expect(apiPlugin._testOpts).toEqual(opts);
+  });
+
+  it("uses routerVmOptions for the router plugin", () => {
+    const resolver = createTypedViteResolver({
+      routerVmOptions: { prefix: "routes:", name: "custom-router" },
+    });
+    const manager = resolver as PluginManager;
+    expect(manager.plugins).toHaveLength(2);
+    expect(manager.plugins[0].name).toBe("custom-router");
+    expect(manager.plugins[1].name).toBe("httpapi-virtual-module");
+  });
+});
+
+describe("typedVitePlugin", () => {
+  it("returns a non-empty plugin array", () => {
+    const plugins = typedVitePlugin();
+    expect(Array.isArray(plugins)).toBe(true);
+    expect(plugins.length).toBeGreaterThan(0);
+  });
+
+  it("returns virtual-modules plugin with resolveId and load", () => {
+    const plugins = typedVitePlugin({ tsconfigPaths: false, compression: false });
+    const virtualPlugin = plugins.find(
+      (p) => p && typeof p === "object" && "name" in p && (p as { name?: string }).name === "virtual-modules",
+    );
+    expect(virtualPlugin).toBeDefined();
+  });
+
+  it("auto-creates LS-backed session when createTypeInfoApiSession is not provided", () => {
+    const plugins = typedVitePlugin({ tsconfigPaths: false, compression: false });
+    const virtualPlugin = plugins.find(
+      (p) => p && typeof p === "object" && "name" in p && (p as { name?: string }).name === "virtual-modules",
+    );
+    expect(virtualPlugin).toBeDefined();
+    expect(virtualPlugin).toHaveProperty("resolveId");
+    expect(virtualPlugin).toHaveProperty("load");
+  });
+});