@gtkx/config 0.21.0 → 1.0.0-rc.2

package/src/config.ts

@@ -1,191 +1,273 @@
-import { isValidApplicationId } from "@gtkx/utils";
-import {
-    type ArrayPropRow,
-    type ContainerPropRow,
-    type ElementMapRule,
-    type ObjectPropRow,
-    type PerElementPropRows,
-    type UserTableRows,
-    type VirtualPropRow,
-    validateArrayPropRows,
-    validateContainerPropRows,
-    validateElementMap,
-    validateObjectPropRows,
-    validateVirtualPropRows,
-} from "./table-schema.js";
-
-export const LIBRARIES_WILDCARD = "*";
-
-export const GIR_NAMESPACE_PATTERN: RegExp = /^[A-Za-z][A-Za-z0-9]*-\d+(?:\.\d+)*$/;
-
-export type GtkxConfig = UserTableRows & {
-    libraries?: typeof LIBRARIES_WILDCARD | string[];
-
-    girPath?: string[];
-
-    applicationId?: string;
-
-    reactCompiler?: boolean | ReactCompilerOptions;
-};
-
-export type ReactCompilerCompilationMode = "infer" | "syntax" | "annotation" | "all";
+import { createDefineConfig, type DefineConfig } from "c12";
+import { defu } from "defu";
+import { resolve } from "node:path";
+import { z } from "zod";
+import { configError, isRecord, rawIssue } from "./config-error.js";
+import { resolveUserEventSignals } from "./user-event-signals.js";
 
-export type ReactCompilerPanicThreshold = "none" | "critical_errors" | "all_errors";
+type ReactCompilerCompilationMode = (typeof COMPILATION_MODES)[number];
+type ReactCompilerPanicThreshold = (typeof PANIC_THRESHOLDS)[number];
 
