@gtkx/config 2.0.0-beta.1 → 2.0.0-beta.10

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@gtkx/config",
-  "version": "2.0.0-beta.1",
-  "description": "Config schema, loader, and element-prop mapping for the GTK toolchain.",
+  "version": "2.0.0-beta.10",
+  "description": "Configuration and element-prop mapping for Adwaita-first GTKX apps.",
   "keywords": [
     "gtkx",
     "gtk",
     "gtk4",
+    "adwaita",
+    "gnome",
     "react",
     "typescript",
     "config",
@@ -64,9 +66,10 @@
     "node": ">=26.7.0"
   },
   "dependencies": {
-    "@gtkx/utils": "2.0.0-beta.1",
+    "@gtkx/utils": "2.0.0-beta.10",
     "c12": "^3.3.4",
     "defu": "^6.1.7",
+    "jiti": "^2.7.0",
     "vite": "^8.2.2",
     "zod": "^4.5.4"
   },

package/src/config-dependencies.ts

@@ -0,0 +1,114 @@
+import { createJiti, type Jiti, type TransformOptions, type TransformResult } from "jiti";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createRequire, registerHooks } from "node:module";
+import { extname, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+type CaptureState = { cacheKey: string; dependencies: Set<string>; transformer: Jiti };
+type CapturedConfig<T> = { dependencies: string[]; value: T };
+
+const captureStorage: AsyncLocalStorage<CaptureState> = new AsyncLocalStorage();
+const dependenciesByValue: WeakMap<object, string[]> = new WeakMap();
+const CACHE_BUSTED_EXTENSIONS: ReadonlySet<string> = new Set([".cjs", ".js", ".json", ".mjs"]);
+
+const isTrackedPath = (path: string): boolean => !path.includes(`${sep}node_modules${sep}`);
+
+const addPath = (path: string): void => {
+    if (isTrackedPath(path)) {
+        captureStorage.getStore()?.dependencies.add(path);
+    }
+};
+
+const addUrl = (url: string): void => {
+    if (url.startsWith("file:")) {
+        addPath(fileURLToPath(url));
+    }
+};
+
+const cacheBustedUrl = (url: string): string => {
+    if (!url.startsWith("file:")) {
+        return url;
+    }
+
+    const path = fileURLToPath(url);
+
+    if (!isTrackedPath(path) || !CACHE_BUSTED_EXTENSIONS.has(extname(path))) {
+        return url;
+    }
+
+    const parsed = new URL(url);
+    parsed.searchParams.set("gtkx-config-load", captureStorage.getStore()?.cacheKey ?? "uncaptured");
+
+    return parsed.href;
+};
+
+const registerResolutionHook = (): ReturnType<typeof registerHooks> =>
+    registerHooks({
+        resolve(specifier, context, nextResolve) {
+            const result = nextResolve(specifier, context);
+            addUrl(result.url);
+
+            return { ...result, url: cacheBustedUrl(result.url) };
+        },
+    });
+
+const clearNativeModuleCache = (dependencies: Iterable<string>): void => {
+    const cache = createRequire(import.meta.url).cache;
+
+    for (const path of dependencies) {
+        Reflect.deleteProperty(cache, path);
+    }
+};
+
+const transformConfigModule = (options: TransformOptions): TransformResult => {
+    const state = captureStorage.getStore();
+
+    if (state === undefined) {
+        throw new Error("Configuration transformation started outside a dependency capture");
+    }
+
+    if (options.filename !== undefined) {
+        addPath(options.filename);
+    }
+
+    return { code: state.transformer.transform(options) };
+};
+
+const setConfigDependencies = (value: object, dependencies: Iterable<string>): void => {
+    const paths = [...new Set(dependencies)];
+    dependenciesByValue.set(value, paths);
+    clearNativeModuleCache(paths);
+};
+
+const configDependenciesFor = (value: unknown): string[] =>
+    typeof value === "object" && value !== null ? dependenciesByValue.get(value) ?? [] : [];
+
+const captureConfigDependencies = async <T>(operation: () => Promise<T>): Promise<CapturedConfig<T>> => {
+    const state: CaptureState = {
+        cacheKey: process.hrtime.bigint().toString(),
+        dependencies: new Set(),
+        transformer: createJiti(import.meta.url, { fsCache: false, moduleCache: false }),
+    };
+    const hook = registerResolutionHook();
+
+    try {
+        const value = await captureStorage.run(state, operation);
+
+        return { dependencies: [...state.dependencies], value };
+    } catch (error) {
+        if (typeof error === "object" && error !== null) {
+            setConfigDependencies(error, state.dependencies);
+        }
+
+        throw error;
+    } finally {
+        hook.deregister();
+    }
+};
+
+export {
+    captureConfigDependencies,
+    configDependenciesFor,
+    setConfigDependencies,
+    transformConfigModule,
+};

package/src/config-error.ts

@@ -1,13 +1,18 @@
 import { z } from "zod";
 
-const CONFIG_PREFIX = "gtkx.config.ts:";
+const DEFAULT_CONFIG_FILE = "gtkx.config.*";
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
     typeof value === "object" && value !== null && !Array.isArray(value);
 
-const missingConfigFileError = (cwd: string): Error =>
-    new Error(`${CONFIG_PREFIX} no configuration file found in ${cwd}`);
+const configPrefix = (configFile: string): string => `${configFile}:`;
 
-const configError = (error: z.ZodError): Error => new Error(`${CONFIG_PREFIX}\n${z.prettifyError(error)}`);
+const missingConfigFileError = (cwd: string, configFile?: string): Error =>
+    new Error(configFile === undefined
+        ? `${configPrefix(DEFAULT_CONFIG_FILE)} no configuration file found in ${cwd}`
+        : `${configPrefix(configFile)} no configuration file found in ${cwd}`);
+
+const configError = (error: z.ZodError, configFile = DEFAULT_CONFIG_FILE): Error =>
+    new Error(`${configPrefix(configFile)}\n${z.prettifyError(error)}`);
 
 export { isRecord, missingConfigFileError, configError };

package/src/config.ts

@@ -58,15 +58,15 @@ type ResolvedConfig = {
 
 const APPLICATION_ID_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]*(\.[A-Za-z_][A-Za-z0-9_-]*)+$/;
 const APPLICATION_ID_MAX_LENGTH = 255;
-const DEFAULT_LIBRARIES: Set<string> = new Set(["Gtk-4.0", "Adw-1"]);
+const IMPLICIT_LIBRARIES: Set<string> = new Set(["Adw-1", "Gtk-4.0"]);
 /** Compilation modes `babel-plugin-react-compiler` accepts. */
 const COMPILATION_MODES = ["infer", "syntax", "annotation", "all"] as const;
 /** Panic thresholds `babel-plugin-react-compiler` accepts. */
 const PANIC_THRESHOLDS = ["none", "critical_errors", "all_errors"] as const;
 const REACT_COMPILER_TARGET = "19";
 
-const librarySchema = girLibrary('must be of the form "Name-Version", such as "Gtk-4.0"')
-    .refine((library) => !DEFAULT_LIBRARIES.has(library), { error: "is bound by default; remove it" });
+const librarySchema = girLibrary('must be of the form "Name-Version", such as "Adw-1"')
+    .refine((library) => !IMPLICIT_LIBRARIES.has(library), { error: "is bound implicitly; remove it" });
 
 const librariesSchema = z
     .array(librarySchema, { error: "must be a non-empty string array or omitted" })
@@ -201,11 +201,11 @@ const resolveReactCompilerOptions = (setting: Config["reactCompiler"]): Resolved
     };
 };
 
