@gtkx/config 1.0.0-rc.1 → 1.0.0-rc.2

package/src/config.ts

@@ -1,28 +1,11 @@
 import { createDefineConfig, type DefineConfig } from "c12";
 import { defu } from "defu";
+import { resolve } from "node:path";
 import { z } from "zod";
-import { configError, elementPropsSchema, isRecord, rawIssue } from "./element-props.js";
-
-export const LIBRARIES_WILDCARD = "*";
-
-export const GIR_LIBRARY_PATTERN: RegExp = /^[A-Za-z][A-Za-z0-9]*-\d+(?:\.\d+)*$/;
-
-const APPLICATION_ID_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]*(\.[A-Za-z_][A-Za-z0-9_-]*)+$/;
-const APPLICATION_ID_MAX_LENGTH = 255;
-
-export const isValidApplicationId = (applicationId: string): boolean => {
-    if (applicationId.length === 0 || applicationId.length > APPLICATION_ID_MAX_LENGTH) {
-        return false;
-    }
-    return APPLICATION_ID_PATTERN.test(applicationId);
-};
-
-const COMPILATION_MODES = ["infer", "syntax", "annotation", "all"] as const;
-
-const PANIC_THRESHOLDS = ["none", "critical_errors", "all_errors"] as const;
+import { configError, isRecord, rawIssue } from "./config-error.js";
+import { resolveUserEventSignals } from "./user-event-signals.js";
 
 type ReactCompilerCompilationMode = (typeof COMPILATION_MODES)[number];