-export type ReactCompilerOptions = {
+type ReactCompilerOptions = {
     compilationMode?: ReactCompilerCompilationMode;
     panicThreshold?: ReactCompilerPanicThreshold;
 };
 
-export type ResolvedReactCompilerOptions = ReactCompilerOptions & {
+/**
+ * React Compiler options resolved for the build, with the compilation target
+ * fixed to React 19.
+ */
+type ResolvedReactCompilerOptions = ReactCompilerOptions & {
     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>;
+
+/**
+ * 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);
 
-export const resolveReactCompilerOptions = (
-    setting: GtkxConfig["reactCompiler"],
-): ResolvedReactCompilerOptions | null => {
-    if (setting === false) return null;
-    const overrides = setting === undefined || setting === true ? {} : setting;
-    return { ...overrides, target: REACT_COMPILER_TARGET };
-};
+const librariesSchema = z.custom<typeof LIBRARIES_WILDCARD | string[]>().check((ctx) => {
+    const value = ctx.value;
 
-const validateLibraryEntry = (library: unknown): void => {
-    if (typeof library === "string" && GIR_NAMESPACE_PATTERN.test(library)) {
+    if (value === LIBRARIES_WILDCARD) {
         return;
     }
-    if (library === LIBRARIES_WILDCARD) {
-        throw new Error(
-            'gtkx.config.ts: to generate every library, set `libraries: "*"` as a bare string, not an array entry',
+
+    if (!Array.isArray(value) || value.length === 0) {
+        ctx.issues.push(rawIssue(value, [], `must be "${LIBRARIES_WILDCARD}", a non-empty string array, or omitted`));
+
+        return;
+    }
+
+    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\` "${value}", must satisfy g_application_id_is_valid ` +
+                '(e.g. "org.example.MyApp")',
+                true,
+            ),
         );
     }
-    throw new Error(
-        `gtkx.config.ts: invalid library identifier "${String(library)}" — must be of the form "Name-Version" (e.g. "Gtk-4.0")`,
-    );
-};
+});
 
-const validateLibraries = (libraries: GtkxConfig["libraries"]): void => {
-    if (libraries === undefined || libraries === LIBRARIES_WILDCARD) {
+const reactCompilerSchema = z.custom<boolean | ReactCompilerOptions>().check((ctx) => {
+    const value = ctx.value;
+
+    if (typeof value === "boolean") {
         return;
     }
-    if (!Array.isArray(libraries) || libraries.length === 0) {
-        throw new Error('gtkx.config.ts: `libraries` must be "*", a non-empty string array, or omitted');
-    }
-    for (const library of libraries) {
-        validateLibraryEntry(library);
+
+    if (!isRecord(value)) {
+        ctx.issues.push(rawIssue(value, [], "must be a boolean or an options object"));
+
+        return;
     }
-};
 
-const validateGirPath = (girPath: GtkxConfig["girPath"]): void => {
-    if (girPath !== undefined && !Array.isArray(girPath)) {
-        throw new Error("gtkx.config.ts: `girPath` must be an array of strings if provided");
+    const compilationMode = value.compilationMode;
+
+    if (!isValidReactCompilerOption(compilationMode, COMPILATION_MODE_SET)) {
+        ctx.issues.push(
+            rawIssue(
+                value,
+                [],
+                `invalid \`reactCompiler.compilationMode\` "${String(compilationMode)}", ` +
+                `must be one of ${COMPILATION_MODES.join(", ")}`,
+                true,
+            ),
+        );
     }
-};
 
-const validateApplicationId = (applicationId: GtkxConfig["applicationId"]): void => {
-    if (applicationId === undefined) return;
-    if (typeof applicationId !== "string" || !isValidApplicationId(applicationId)) {
-        throw new Error(
-            `gtkx.config.ts: invalid \`applicationId\` "${String(applicationId)}" — ` +
-                `must satisfy g_application_id_is_valid (e.g. "org.example.MyApp")`,
+    const panicThreshold = value.panicThreshold;
+
+    if (!isValidReactCompilerOption(panicThreshold, PANIC_THRESHOLD_SET)) {
+        ctx.issues.push(
+            rawIssue(
+                value,
+                [],
+                `invalid \`reactCompiler.panicThreshold\` "${String(panicThreshold)}", ` +
+                `must be one of ${PANIC_THRESHOLDS.join(", ")}`,
+                true,
+            ),
         );
     }
-};
+});
 
-const REACT_COMPILER_COMPILATION_MODES: ReactCompilerCompilationMode[] = ["infer", "syntax", "annotation", "all"];
+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 REACT_COMPILER_PANIC_THRESHOLDS: ReactCompilerPanicThreshold[] = ["none", "critical_errors", "all_errors"];
+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 validateReactCompilerEnum = <T extends string>(value: T | undefined, allowed: T[], field: string): void => {
-    if (value !== undefined && !allowed.includes(value)) {
-        throw new Error(
-            `gtkx.config.ts: invalid \`reactCompiler.${field}\` "${String(value)}" — must be one of ${allowed.join(", ")}`,
-        );
+const configSchema = z.object({
+    libraries: librariesSchema.optional(),
+    girPath: z.array(z.string(), { error: "must be an array of strings if provided" }).optional(),
+    applicationId: applicationIdSchema,
+    reactCompiler: reactCompilerSchema.optional(),
+    codegen: z.boolean({ error: "must be a boolean" }).optional(),
+    userEventSignals: userEventSignalsSchema.optional(),
+    elements: elementsSchema.optional(),
+});
+
+/**
+ * Identity helper that returns the given configuration typed as {@link Config},
+ * enabling editor autocompletion and type checking in `gtkx.config.ts`.
+ */
+const defineConfig: DefineConfig<Config> = createDefineConfig<Config>();
+
+const libraryEntryIssues = (value: unknown[], index: number, entry: unknown): ReturnType<typeof rawIssue>[] => {
+    if (typeof entry === "string" && GIR_LIBRARY_PATTERN.test(entry)) {
+        return [];
     }
-};
 
-const validateReactCompiler = (reactCompiler: GtkxConfig["reactCompiler"]): void => {
-    if (reactCompiler === undefined || typeof reactCompiler === "boolean") return;
-    if (typeof reactCompiler !== "object" || reactCompiler === null || Array.isArray(reactCompiler)) {
-        throw new Error("gtkx.config.ts: `reactCompiler` must be a boolean or an options object");
+    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)];
     }
-    validateReactCompilerEnum(reactCompiler.compilationMode, REACT_COMPILER_COMPILATION_MODES, "compilationMode");
-    validateReactCompilerEnum(reactCompiler.panicThreshold, REACT_COMPILER_PANIC_THRESHOLDS, "panicThreshold");
+
+    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)];
 };
 