-const validateConfig = (config: unknown): void => {
+const validateConfig = (config: unknown, configFile?: string): void => {
     const result = validationSchema.safeParse(config);
 
     if (!result.success) {
-        throw configError(result.error);
+        throw configError(result.error, configFile);
     }
 };
 

package/src/deploy.ts

@@ -14,6 +14,7 @@ const APPIMAGE_COMPRESSIONS = ["gzip", "xz", "zstd"] as const;
 const DEB_COMPRESSIONS = ["gzip", "none", "xz", "zstd"] as const;
 const DEB_SIGN_METHODS = ["debsign", "dpkg-sig"] as const;
 const DEB_SIGN_TYPES = ["archive", "maint", "origin"] as const;
+const DEPLOY_ARCH_NAMES = ["arm64", "x64"] as const;
 const DEPLOY_TARGET_NAMES = ["appimage", "deb", "flatpak", "rpm"] as const;
 const FLATPAK_MODES = ["prebuilt", "source"] as const;
 const NODE_SOURCES = ["download", "host", "path"] as const;
@@ -37,16 +38,22 @@ const URL_KINDS = [
 const BOOLEAN_ERROR = "must be a boolean";
 const EPOCH_ERROR = "must be a non-negative integer";
 const EXTRA_FILE_ERROR = "must be a source path or a { source, mode } entry";
-const FILE_MODE_ERROR = "must be an octal file mode such as 755";
+const FILE_MODE_ERROR = "must be an octal file mode without setuid or setgid bits, such as 755";
 const FILE_MODE_PATTERN = /^[0-7]{3,4}$/;
+const FILE_MODE_RADIX = 8;
+const PRIVILEGED_FILE_MODE_MASK = 0o6000;
 const HEX_COLOR_ERROR = "must be a #rrggbb color";
 const HEX_COLOR_PATTERN = /^#[\dA-Fa-f]{6}$/;
 const KEY_FILE_ERROR = "must be a path to a PGP key file";
 const KEY_ID_ERROR = "must be a PGP key id";
+const LAUNCHER_ENV_ERROR = "must be a record of POSIX environment names to values without null bytes";
+const LAUNCHER_ENV_NAME_ERROR = "must be a POSIX environment name";
+const LAUNCHER_ENV_NAME_PATTERN = /^[A-Za-z_]\w*$/;
 const MINIMUM_LIBRARY_VERSION_ERROR = "must be a version such as 4.18";
 const MINIMUM_LIBRARY_VERSION_PATTERN = /^\d+(?:\.\d+)*$/;
 const MINIMUM_LIBRARY_VERSIONS_ERROR = "must be a record of GIR library ids to a minimum version";
-const LIBRARY_ID_ERROR = 'must be a GIR library identifier of the form "Name-Version", such as "Gtk-4.0"';
+const NODE_FLAG_ERROR = "must be a Node.js flag beginning with a hyphen and containing no null bytes";
+const LIBRARY_ID_ERROR = 'must be a GIR library identifier of the form "Name-Version", such as "Adw-1"';
 const SCRIPT_ERROR = "must be a path to a shell script";
 const SOURCE_PATH_ERROR = "must be a source path";
 const SPDX_ERROR = "must be an SPDX license expression";
@@ -110,14 +117,53 @@ const brandingSchema = z.strictObject({
     dark: hexColorSchema,
 });
 
-const extraFileSchema = z.strictObject({
+/**
+ * A `deploy.extraFiles` entry in object form: the source file, resolved against the project root, that is
+ * installed at the entry's prefix-relative destination, and the octal mode it is installed with.
+ */
+type DeployExtraFileOptions = Record<"source", string> & {
+    /** Octal file mode. Setuid and setgid bits are rejected. */
+    mode?: string | undefined;
+};
+const extraFileSchema: z.ZodType<DeployExtraFileOptions> = z.strictObject({
     source: text(SOURCE_PATH_ERROR),
-    mode: z.string({ error: FILE_MODE_ERROR }).regex(FILE_MODE_PATTERN, { error: FILE_MODE_ERROR }).optional(),
+    mode: z
+        .string({ error: FILE_MODE_ERROR })
+        .regex(FILE_MODE_PATTERN, { error: FILE_MODE_ERROR })
+        .refine((mode) => (Number.parseInt(mode, FILE_MODE_RADIX) & PRIVILEGED_FILE_MODE_MASK) === 0, {
+            error: FILE_MODE_ERROR,
+        })
+        .optional(),
 });
 
 const extraFileEntrySchema = z.union([text(SOURCE_PATH_ERROR), extraFileSchema], { error: EXTRA_FILE_ERROR });
 
-const nodeRuntimeSchema = z.strictObject({
+const launcherEnvSchema = z.record(
+    z.string({ error: LAUNCHER_ENV_NAME_ERROR }).regex(LAUNCHER_ENV_NAME_PATTERN, { error: LAUNCHER_ENV_NAME_ERROR }),
+    z.string({ error: LAUNCHER_ENV_ERROR }).refine((value) => !value.includes("\0"), { error: LAUNCHER_ENV_ERROR }),
+    { error: (issue) => issue.code === "invalid_key" ? LAUNCHER_ENV_NAME_ERROR : LAUNCHER_ENV_ERROR },
+);
+
+const nodeFlagsSchema = z.array(
+    z
+        .string({ error: NODE_FLAG_ERROR })
+        .refine((value) => value.startsWith("-") && !value.includes("\0"), { error: NODE_FLAG_ERROR }),
+    { error: "must be an array of Node.js flags" },
+);
+
+/**
+ * The `deploy.node` options: where the Node.js runtime bundled with the application comes from, the version it
+ * is expected to be, whether its binary is stripped, and whether the launcher enables the compile cache.
+ */
+type DeployNodeOptions = Partial<
+    Record<"source", "download" | "host" | "path" | undefined> &
+    Record<"path", string | undefined> &
+    Record<"shouldStrip" | "shouldUseCompileCache", boolean | undefined>
+> & {
+    /** Expected Node.js version. Downloaded runtimes default to exactly 26.7.0 when omitted. */
+    version?: string | undefined;
+};
+const nodeRuntimeSchema: z.ZodType<DeployNodeOptions> = z.strictObject({
     source: z.enum(NODE_SOURCES, { error: "must be one of download, host, path" }).optional(),
     version: text("must be a Node.js version such as 26.7.0").optional(),
     path: text("must be a path to a node binary").optional(),
@@ -229,6 +275,11 @@ const deploySchema = z.strictObject({
             error: "must be an array of deploy targets",
         })
         .optional(),
+    architectures: z
+        .array(z.enum(DEPLOY_ARCH_NAMES, { error: "must be one of arm64, x64" }), {
+            error: "must be an array of deploy architectures",
+        })
+        .optional(),
     outDir: text("must be a directory path relative to the project root").optional(),
     name: text("must be the display name shown in the launcher").optional(),
     genericName: text("must be a generic application name").optional(),
@@ -262,6 +313,8 @@ const deploySchema = z.strictObject({
         .optional(),
     releases: z.array(releaseSchema, { error: "must be an array of releases" }).optional(),
     execArgs: textList("argument", "must be an array of arguments appended to Exec").optional(),
+    launcherEnv: launcherEnvSchema.optional(),
+    nodeFlags: nodeFlagsSchema.optional(),
     fileAssociations: z
         .array(fileAssociationSchema, { error: "must be an array of file associations" })
         .optional(),
@@ -271,6 +324,7 @@ const deploySchema = z.strictObject({
         .optional(),
     desktopEntry: textRecord("must be a desktop entry value", "must be a record of desktop entry keys to values")
         .optional(),
+    metainfoExtra: textList("AppStream XML fragment", "must be an array of AppStream XML fragments").optional(),
     isDbusActivatable: flag(BOOLEAN_ERROR).optional(),
     extraFiles: relativePathRecord(
         "must be a destination path inside the install prefix, without a leading slash or a .. segment",
@@ -289,4 +343,4 @@ const deploySchema = z.strictObject({
     rpm: rpmSchema.optional(),
 });
 
-export { deploySchema };
+export { deploySchema, type DeployExtraFileOptions, type DeployNodeOptions };

package/src/index.ts

@@ -1,2 +1,3 @@
 export { type Config, defineConfig, mergeConfig, type ResolvedConfig } from "./config.ts";
+export { type DeployExtraFileOptions, type DeployNodeOptions } from "./deploy.ts";
 export { type ConfigLoader, type LoadedConfig, loadConfig } from "./loader.ts";

package/src/internal.ts

@@ -1,3 +1,4 @@
+export { configDependenciesFor } from "./config-dependencies.ts";
 export type { McpSettings, ResolvedReactCompilerOptions } from "./config.ts";
 export {
     APPLICATION_ID_MAX_LENGTH,
@@ -11,4 +12,6 @@ export {
     resolveOmittedProps,
 } from "./config.ts";
 export { createConfigLoader } from "./loader.ts";
+export { assertSupportedNodeVersion, MINIMUM_NODE_VERSION } from "./node-version.ts";
 export { resourceBasePath } from "./resource-base-path.ts";
+export { viteProjectRoot } from "./vite-root.ts";

package/src/loader.ts

@@ -1,7 +1,12 @@
-import { warn } from "@gtkx/utils";
+import { isPathInside, warn } from "@gtkx/utils";
 import { loadConfig as loadConfigFile } from "c12";
 import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { basename, extname, isAbsolute, relative, resolve } from "node:path";
+import {
+    captureConfigDependencies,
+    setConfigDependencies,
+    transformConfigModule,
+} from "./config-dependencies.ts";
 import { missingConfigFileError } from "./config-error.ts";
 import {
     type Config,
@@ -10,6 +15,7 @@ import {
     type ResolvedConfig,
     validateConfig,
 } from "./config.ts";
+import { assertSupportedNodeVersion } from "./node-version.ts";
 
 /** Result of loading a project's `gtkx.config.ts` file. */
 type LoadedConfig = {
@@ -28,7 +34,7 @@ type LoadConfigOptions = {
      * top-level values, and the name is passed to a config authored as a function.
      */
     mode?: string | undefined;
-};
+} & Partial<Record<"configFile", string | undefined>>;
 
 /** Reads a project's configuration once per directory, caching what it loads and what it resolves. */
 type ConfigLoader = {
@@ -41,6 +47,62 @@ type ConfigLoader = {
 const GRADUATED_FUTURE_ENV = "GTKX_GRADUATED_FUTURE_SHOWN";
 const graduatedFutureWarnings: Map<string, string> = new Map();
 
+type ConfigResolutionOptions = { configFile?: string | undefined; cwd?: string | undefined };
+
+const isLocalConfigSource = (source: string): boolean => source.startsWith(".") || isAbsolute(source);
+
+const isDirectoryConfigSource = (source: string): boolean => {
+    const extension = extname(source);
+
+    return extension.length === 0 || extension === basename(source);
+};
+
+const localConfigSourcePath = (source: string, options: ConfigResolutionOptions): string | undefined => {
+    if (source === "." || !isLocalConfigSource(source)) {
+        return undefined;
+    }
+
+    const cwd = options.cwd ?? process.cwd();
+
+    return isDirectoryConfigSource(source)
+        ? resolve(cwd, source, options.configFile ?? "gtkx.config")
+        : resolve(cwd, source);
+};
+
+const rejectMissingLocalConfig = (source: string, options: ConfigResolutionOptions): undefined => {
+    const path = localConfigSourcePath(source, options);
+
+    if (path !== undefined && !existsSync(path)) {
+        throw new Error(`Extended configuration does not exist at ${path}`);
+    }
+};
+
+const withConfigDependencies = <T>(dependencies: string[], operation: () => T): T => {
+    try {
+        return operation();
+    } catch (error) {
+        if (typeof error === "object" && error !== null) {
+            setConfigDependencies(error, dependencies);
+        }
+
+        throw error;
+    }
+};
+
+const selectedConfigFile = (root: string, configured: string | undefined): string | undefined => {
+    if (configured === undefined) {
+        return undefined;
+    }
+
+    const path = resolve(root, configured);
+
+    if (!isPathInside(root, path)) {
+        throw new Error(`Configuration file ${configured} must be inside the project root ${root}`);
+    }
+
+    return relative(root, path);
+};
+
 const warnGraduatedFuture = (config: unknown, root: string): void => {
     const keys = graduatedFutureKeys(config);
     const signature = keys.join(",");
@@ -65,37 +127,59 @@ const warnGraduatedFuture = (config: unknown, root: string): void => {
  * @throws When that directory holds no configuration file, or when the configuration fails validation.
  */
 const loadConfig = async (cwd: string, options: LoadConfigOptions = {}): Promise<LoadedConfig> => {
+    assertSupportedNodeVersion();
     const searched = resolve(cwd);
-
-    const result = await loadConfigFile<Config>({
-        name: "gtkx",
-        cwd: searched,
-        rcFile: false,
-        globalRc: false,
-        packageJson: false,
-        context: { mode: options.mode },
-        ...((options.mode !== undefined) && { envName: options.mode }),
-    });
+    const requestedConfigFile = selectedConfigFile(searched, options.configFile);
+
+    const captured = await captureConfigDependencies(() =>
+        loadConfigFile<Config>({
+            name: "gtkx",
+            cwd: searched,
+            rcFile: false,
+            globalRc: false,
+            packageJson: false,
+            context: { mode: options.mode },
+            jitiOptions: { fsCache: false, transform: transformConfigModule },
+            resolve: rejectMissingLocalConfig,
+            ...(requestedConfigFile !== undefined && { configFile: requestedConfigFile }),
+            ...((options.mode !== undefined) && { envName: options.mode }),
+        }));
+    const result = captured.value;
 
     const configFile = result.configFile;
-
-    if (configFile === undefined || !existsSync(resolve(searched, configFile))) {
-        throw missingConfigFileError(searched);
-    }
-
-    const config = result.config;
     const root = result.cwd ?? searched;
-    validateConfig(config);
-    warnGraduatedFuture(config, root);
-
-    return {
-        config,
-        configFile,
-        root,
-    };
+    const layerFiles = (result.layers ?? [])
+        .flatMap((layer) => layer.configFile === undefined
+            ? []
+            : [resolve(layer.cwd ?? root, layer.configFile)]);
+    const dependencies = [
+        ...(configFile === undefined ? [] : [configFile]),
+        ...layerFiles,
+        ...captured.dependencies,
+    ];
+
+    return withConfigDependencies(dependencies, () => {
+        if (configFile === undefined || !existsSync(resolve(searched, configFile))) {
+            throw missingConfigFileError(searched, requestedConfigFile);
+        }
+
+        const config = result.config;
+        validateConfig(config, configFile);
+        warnGraduatedFuture(config, root);
+
+        const loaded = {
+            config,
+            configFile,
+            root,
+        };
+        setConfigDependencies(loaded, dependencies);
+
+        return loaded;
+    });
 };
 
 const createConfigLoader = (options: LoadConfigOptions = {}): ConfigLoader => {
+    assertSupportedNodeVersion();
     const loaded: Map<string, Promise<LoadedConfig>> = new Map();
     const resolved: Map<string, Promise<ResolvedConfig>> = new Map();
 

package/src/node-version.ts

@@ -0,0 +1,16 @@
+const MINIMUM_NODE_MAJOR = 26;
+const MINIMUM_NODE_MINOR = 7;
+const MINIMUM_NODE_VERSION = "26.7.0";
+
+const assertSupportedNodeVersion = (): void => {
+    const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+    const isSupported = major > MINIMUM_NODE_MAJOR || (major === MINIMUM_NODE_MAJOR && minor >= MINIMUM_NODE_MINOR);
+
+    if (!isSupported) {
+        throw new Error(
+            `GTKX requires Node.js ${MINIMUM_NODE_VERSION} or newer. Current version: ${process.versions.node}.`,
+        );
+    }
+};
+
+export { assertSupportedNodeVersion, MINIMUM_NODE_VERSION };

package/src/vite-plugin.ts

@@ -1,13 +1,17 @@
 import type { Plugin, UserConfig } from "vite";
 import { type ConfigLoader, createConfigLoader } from "./loader.ts";
 import { GTKX_CONFIG_VIRTUAL_ID, renderConfigModule, RESOLVED_GTKX_CONFIG_VIRTUAL_ID } from "./virtual.ts";
+import { viteProjectRoot } from "./vite-root.ts";
 
 /** State the plugin carries from Vite's `config` hook to the virtual module it serves. */
 type PluginState = {
-    /** Project root taken from Vite's `config` hook, undefined when the user config leaves it unset. */
-    root: string | undefined;
+    /** Project root taken from Vite's `config` hook, falling back to the working directory. */
+    root: string;
 };
 
+const VIRTUAL_ID_RE = new RegExp(`^${GTKX_CONFIG_VIRTUAL_ID}$`);
+const RESOLVED_VIRTUAL_ID_RE = new RegExp(`^${RESOLVED_GTKX_CONFIG_VIRTUAL_ID}$`);
+
 const resolveVirtualId = (id: string): string | null =>
     id === GTKX_CONFIG_VIRTUAL_ID ? RESOLVED_GTKX_CONFIG_VIRTUAL_ID : null;
 
@@ -20,7 +24,7 @@ const loadVirtualModule = async (
         return undefined;
     }
 
-    return renderConfigModule(await loadConfig.resolve(state.root ?? process.cwd()));
+    return renderConfigModule(await loadConfig.resolve(state.root));
 };
 
 /**
@@ -36,17 +40,23 @@ const createConfigPlugin = (options: {
     config?: (config: UserConfig) => Omit<UserConfig, "plugins">;
 }): Plugin => {
     const loadConfig = options.loadConfig ?? createConfigLoader();
-    const state: PluginState = { root: undefined };
+    const state: PluginState = { root: process.cwd() };
 
     return {
         name: options.name,
         config(config: UserConfig) {
-            state.root = config.root ?? state.root;
+            state.root = viteProjectRoot(config);
 
             return options.config?.(config);
         },
-        resolveId: (id: string) => resolveVirtualId(id),
-        load: (id: string) => loadVirtualModule(id, loadConfig, state),
+        resolveId: {
+            filter: { id: VIRTUAL_ID_RE },
+            handler: (id: string) => resolveVirtualId(id),
+        },
+        load: {
+            filter: { id: RESOLVED_VIRTUAL_ID_RE },
+            handler: (id: string) => loadVirtualModule(id, loadConfig, state),
+        },
     };
 };
 

package/src/vite-root.ts

@@ -0,0 +1,8 @@
+type RootConfig = {
+    root?: string | undefined;
+    test?: { root?: string | undefined } | undefined;
+};
+
+const viteProjectRoot = (config: RootConfig): string => config.test?.root ?? config.root ?? process.cwd();
+
+export { viteProjectRoot };