-
 type ReactCompilerPanicThreshold = (typeof PANIC_THRESHOLDS)[number];
 
 type ReactCompilerOptions = {
@@ -34,61 +17,72 @@ type ReactCompilerOptions = {
  * React Compiler options resolved for the build, with the compilation target
  * fixed to React 19.
  */
-export type ResolvedReactCompilerOptions = ReactCompilerOptions & {
+type ResolvedReactCompilerOptions = ReactCompilerOptions & {
     target: "19";
 };
 
-const REACT_COMPILER_TARGET = "19";
+/**
+ * User-facing configuration for a GTKX project, as authored in `gtkx.config.ts`:
+ * the GIR libraries to bind, extra `.gir` search paths, the GApplication id,
+ * a module of per-element configuration (lazy flags and custom behaviors),
+ * per-element component wrappers keyed by GLib type name, the React Compiler and
+ * codegen settings, and additional user event signals to suppress during React
+ * commits.
+ */
+type Config = z.infer<typeof configSchema>;
 
-export const resolveReactCompilerOptions = (setting: Config["reactCompiler"]): ResolvedReactCompilerOptions | null => {
-    if (setting === false) return null;
-    const overrides = setting === undefined || setting === true ? {} : setting;
-    return { ...overrides, target: REACT_COMPILER_TARGET };
+/**
+ * Configuration reduced to the values needed at runtime: the GApplication
+ * identifier, the resolved React Compiler options (`null` when disabled), the
+ * user event signals suppressed while a React commit is in progress, and the
+ * module path holding per-element configuration (`null` when unset).
+ */
+type ResolvedConfig = {
+    applicationId: string;
+    reactCompiler: ResolvedReactCompilerOptions | null;
+    userEventSignals: Record<string, string[]>;
+    elements: string | null;
+    lazyElements: string[];
 };
 
+const LIBRARIES_WILDCARD = "*";
+const GIR_LIBRARY_PATTERN = /^[A-Za-z][A-Za-z0-9]*-\d+(?:\.\d+)*$/;
+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 COMPILATION_MODES = ["infer", "syntax", "annotation", "all"] as const;
+const PANIC_THRESHOLDS = ["none", "critical_errors", "all_errors"] as const;
+const REACT_COMPILER_TARGET = "19";
 const COMPILATION_MODE_SET: Set<string> = new Set(COMPILATION_MODES);
-
 const PANIC_THRESHOLD_SET: Set<string> = new Set(PANIC_THRESHOLDS);
 
 const librariesSchema = z.custom<typeof LIBRARIES_WILDCARD | string[]>().check((ctx) => {
     const value = ctx.value;
-    if (value === LIBRARIES_WILDCARD) return;
+
+    if (value === LIBRARIES_WILDCARD) {
+        return;
+    }
+
     if (!Array.isArray(value) || value.length === 0) {
         ctx.issues.push(rawIssue(value, [], `must be "${LIBRARIES_WILDCARD}", a non-empty string array, or omitted`));
+
         return;
     }
-    value.forEach((entry, index) => {
-        if (typeof entry === "string" && GIR_LIBRARY_PATTERN.test(entry)) return;
-        if (entry === LIBRARIES_WILDCARD) {
-            ctx.issues.push(
-                rawIssue(
-                    value,
-                    [index],
-                    `to generate every library, set \`libraries: "${LIBRARIES_WILDCARD}"\` as a bare string, not an array entry`,
-                    true,
-                ),
-            );
-            return;
-        }
-        ctx.issues.push(
-            rawIssue(
-                value,
-                [index],
-                `invalid library identifier "${String(entry)}", must be of the form "Name-Version" (e.g. "Gtk-4.0")`,
-                true,
-            ),
-        );
-    });
+
+    for (const [index, entry] of value.entries()) {
+        ctx.issues.push(...libraryEntryIssues(value, index, entry));
+    }
 });
 
 const applicationIdSchema = z.custom<string>().check((ctx) => {
     const value = ctx.value;
+
     if (typeof value !== "string" || !isValidApplicationId(value)) {
         ctx.issues.push(
             rawIssue(
                 value,
                 [],
-                `invalid \`applicationId\` "${String(value)}", must satisfy g_application_id_is_valid (e.g. "org.example.MyApp")`,
+                `invalid \`applicationId\` "${value}", must satisfy g_application_id_is_valid ` +
+                '(e.g. "org.example.MyApp")',
                 true,
             ),
         );
@@ -97,85 +91,183 @@ const applicationIdSchema = z.custom<string>().check((ctx) => {
 
 const reactCompilerSchema = z.custom<boolean | ReactCompilerOptions>().check((ctx) => {
     const value = ctx.value;
-    if (typeof value === "boolean") return;
+
+    if (typeof value === "boolean") {
+        return;
+    }
+
     if (!isRecord(value)) {
         ctx.issues.push(rawIssue(value, [], "must be a boolean or an options object"));
+
         return;
     }
+
     const compilationMode = value.compilationMode;
-    if (
-        compilationMode !== undefined &&
-        !(typeof compilationMode === "string" && COMPILATION_MODE_SET.has(compilationMode))
-    ) {
+
+    if (!isValidReactCompilerOption(compilationMode, COMPILATION_MODE_SET)) {
         ctx.issues.push(
             rawIssue(
                 value,
                 [],
-                `invalid \`reactCompiler.compilationMode\` "${String(compilationMode)}", must be one of ${COMPILATION_MODES.join(", ")}`,
+                `invalid \`reactCompiler.compilationMode\` "${String(compilationMode)}", ` +
+                `must be one of ${COMPILATION_MODES.join(", ")}`,
                 true,
             ),
         );
     }
+
     const panicThreshold = value.panicThreshold;
-    if (
-        panicThreshold !== undefined &&
-        !(typeof panicThreshold === "string" && PANIC_THRESHOLD_SET.has(panicThreshold))
-    ) {
+
+    if (!isValidReactCompilerOption(panicThreshold, PANIC_THRESHOLD_SET)) {
         ctx.issues.push(
             rawIssue(
                 value,
                 [],
-                `invalid \`reactCompiler.panicThreshold\` "${String(panicThreshold)}", must be one of ${PANIC_THRESHOLDS.join(", ")}`,
+                `invalid \`reactCompiler.panicThreshold\` "${String(panicThreshold)}", ` +
+                `must be one of ${PANIC_THRESHOLDS.join(", ")}`,
                 true,
             ),
         );
     }
 });
 
+const userEventSignalsSchema = z.record(
+    z.string(),
+    z.array(
+        z.string({ error: "must be a non-empty signal name" }).min(1, { error: "must be a non-empty signal name" }),
+        {
+            error: "must be an array of signal names",
+        },
+    ),
+    { error: "must be a record of GLib type names to signal name arrays" },
+);
+
+const moduleExportSchema = z.object(
+    {
+        module: z.string({ error: "must be a module specifier" }).min(1, { error: "must be a module specifier" }),
+        export: z.string({ error: "must be an export name" }).min(1, { error: "must be an export name" }),
+    },
+    { error: "must be a { module, export } object" },
+);
+
+const elementConfigSchema = z.object({
+    component: moduleExportSchema.optional(),
+    props: moduleExportSchema.optional(),
+    lazy: z.boolean({ error: "must be a boolean" }).optional(),
+});
+
+const elementsSchema = z.object({
+    behaviors: z
+        .string({ error: "must be a path to a module exporting element behaviors" })
+        .min(1, { error: "must be a path to a module exporting element behaviors" })
+        .optional(),
+    config: z.record(z.string(), elementConfigSchema).optional(),
+});
+
 const configSchema = z.object({
     libraries: librariesSchema.optional(),
     girPath: z.array(z.string(), { error: "must be an array of strings if provided" }).optional(),
     applicationId: applicationIdSchema,
-    elementProps: elementPropsSchema.optional(),
     reactCompiler: reactCompilerSchema.optional(),
     codegen: z.boolean({ error: "must be a boolean" }).optional(),
+    userEventSignals: userEventSignalsSchema.optional(),
+    elements: elementsSchema.optional(),
 });
 
 /**
- * User-facing configuration for a GTKX project, as authored in `gtkx.config.ts`:
- * the GIR libraries to bind, extra `.gir` search paths, the GApplication id,
- * custom element prop mappings, and the React Compiler and codegen settings.
+ * Identity helper that returns the given configuration typed as {@link Config},
+ * enabling editor autocompletion and type checking in `gtkx.config.ts`.
  */
-export type Config = z.infer<typeof configSchema>;
+const defineConfig: DefineConfig<Config> = createDefineConfig<Config>();
 
-export const validateConfig = (config: Config): void => {
-    const result = configSchema.safeParse(config);
-    if (!result.success) throw configError(result.error);
+const libraryEntryIssues = (value: unknown[], index: number, entry: unknown): ReturnType<typeof rawIssue>[] => {
+    if (typeof entry === "string" && GIR_LIBRARY_PATTERN.test(entry)) {
+        return [];
+    }
+
+    if (entry === LIBRARIES_WILDCARD) {
+        const message =
+            `to generate every library, set \`libraries: "${LIBRARIES_WILDCARD}"\` as a bare string, ` +
+            "not an array entry";
+
+        return [rawIssue(value, [index], message, true)];
+    }
+
+    const message =
+        `invalid library identifier "${String(entry)}", must be of the form "Name-Version" ` +
+        '(e.g. "Gtk-4.0")';
+
+    return [rawIssue(value, [index], message, true)];
 };
 
-/**
- * Identity helper that returns the given configuration typed as {@link Config},
- * enabling editor autocompletion and type checking in `gtkx.config.ts`.
- */
-export const defineConfig: DefineConfig<Config> = createDefineConfig<Config>();
+const isValidApplicationId = (applicationId: string): boolean => {
+    if (applicationId.length === 0 || applicationId.length > APPLICATION_ID_MAX_LENGTH) {
+        return false;
+    }
+
+    return APPLICATION_ID_PATTERN.test(applicationId);
+};
+
+const resolveReactCompilerOptions = (setting: Config["reactCompiler"]): ResolvedReactCompilerOptions | null => {
+    if (setting === false) {
+        return null;
+    }
+
+    const overrides = setting === undefined || setting === true ? {} : setting;
+
+    return { ...overrides, target: REACT_COMPILER_TARGET };
+};
+
+const isValidReactCompilerOption = (value: unknown, allowed: Set<string>): boolean =>
+    value === undefined || (typeof value === "string" && allowed.has(value));
+
+const validateConfig = (config: Config): void => {
+    const result = configSchema.safeParse(config);
+
+    if (!result.success) {
+        throw configError(result.error);
+    }
+};
 
 /**
  * Deep-merges two configurations, with `override` taking precedence over `base`.
  * @param base The lower-priority configuration.
  * @param override The higher-priority configuration whose values win on conflict.
  */
-export const mergeConfig = (base: Config, override: Config): Config => defu(override, base);
+const mergeConfig = (base: Config, override: Config): Config => defu(override, base);
 
-/**
- * Configuration reduced to the values needed at runtime: the GApplication
- * identifier and the resolved React Compiler options (`null` when disabled).
- */
-export type ResolvedConfig = {
-    applicationId: string;
-    reactCompiler: ResolvedReactCompilerOptions | null;
+const resolveElementsModule = (behaviors: string | undefined, root: string | undefined): string | null => {
+    if (behaviors === undefined) {
+        return null;
+    }
+
+    return root === undefined ? behaviors : resolve(root, behaviors);
 };
 
-export const resolveConfig = (config: Config): ResolvedConfig => ({
+const resolveLazyElements = (elements: Config["elements"]): string[] =>
+    Object.entries(elements?.config ?? {})
+        .filter(([, entry]) => entry.lazy === true)
+        .map(([type]) => type);
+
+const resolveConfig = (config: Config, root?: string): ResolvedConfig => ({
     applicationId: config.applicationId,
     reactCompiler: resolveReactCompilerOptions(config.reactCompiler),
+    userEventSignals: resolveUserEventSignals(config.userEventSignals),
+    elements: resolveElementsModule(config.elements?.behaviors, root),
+    lazyElements: resolveLazyElements(config.elements),
 });
+
+export {
+    LIBRARIES_WILDCARD,
+    GIR_LIBRARY_PATTERN,
+    defineConfig,
+    isValidApplicationId,
+    resolveReactCompilerOptions,
+    validateConfig,
+    mergeConfig,
+    resolveLazyElements,
+    resolveConfig,
+    type ResolvedReactCompilerOptions,
+    type Config,
+    type ResolvedConfig,
+};

package/src/index.ts

@@ -5,16 +5,4 @@ export {
     type ResolvedConfig,
     type ResolvedReactCompilerOptions,
 } from "./config.js";
-export type {
-    AppliedProp,
-    Arg,
-    ArgRef,
-    Call,
-    ContainerProp,
-    ControlledTextProp,
-    ElementProp,
-    LazyProp,
-    ListProp,
-    ValueProp,
-} from "./element-props.js";
 export { type LoadedConfig, loadConfig } from "./loader.js";

package/src/internal.ts

@@ -1,2 +1,2 @@
-export { GIR_LIBRARY_PATTERN, isValidApplicationId, LIBRARIES_WILDCARD } from "./config.js";
+export { GIR_LIBRARY_PATTERN, isValidApplicationId, LIBRARIES_WILDCARD, resolveLazyElements } from "./config.js";
 export { type ConfigLoader, createConfigLoader } from "./loader.js";

package/src/loader.ts

@@ -1,30 +1,32 @@
+import { loadConfig as loadConfigFile } from "c12";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
-import { loadConfig as loadConfigFile } from "c12";
-import { type Config, type ResolvedConfig, resolveConfig, validateConfig } from "./config.js";
+import { type Config, resolveConfig, type ResolvedConfig, validateConfig } from "./config.js";
 
 /**
  * Result of loading a `gtkx.config.ts` file: the parsed configuration, the
  * resolved config file path (`undefined` when none was found), and the project
  * root it was loaded from.
  */
-export type LoadedConfig = {
+type LoadedConfig = {
     config: Config;
     configFile: string | undefined;
     root: string;
 };
 
-export type LoadConfigOptions = {
+type LoadConfigOptions = {
     mode?: string | undefined;
 };
 
+type ConfigLoader = (cwd: string) => Promise<ResolvedConfig>;
+
 /**
  * Loads and validates the `gtkx.config.ts` file for a project, returning the
  * parsed configuration together with the config file path and project root.
  * @param cwd Directory from which to search for the configuration file.
  * @param options Loading options, such as the environment mode.
  */
-export const loadConfig = async (cwd: string, options: LoadConfigOptions = {}): Promise<LoadedConfig> => {
+const loadConfig = async (cwd: string, options: LoadConfigOptions = {}): Promise<LoadedConfig> => {
     const result = await loadConfigFile<Config>({
         name: "gtkx",
         cwd,
@@ -32,37 +34,44 @@ export const loadConfig = async (cwd: string, options: LoadConfigOptions = {}):
         globalRc: false,
         packageJson: false,
         context: { mode: options.mode },
-        ...(options.mode !== undefined ? { envName: options.mode } : {}),
+        ...((options.mode !== undefined) && { envName: options.mode }),
     });
 
     const config = result.config;
-    const found = result.configFile !== undefined && existsSync(resolve(cwd, result.configFile));
+    const isFound = result.configFile !== undefined && existsSync(resolve(cwd, result.configFile));
 
-    if (found) validateConfig(config);
+    if (isFound) {
+        validateConfig(config);
+    }
 
     return {
         config,
-        configFile: found ? result.configFile : undefined,
+        configFile: isFound ? result.configFile : undefined,
         root: result.cwd ?? cwd,
     };
 };
 
-export type ConfigLoader = (cwd: string) => Promise<ResolvedConfig>;
+const createConfigLoader = (options: LoadConfigOptions = {}): ConfigLoader => {
+    const cache: Map<string, Promise<ResolvedConfig>> = new Map();
 
-export const createConfigLoader = (options: LoadConfigOptions = {}): ConfigLoader => {
-    const cache = new Map<string, Promise<ResolvedConfig>>();
     const loadResolved = async (root: string): Promise<ResolvedConfig> => {
         const { config } = await loadConfig(root, options);
         validateConfig(config);
-        return resolveConfig(config);
+
+        return resolveConfig(config, root);
     };
+
     return (cwd: string): Promise<ResolvedConfig> => {
         const root = resolve(cwd);
         let pending = cache.get(root);
+
         if (!pending) {
             pending = loadResolved(root);
             cache.set(root, pending);
         }
+
         return pending;
     };
 };
+
+export { loadConfig, createConfigLoader, type LoadedConfig, type LoadConfigOptions, type ConfigLoader };

package/src/user-event-signals.ts

@@ -0,0 +1,57 @@
+const DEFAULT_USER_EVENT_SIGNALS: Record<string, string[]> = {
+    AdwAlertDialog: ["response"],
+    AdwCarousel: ["page-changed"],
+    AdwDialog: ["closed"],
+    AdwNavigationView: ["pushed"],
+    AdwTabView: ["close-page", "page-attached", "page-detached", "page-reordered"],
+    GObject: ["notify"],
+    GtkAdjustment: ["changed", "value-changed"],
+    GtkAppChooserButton: ["changed"],
+    GtkAppChooserWidget: ["application-selected"],
+    GtkCalendar: ["day-selected"],
+    GtkCheckButton: ["toggled"],
+    GtkComboBox: ["changed"],
+    GtkEditable: ["changed", "delete-text", "insert-text"],
+    GtkEntryBuffer: ["deleted-text", "inserted-text"],
+    GtkFlowBox: ["selected-children-changed"],
+    GtkIconView: ["selection-changed"],
+    GtkListBox: ["row-selected", "selected-rows-changed"],
+    GtkNotebook: ["page-added", "page-removed", "page-reordered", "switch-page"],
+    GtkPopover: ["closed"],
+    GtkRange: ["value-changed"],
+    GtkScaleButton: ["value-changed"],
+    GtkScrolledWindow: ["edge-reached"],
+    GtkSearchEntry: ["search-changed"],
+    GtkSelectionModel: ["selection-changed"],
+    GtkSpinButton: ["value-changed"],
+    GtkSwitch: ["state-set"],
+    GtkTextBuffer: [
+        "apply-tag",
+        "changed",
+        "delete-range",
+        "insert-child-anchor",
+        "insert-paintable",
+        "insert-text",
+        "mark-deleted",
+        "mark-set",
+        "modified-changed",
+        "remove-tag",
+    ],
+    GtkToggleButton: ["toggled"],
+    GtkTreeSelection: ["changed"],
+    GtkTreeView: ["columns-changed", "cursor-changed", "row-collapsed", "row-expanded"],
+    GtkWidget: ["state-flags-changed"],
+};
+
+const resolveUserEventSignals = (overrides: Record<string, string[]> | undefined): Record<string, string[]> => {
+    const resolved: Record<string, string[]> = { ...DEFAULT_USER_EVENT_SIGNALS };
+    const overrideEntries = Object.entries(overrides ?? {});
+
+    for (const [typeName, signals] of overrideEntries) {
+        resolved[typeName] = [...new Set([...(resolved[typeName] ?? []), ...signals])];
+    }
+
+    return resolved;
+};
+
+export { DEFAULT_USER_EVENT_SIGNALS, resolveUserEventSignals };

package/src/virtual.ts

@@ -1,13 +1,36 @@
 import type { ResolvedConfig } from "./config.js";
 
-export const GTKX_CONFIG_VIRTUAL_ID = "virtual:gtkx-config";
+const GTKX_CONFIG_VIRTUAL_ID = "virtual:gtkx-config";
+const RESOLVED_GTKX_CONFIG_VIRTUAL_ID = `\0${GTKX_CONFIG_VIRTUAL_ID}`;
+const METADATA_SPECIFIER = "@gtkx/jsx/metadata";
 
-export const RESOLVED_GTKX_CONFIG_VIRTUAL_ID: string = `\0${GTKX_CONFIG_VIRTUAL_ID}`;
+const lazyElementConfig = (lazyElements: string[]): Record<string, { lazy: true }> =>
+    Object.fromEntries(lazyElements.map((type) => [type, { lazy: true }]));
 
-const METADATA_SPECIFIER = "@gtkx/jsx/metadata";
+/**
+ * The runtime element config is the app's static per-element config (currently its lazy flags) merged
+ * with its behaviors module, so a single `elements` map is registered.
+ */
+const renderConfigModule = (config: ResolvedConfig): string => {
+    const lazyJson = JSON.stringify(lazyElementConfig(config.lazyElements));
 
-export const renderConfigModule = (config: ResolvedConfig): string =>
-    [
+    const behaviorImports =
+        config.elements === null
+            ? []
+            : [
+                    "import { mergeElementConfigs } from \"@gtkx/react/config\";",
+                    `import __elementBehaviors from ${JSON.stringify(config.elements)};`,
+                ];
+
+    return [
+        ...behaviorImports,
         `export * from ${JSON.stringify(METADATA_SPECIFIER)};`,
         `export const applicationId = ${JSON.stringify(config.applicationId)};`,
+        `export const userEventSignals = ${JSON.stringify(config.userEventSignals)};`,
+        config.elements === null
+            ? `export const elements = ${lazyJson};`
+            : `export const elements = mergeElementConfigs(__elementBehaviors, ${lazyJson});`,
     ].join("\n");
+};
+
+export { GTKX_CONFIG_VIRTUAL_ID, RESOLVED_GTKX_CONFIG_VIRTUAL_ID, renderConfigModule };

package/src/vite-plugin.ts

@@ -1,6 +1,25 @@
 import type { Plugin, UserConfig } from "vite";
 import { type ConfigLoader, createConfigLoader } from "./loader.js";
-import { GTKX_CONFIG_VIRTUAL_ID, RESOLVED_GTKX_CONFIG_VIRTUAL_ID, renderConfigModule } from "./virtual.js";
+import { GTKX_CONFIG_VIRTUAL_ID, renderConfigModule, RESOLVED_GTKX_CONFIG_VIRTUAL_ID } from "./virtual.js";
+
+type PluginState = {
+    root: string | undefined;
+};
+
+const resolveVirtualId = (id: string): string | null =>
+    id === GTKX_CONFIG_VIRTUAL_ID ? RESOLVED_GTKX_CONFIG_VIRTUAL_ID : null;
+
+const loadVirtualModule = async (
+    id: string,
+    loadConfig: ConfigLoader,
+    state: PluginState,
+): Promise<string | undefined> => {
+    if (id !== RESOLVED_GTKX_CONFIG_VIRTUAL_ID) {
+        return undefined;
+    }
+
+    return renderConfigModule(await loadConfig(state.root ?? process.cwd()));
+};
 
 /**
  * Creates the Vite plugin that resolves and serves the `virtual:gtkx-config`
@@ -15,22 +34,17 @@ const createConfigPlugin = (options: {
     config?: () => Omit<UserConfig, "plugins">;
 }): Plugin => {
     const loadConfig = options.loadConfig ?? createConfigLoader();
-    let root: string | undefined;
+    const state: PluginState = { root: undefined };
 
     return {
         name: options.name,
         config(config: UserConfig) {
-            root = config.root ?? root;
+            state.root = config.root ?? state.root;
+
             return options.config?.();
         },
-        resolveId(id: string) {
-            if (id === GTKX_CONFIG_VIRTUAL_ID) return RESOLVED_GTKX_CONFIG_VIRTUAL_ID;
-            return undefined;
-        },
-        async load(id: string) {
-            if (id !== RESOLVED_GTKX_CONFIG_VIRTUAL_ID) return undefined;
-            return renderConfigModule(await loadConfig(root ?? process.cwd()));
-        },
+        resolveId: (id: string) => resolveVirtualId(id),
+        load: (id: string) => loadVirtualModule(id, loadConfig, state),
     };
 };