-export const validateGtkxConfig = (config: GtkxConfig): void => {
-    validateLibraries(config.libraries);
-    validateGirPath(config.girPath);
-    validateApplicationId(config.applicationId);
-    validateContainerPropRows(config.containerProps);
-    validateArrayPropRows(config.arrayProps);
-    validateObjectPropRows(config.objectProps);
-    validateVirtualPropRows(config.virtualProps);
-    validateElementMap(config.elementMap);
-    validateReactCompiler(config.reactCompiler);
+const isValidApplicationId = (applicationId: string): boolean => {
+    if (applicationId.length === 0 || applicationId.length > APPLICATION_ID_MAX_LENGTH) {
+        return false;
+    }
+
+    return APPLICATION_ID_PATTERN.test(applicationId);
 };
 
-export type GtkxConfigEnv = {
-    mode?: string;
+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 };
 };
 
-export type GtkxConfigFn = (env: GtkxConfigEnv) => GtkxConfig;
-
-export type GtkxConfigFnPromise = (env: GtkxConfigEnv) => Promise<GtkxConfig>;
-
-export type GtkxConfigExport = GtkxConfig | Promise<GtkxConfig> | GtkxConfigFn | GtkxConfigFnPromise;
-
-export function defineConfig(config: GtkxConfig): GtkxConfig;
-export function defineConfig(config: Promise<GtkxConfig>): Promise<GtkxConfig>;
-export function defineConfig(config: GtkxConfigFn): GtkxConfigFn;
-export function defineConfig(config: GtkxConfigFnPromise): GtkxConfigFnPromise;
-export function defineConfig(config: GtkxConfigExport): GtkxConfigExport;
-export function defineConfig(config: GtkxConfigExport): GtkxConfigExport {
-    return config;
-}
-
-const isMergeableObject = (value: unknown): value is Record<string, unknown> =>
-    typeof value === "object" && value !== null && !Array.isArray(value);
-
-const mergeConfigValue = (base: unknown, override: unknown): unknown => {
-    if (override === undefined) return base;
-    if (base === undefined) return override;
-    if (Array.isArray(base) && Array.isArray(override)) return [...base, ...override];
-    if (isMergeableObject(base) && isMergeableObject(override)) {
-        const merged: Record<string, unknown> = { ...base };
-        for (const key of Object.keys(override)) {
-            merged[key] = mergeConfigValue(base[key], override[key]);
-        }
-        return merged;
+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);
     }
-    return override;
 };
 
-export const mergeConfig = (base: GtkxConfig, override: GtkxConfig): GtkxConfig =>
-    mergeConfigValue(base, override) as GtkxConfig;
-
-export type ResolvedGtkxConfig = {
-    libraries: typeof LIBRARIES_WILDCARD | string[];
-    girPath: string[];
-    applicationId: string | undefined;
-    containerProps: PerElementPropRows<ContainerPropRow>;
-    arrayProps: PerElementPropRows<ArrayPropRow>;
-    objectProps: PerElementPropRows<ObjectPropRow>;
-    virtualProps: PerElementPropRows<VirtualPropRow>;
-    elementMap: ElementMapRule[];
-    reactCompiler: ResolvedReactCompilerOptions | null;
+/**
+ * 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.
+ */
+const mergeConfig = (base: Config, override: Config): Config => defu(override, base);
+
+const resolveElementsModule = (behaviors: string | undefined, root: string | undefined): string | null => {
+    if (behaviors === undefined) {
+        return null;
+    }
+
+    return root === undefined ? behaviors : resolve(root, behaviors);
 };
 
-export const resolveGtkxConfig = (config: GtkxConfig): ResolvedGtkxConfig => ({
-    libraries: config.libraries ?? [],
-    girPath: config.girPath ?? [],
+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,
-    containerProps: config.containerProps ?? {},
-    arrayProps: config.arrayProps ?? {},
-    objectProps: config.objectProps ?? {},
-    virtualProps: config.virtualProps ?? {},
-    elementMap: config.elementMap ?? [],
     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

@@ -1,88 +1,8 @@
-export { gtkxBundledModulePatterns } from "./bundled-modules.js";
 export {
+    type Config,
     defineConfig,
-    GIR_NAMESPACE_PATTERN,
-    type GtkxConfig,
-    type GtkxConfigEnv,
-    type GtkxConfigExport,
-    type GtkxConfigFn,
-    type GtkxConfigFnPromise,
-    LIBRARIES_WILDCARD,
     mergeConfig,
-    type ReactCompilerCompilationMode,
-    type ReactCompilerOptions,
-    type ReactCompilerPanicThreshold,
-    type ResolvedGtkxConfig,
+    type ResolvedConfig,
     type ResolvedReactCompilerOptions,
-    resolveGtkxConfig,
-    resolveReactCompilerOptions,
-    validateGtkxConfig,
 } from "./config.js";
-export { DATA_IMPORT_KEY, DATA_IMPORT_PREFIX, resolveDataDir } from "./data-dir.js";
-export {
-    createGtkxConfigLoader,
-    type GtkxConfigLoader,
-    GtkxConfigNotFoundError,
-    type LoadedConfig,
-    type LoadGtkxConfigOptions,
-    type LoadResolvedGtkxConfigOptions,
-    loadGtkxConfig,
-    loadResolvedGtkxConfig,
-} from "./loader.js";
-export { createGtkxConfigPlugin, type GtkxConfigPluginOptions } from "./plugin.js";
-export type {
-    AddMethodArg,
-    AddMethodRule,
-    PageMetaSetter,
-    PropCondition,
-    PropRule,
-    SetterPropGroup,
-    SetterPropStep,
-    SignalPropRule,
-} from "./table-rules-ir.js";
-export type {
-    ArrayPropRow,
-    AttachShape,
-    AttachShapeTable,
-    AttachVerb,
-    CallArg,
-    CallStep,
-    ConstructSetter,
-    ConstructStep,
-    ContainerPropRow,
-    DetachGuard,
-    ElementMapRule,
-    MethodVerb,
-    ObjectPropRow,
-    OrderedInsertVerb,
-    PerElementPropRows,
-    PresenceCondition,
-    UserTableRows,
-    VerbArgs,
-    VirtualPropRow,
-} from "./table-schema.js";
-export {
-    CAMEL_CASE_NAME_PATTERN,
-    PASCAL_CASE_NAME_PATTERN,
-    validateArrayOf,
-} from "./validators.js";
-export {
-    GTKX_CONFIG_VIRTUAL_ID,
-    RESOLVED_GTKX_CONFIG_VIRTUAL_ID,
-    renderGtkxConfigModule,
-    type SerializedGtkxConfig,
-    serializeGtkxConfig,
-} from "./virtual.js";
-export {
-    BUFFER_TEXT_KIND,
-    CONTAINER_PROP_KIND,
-    LABEL_TEXT_KIND,
-    LAYOUT_CHILD_KIND,
-    META_OBJECT_KIND,
-    OVERLAY_KIND,
-    SLOT_KIND,
-    TAB_LABEL_KIND,
-    TEXT_ANCHOR_KIND,
-    TEXT_PAINTABLE_KIND,
-    WRAPPER_NODE_ELEMENT,
-} from "./wrapper-protocol.js";
+export { type LoadedConfig, loadConfig } from "./loader.js";

package/src/internal.ts

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

package/src/loader.ts

@@ -1,88 +1,77 @@
+import { loadConfig as loadConfigFile } from "c12";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
-import { loadConfig } from "c12";
-import { type GtkxConfig, type ResolvedGtkxConfig, resolveGtkxConfig, validateGtkxConfig } from "./config.js";
+import { type Config, resolveConfig, type ResolvedConfig, validateConfig } from "./config.js";
 
-export type LoadedConfig = {
-    config: GtkxConfig;
+/**
+ * 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.
+ */
+type LoadedConfig = {
+    config: Config;
     configFile: string | undefined;
-    rootDir: string;
+    root: string;
 };
 
-export class GtkxConfigNotFoundError extends Error {
-    constructor(cwd: string) {
-        super(
-            `No gtkx.config.ts found in ${cwd}.\n` +
-                `Create one with:\n` +
-                `\n` +
-                `  // gtkx.config.ts\n` +
-                `  import { defineConfig } from "@gtkx/config";\n` +
-                `\n` +
-                `  export default defineConfig({\n` +
-                `      libraries: ["Gtk-4.0", "Adw-1"],\n` +
-                `  });\n`,
-        );
-        this.name = "GtkxConfigNotFoundError";
-    }
-}
-
-export type LoadGtkxConfigOptions = {
-    mode?: string;
+type LoadConfigOptions = {
+    mode?: string | undefined;
 };
 
-export const loadGtkxConfig = async (cwd: string, options: LoadGtkxConfigOptions = {}): Promise<LoadedConfig> => {
-    const result = await loadConfig<GtkxConfig>({
+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.
+ */
+const loadConfig = async (cwd: string, options: LoadConfigOptions = {}): Promise<LoadedConfig> => {
+    const result = await loadConfigFile<Config>({
         name: "gtkx",
         cwd,
         rcFile: false,
         globalRc: false,
         packageJson: false,
         context: { mode: options.mode },
+        ...((options.mode !== undefined) && { envName: options.mode }),
     });
 
-    if (!result.configFile || !result.config || !existsSync(resolve(cwd, result.configFile))) {
-        throw new GtkxConfigNotFoundError(cwd);
-    }
+    const config = result.config;
+    const isFound = result.configFile !== undefined && existsSync(resolve(cwd, result.configFile));
 
-    validateGtkxConfig(result.config);
+    if (isFound) {
+        validateConfig(config);
+    }
 
     return {
-        config: result.config,
-        configFile: result.configFile,
-        rootDir: result.cwd ?? cwd,
+        config,
+        configFile: isFound ? result.configFile : undefined,
+        root: result.cwd ?? cwd,
     };
 };
 
-export type LoadResolvedGtkxConfigOptions = LoadGtkxConfigOptions & {
-    allowMissing?: boolean;
-};
+const createConfigLoader = (options: LoadConfigOptions = {}): ConfigLoader => {
+    const cache: Map<string, Promise<ResolvedConfig>> = new Map();
 
-export const loadResolvedGtkxConfig = async (
-    cwd: string,
-    options: LoadResolvedGtkxConfigOptions = {},
-): Promise<ResolvedGtkxConfig> => {
-    try {
-        const { config } = await loadGtkxConfig(cwd, options.mode === undefined ? {} : { mode: options.mode });
-        return resolveGtkxConfig(config);
-    } catch (error) {
-        if (options.allowMissing && error instanceof GtkxConfigNotFoundError) {
-            return resolveGtkxConfig({});
-        }
-        throw error;
-    }
-};
+    const loadResolved = async (root: string): Promise<ResolvedConfig> => {
+        const { config } = await loadConfig(root, options);
+        validateConfig(config);
 
-export type GtkxConfigLoader = (cwd: string) => Promise<ResolvedGtkxConfig>;
+        return resolveConfig(config, root);
+    };
 
-export const createGtkxConfigLoader = (options: LoadResolvedGtkxConfigOptions = {}): GtkxConfigLoader => {
-    const cache = new Map<string, Promise<ResolvedGtkxConfig>>();
-    return (cwd: string): Promise<ResolvedGtkxConfig> => {
+    return (cwd: string): Promise<ResolvedConfig> => {
         const root = resolve(cwd);
         let pending = cache.get(root);
+
         if (!pending) {
-            pending = loadResolvedGtkxConfig(root, options);
+            pending = loadResolved(root);
             cache.set(root, pending);
         }
+
         return pending;
     };
 };
+
+export { loadConfig, createConfigLoader, type LoadedConfig, type LoadConfigOptions, type ConfigLoader };