@gtkx/cli 1.6.0 → 2.0.0-beta.10

package/src/vite-plugins/react-compiler.ts

@@ -1,21 +1,45 @@
 import type { ConfigLoader } from "@gtkx/config";
 import type { ResolvedReactCompilerOptions } from "@gtkx/config/internal";
 import type { Plugin, ResolvedConfig, UserConfig } from "vite";
-import { transformAsync } from "@babel/core";
-import babelPresetTypescriptNs from "@babel/preset-typescript";
-import { createConfigLoader } from "@gtkx/config/internal";
-import babelPluginReactCompilerNs from "babel-plugin-react-compiler";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
+import {
+    type CompilerOutput,
+    createReactCompilerCache,
+    type ReactCompilerCache,
+} from "../internal/react-compiler-cache.js";
 
 type ReactCompilerState = {
-    root: string;
+    cache: ReactCompilerCache | null;
     options: ResolvedReactCompilerOptions | null;
+    root: string;
 };
 
-const babelPresetTypescript = babelPresetTypescriptNs.default ?? babelPresetTypescriptNs;
-const babelPluginReactCompiler = babelPluginReactCompilerNs.default ?? babelPluginReactCompilerNs;
+type BabelToolchain = Awaited<ReturnType<typeof loadBabelToolchain>>;
+
 const SOURCE_EXTENSION = /\.[jt]sx?$/;
 const TYPESCRIPT_EXTENSION = /\.tsx?$/;
 const NODE_MODULES = /(?:^|\/)node_modules\//;
+const MEMOIZABLE_SOURCE = /use[A-Z0-9]|use memo|use forget/;
+const JSX_MARK = "<";
+const PLAIN_TYPESCRIPT = ".ts";
+const ALL_FUNCTIONS = "all";
+const babel: { toolchain: Promise<BabelToolchain> | undefined } = { toolchain: undefined };
+
+const loadBabelToolchain = async () => {
+    const [core, preset, plugin] = await Promise.all([
+        import("@babel/core"),
+        import("@babel/preset-typescript"),
+        import("babel-plugin-react-compiler"),
+    ]);
+
+    return {
+        presetTypescript: preset.default.default ?? preset.default,
+        reactCompiler: plugin.default.default ?? plugin.default,
+        transformAsync: core.transformAsync,
+    };
+};
+
+const babelToolchain = (): Promise<BabelToolchain> => (babel.toolchain ??= loadBabelToolchain());
 
 const isProjectSource = (root: string, id: string): boolean => {
     if (!SOURCE_EXTENSION.test(id)) {
@@ -33,15 +57,25 @@ const isProjectSource = (root: string, id: string): boolean => {
     return true;
 };
 
+const isMemoizable = (code: string, id: string, options: ResolvedReactCompilerOptions): boolean => {
+    if (options.compilationMode === ALL_FUNCTIONS || MEMOIZABLE_SOURCE.test(code)) {
+        return true;
+    }
+
+    return !id.endsWith(PLAIN_TYPESCRIPT) && code.includes(JSX_MARK);
+};
+
 const compileSource = async (code: string, id: string, options: ResolvedReactCompilerOptions) => {
-    const result = await transformAsync(code, {
+    const toolchain = await babelToolchain();
+
+    const result = await toolchain.transformAsync(code, {
         filename: id,
         babelrc: false,
         configFile: false,
         sourceMaps: true,
-        parserOpts: { plugins: id.endsWith(".ts") ? [] : ["jsx"] },
-        presets: TYPESCRIPT_EXTENSION.test(id) ? [babelPresetTypescript] : [],
-        plugins: [[babelPluginReactCompiler, options]],
+        parserOpts: { plugins: id.endsWith(PLAIN_TYPESCRIPT) ? [] : ["jsx"] },
+        presets: TYPESCRIPT_EXTENSION.test(id) ? [toolchain.presetTypescript] : [],
+        plugins: [[toolchain.reactCompiler, options]],
     });
 
     if (!result?.code) {
@@ -51,10 +85,33 @@ const compileSource = async (code: string, id: string, options: ResolvedReactCom
     return result.map == null ? { code: result.code } : { code: result.code, map: JSON.stringify(result.map) };
 };
 
+const cachedSource = async (
+    cache: ReactCompilerCache,
+    code: string,
+    id: string,
+    options: ResolvedReactCompilerOptions,
+): Promise<CompilerOutput | undefined> => {
+    const key = cache.keyFor(code, id);
+    const cached = cache.read(key);
+
+    if (cached !== undefined) {
+        return cached;
+    }
+
+    const compiled = await compileSource(code, id, options);
+
+    if (compiled !== undefined) {
+        cache.write(key, compiled);
+    }
+
+    return compiled;
+};
+
 function gtkxReactCompiler(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
     const state: ReactCompilerState = {
-        root: "",
+        cache: null,
         options: null,
+        root: "",
     };
 
     return {
@@ -62,22 +119,29 @@ function gtkxReactCompiler(loadConfig: ConfigLoader = createConfigLoader()): Plu
         enforce: "pre",
 
         async config(config: UserConfig) {
-            const resolved = await loadConfig.resolve(config.root ?? process.cwd());
+            const resolved = await loadConfig.resolve(viteProjectRoot(config));
             state.options = resolved.reactCompiler;
         },
 
         configResolved(config: ResolvedConfig) {
             state.root = config.root;
+            state.cache = state.options === null ? null : createReactCompilerCache(config.cacheDir, state.options);
         },
 
-        async transform(code, id) {
-            const options = state.options;
+        transform: {
+            filter: { id: { include: SOURCE_EXTENSION, exclude: NODE_MODULES } },
+
+            async handler(code, id) {
+                const options = state.options;
+
+                if (options === null || !isProjectSource(state.root, id) || !isMemoizable(code, id, options)) {
+                    return;
+                }
 
-            if (options === null || !isProjectSource(state.root, id)) {
-                return;
-            }
+                const cache = state.cache;
 
-            return compileSource(code, id, options);
+                return cache === null ? compileSource(code, id, options) : cachedSource(cache, code, id, options);
+            },
         },
     };
 }

package/src/vite-plugins/resource-shared.ts

@@ -8,6 +8,8 @@ const ICON_NAME_SEPARATOR = "\0icon=";
 const REFRESH_EXPORT = "__refresh";
 const REGISTER_REFRESH_EXPORT = "__registerRefresh";
 const RESOURCE_PATH_EXPORT = "path";
+const VIRTUAL_ID_RE = new RegExp(`^${VIRTUAL_PREFIX}`);
+const VIRTUAL_INIT_RE = new RegExp(`^${VIRTUAL_INIT}$`);
 const { isVirtual, toVirtualId, fromVirtualId } = createVirtualNamespace(VIRTUAL_PREFIX);
 
 const escapeXml = (value: string): string =>
@@ -32,7 +34,9 @@ const escapeXml = (value: string): string =>
     });
 
 export {
+    VIRTUAL_ID_RE,
     VIRTUAL_INIT,
+    VIRTUAL_INIT_RE,
     BUNDLE_FILENAME,
     REL_SEPARATOR,
     ICON_NAME_SEPARATOR,

package/src/vite-plugins/resources.ts

@@ -1,20 +1,17 @@
 import type { ConfigLoader } from "@gtkx/config";
 import type { ModuleNode, Plugin, ResolvedConfig, Rolldown, UserConfig, ViteDevServer } from "vite";
-import { createConfigLoader, resolveFuture, resourceBasePath } from "@gtkx/config/internal";
-import { error, info, isRecord, sortStrings } from "@gtkx/utils";
+import { createConfigLoader, resourceBasePath, viteProjectRoot } from "@gtkx/config/internal";
+import { error, info, isPathInside, isRecord, sortStrings, toPosixPath } from "@gtkx/utils";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, isAbsolute, join, posix, relative, sep } from "node:path";
 import { parseSync } from "vite";
-import { resolveDataDir } from "../internal/data-dir.js";
-import { type ListedFile, listFilesRecursive } from "../internal/list-files.js";
+import { withExclusiveLoad } from "../internal/module-loads.js";
 import { runCliTool } from "../internal/run-cli-tool.js";
 import { parseRuntimeImportsIn, type SourceImport, sourceLanguage } from "../internal/source-imports.js";
 import { createRetainedStagingDir, type RetainedStagingDir, withStagingDir } from "../internal/staging-dir.js";
 import { ASSET_RE } from "./asset-extensions.js";
 import {
-    DATA_PREFIX,
     isBareRelativeAsset,
-    isDataAsset,
     parseIconSpecifier,
     parseResourceSpecifier,
 } from "./asset-specifier.js";
@@ -30,7 +27,9 @@ import {
     REL_SEPARATOR,
     RESOURCE_PATH_EXPORT,
     toVirtualId,
+    VIRTUAL_ID_RE,
     VIRTUAL_INIT,
+    VIRTUAL_INIT_RE,
 } from "./resource-shared.js";
 import { stripQuery } from "./strip-query.js";
 
@@ -44,7 +43,6 @@ type PluginState = {
     prefix: string;
     root: string;
     isBuild: boolean;
-    isV2: boolean;
     entries: Map<string, ResourceEntry>;
     bundledSpecifiers: Map<string, Set<string>>;
     moduleDependencies: Map<string, Set<string>>;
@@ -58,7 +56,6 @@ type PluginState = {
     devBundlePath: string;
     server: ViteDevServer | null;
     compiledSignature: string;
-    dataDir: string | null;
     bundleReferenceId: string | null;
     iconOwners: Map<string, ResourceEntry>;
 };
@@ -118,7 +115,7 @@ type DerivedIconEntry = {
     resourcePath: string;
 };
 
-type LegacyResolveRequest = {
+type ResolveRequest = {
     source: string;
     importer: string | undefined;
     options: Record<string, unknown> | undefined;
@@ -128,6 +125,7 @@ const RESOURCE_COMPILER = "glib-compile-resources";
 const MANIFEST_PREFIX = "/";
 const DEV_STAGING_PREFIX = "resources-dev";
 const MANIFEST_FILENAME = "package.json";
+const DATA_PREFIX = "#data/";
 const BUNDLED_QUERY_MENTION_RE = /[?&](?:icon|resource)(?:[=&]|$)/;
 const ICON_EXTENSIONS: Set<string> = new Set([".png", ".svg", ".xpm"]);
 
@@ -164,16 +162,8 @@ const STOCK_ICON_CONTEXTS: Set<string> = new Set([
 const ICON_SIZE_RE = /^([1-9]\d*)x\1(?:@[1-9]\d*)?$/;
 const RESERVED_ICON_NAMES: Set<string> = new Set(["", ".", ".."]);
 
-const toForwardSlashes = (value: string): string => value.replaceAll(/[/\\]/g, "/");
-
-const isWithin = (root: string, path: string): boolean => {
-    const rel = relative(root, path);
-
-    return rel.length > 0 && !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
-};
-
 const isDependencyFile = (root: string, path: string): boolean =>
-    isWithin(root, path) && relative(root, path).split(sep).includes("node_modules");
+    isPathInside(root, path) && relative(root, path).split(sep).includes("node_modules");
 
 const packageIdentityIn = (dir: string): string | null => {
     try {
@@ -216,17 +206,17 @@ const validateResourcePath = (resourcePath: string): string => {
 };
 
 const derivedResourcePath = (state: PluginState, sourcePath: string): string => {
-    if (isWithin(state.root, sourcePath) && !isDependencyFile(state.root, sourcePath)) {
-        return validateResourcePath(`${state.prefix}/${toForwardSlashes(relative(state.root, sourcePath))}`);
+    if (isPathInside(state.root, sourcePath) && !isDependencyFile(state.root, sourcePath)) {
+        return validateResourcePath(`${state.prefix}/${toPosixPath(relative(state.root, sourcePath))}`);
     }
 
     const owner = packageForFile(sourcePath);
 
-    if (owner === null || !isWithin(owner.dir, sourcePath)) {
+    if (owner === null || !isPathInside(owner.dir, sourcePath)) {
         throw new Error(`${sourcePath} is outside the application and does not belong to a named package`);
     }
 
-    const packagePath = toForwardSlashes(relative(owner.dir, sourcePath));
+    const packagePath = toPosixPath(relative(owner.dir, sourcePath));
 
     return validateResourcePath(`${state.prefix}/${owner.name}/${packagePath}`);
 };
@@ -292,7 +282,7 @@ const iconLayoutInParts = (parts: string[], beforeIndex: number): string | null
 };
 
 const iconLayoutFromTree = (sourcePath: string): string | null => {
-    const parts = toForwardSlashes(sourcePath).split("/");
+    const parts = toPosixPath(sourcePath).split("/");
 
     return iconLayoutInParts(parts, parts.length - 2);
 };
@@ -335,11 +325,10 @@ const hasSideEffectIconImport = (code: string, id: string): boolean => {
 };
 
 const retainSideEffectIconImport = (
-    state: PluginState,
     code: string,
     id: string,
 ): { code: string; moduleSideEffects: true } | null =>
-    state.isV2 && hasSideEffectIconImport(code, id)
+    hasSideEffectIconImport(code, id)
         ? { code, moduleSideEffects: true }
         : null;
 
@@ -430,20 +419,6 @@ const refreshRegisteredDevBundle = (state: PluginState): void => {
     }
 };
 
-const scanDataAssets = (dataDir: string): ListedFile[] => listFilesRecursive(dataDir, (name) => ASSET_RE.test(name));
-
-const primeLegacyDevBundle = (state: PluginState): void => {
-    if (state.dataDir === null) {
-        return;
-    }
-
-    for (const { absPath, rel } of scanDataAssets(state.dataDir)) {
-        registerEntry(state, absPath, rel);
-    }
-
-    compileDevBundle(state);
-};
-
 const registerDevAsset = (state: PluginState): void => {
     if (entriesSignature(state) !== state.compiledSignature) {
         compileDevBundle(state);
@@ -490,7 +465,7 @@ const activateEntry = (state: PluginState, entry: ResourceEntry): ResourceEntry
 };
 
 const isDeclarativeImporter = (state: PluginState, importer: string | undefined): importer is string =>
-    !state.isBuild && state.isV2 && importer !== undefined;
+    !state.isBuild && importer !== undefined;
 
 const setSourceAvailability = (state: PluginState, file: string, isAvailable: boolean): void => {
     if (isAvailable) {
@@ -713,26 +688,6 @@ const resolveIconEntry = async (
     };
 };
 
-const resolveLegacyAssetEntry = async (
-    ctx: ResolveContext,
-    state: PluginState,
-    request: LegacyResolveRequest,
-): Promise<ResourceEntry | undefined> => {
-    const resolved = await ctx.resolve(request.source, request.importer, { ...request.options, skipSelf: true });
-
-    if (!resolved || resolved.external) {
-        return undefined;
-    }
-
-    const sourcePath = stripQuery(resolved.id);
-
-    if (!isAbsolute(sourcePath)) {
-        return undefined;
-    }
-
-    return registerEntry(state, sourcePath, request.source.slice(DATA_PREFIX.length));
-};
-
 const loadInitModule = (state: PluginState): string => {
     if (state.isBuild) {
         if (state.bundleReferenceId === null) {
@@ -831,8 +786,7 @@ const loadAssetModule = (state: PluginState, virtualId: string): string => {
     const { absPath, iconName, rel } = virtualAssetMetadata(virtualId);
     const resourcePath = validateResourcePath(rel);
     const { entry, isRegistered } = loadedResourceEntry(state, absPath, resourcePath);
-    const uri = `resource://${entry.resourcePath}`;
-    const defaultValue = iconName ?? (state.isV2 ? entry.resourcePath : uri);
+    const defaultValue = iconName ?? entry.resourcePath;
     compileLoadedDevAsset(state, isRegistered);
 
     return [
@@ -899,12 +853,12 @@ const isSourceModule = (file: string): boolean => sourceLanguage(file) !== undef
 const isBundledSource = (source: string): boolean =>
     parseResourceSpecifier(source) !== null || parseIconSpecifier(source) !== null;
 
-const validateUnbundledV2Source = (source: string): void => {
+const validateUnbundledSource = (source: string): void => {
     if (isLegacyDataSpecifier(source)) {
         throw new Error(`${JSON.stringify(source)} uses the legacy #data asset form`);
     }
 
-    rejectInvalidV2Specifier(source);
+    rejectInvalidSpecifier(source);
 };
 
 const resolvedModuleDependency = async (
@@ -916,7 +870,7 @@ const resolvedModuleDependency = async (
         return null;
     }
 
-    validateUnbundledV2Source(source);
+    validateUnbundledSource(source);
     const resolved = await ctx.resolve(source, importer, { skipSelf: true });
 
     if (resolved === null) {
@@ -952,7 +906,7 @@ const importerReconciliation = async (
     const file = stripQuery(id);
     const key = importerKey(file);
 
-    if (!state.isV2 || state.isBuild || !isSourceModule(file)) {
+    if (state.isBuild || !isSourceModule(file)) {
         return null;
     }
 
@@ -1171,35 +1125,16 @@ const forgetImporterDeclarations = (state: PluginState, importer: string): void
     state.declaredIcons.delete(importer);
 };
 
-const cloneStringSetMap = (source: Map<string, Set<string>>): Map<string, Set<string>> => {
-    const clone: Map<string, Set<string>> = new Map();
-
-    for (const [key, values] of source) {
-        clone.set(key, new Set(values));
-    }
-
-    return clone;
-};
-
-const cloneDeclarationMap = (
-    source: Map<string, Map<string, ResourceEntry>>,
-): Map<string, Map<string, ResourceEntry>> => {
-    const clone: Map<string, Map<string, ResourceEntry>> = new Map();
-
-    for (const [key, declarations] of source) {
-        clone.set(key, new Map(declarations));
-    }
-
-    return clone;
-};
+const cloneMapValues = <Value>(source: Map<string, Value>, clone: (value: Value) => Value): Map<string, Value> =>
+    new Map([...source].map(([key, value]) => [key, clone(value)]));
 
 const reconciliationCandidate = (state: PluginState): PluginState => ({
     ...state,
-    bundledSpecifiers: cloneStringSetMap(state.bundledSpecifiers),
-    moduleDependencies: cloneStringSetMap(state.moduleDependencies),
-    prunedDependencies: cloneStringSetMap(state.prunedDependencies),
-    declaredEntries: cloneDeclarationMap(state.declaredEntries),
-    declaredIcons: cloneDeclarationMap(state.declaredIcons),
+    bundledSpecifiers: cloneMapValues(state.bundledSpecifiers, (values) => new Set(values)),
+    moduleDependencies: cloneMapValues(state.moduleDependencies, (values) => new Set(values)),
+    prunedDependencies: cloneMapValues(state.prunedDependencies, (values) => new Set(values)),
+    declaredEntries: cloneMapValues(state.declaredEntries, (entries) => new Map(entries)),
+    declaredIcons: cloneMapValues(state.declaredIcons, (entries) => new Map(entries)),
     missingSourcePaths: new Set(state.missingSourcePaths),
 });
 
@@ -1333,7 +1268,7 @@ const commitReconciliation = (state: PluginState, candidate: PluginState): void
     state.iconOwners = candidate.iconOwners;
 };
 
-const reconcileV2Importer = async (ctx: ResolveContext, state: PluginState, id: string): Promise<void> => {
+const reconcileImporter = async (ctx: ResolveContext, state: PluginState, id: string): Promise<void> => {
     const reconciliation = await importerReconciliation(ctx, state, id);
 
     if (reconciliation === null) {
@@ -1350,10 +1285,9 @@ const reconcileV2Importer = async (ctx: ResolveContext, state: PluginState, id:
 };
 
 const resolveResourceConfig = async (state: PluginState, config: UserConfig, loadConfig: ConfigLoader) => {
-    const loaded = await loadConfig.load(config.root ?? process.cwd());
+    const loaded = await loadConfig.load(viteProjectRoot(config));
     state.prefix = resourceBasePath(loaded.config.applicationId);
     state.root = loaded.root;
-    state.isV2 = resolveFuture(loaded.config.future).isResourceImported;
 
     return {
         assetsInclude: [ASSET_RE],
@@ -1423,14 +1357,6 @@ const attachResourceWatcher = (state: PluginState, server: ViteDevServer): void
 const applyResolvedConfig = (state: PluginState, config: ResolvedConfig): void => {
     state.isBuild = config.command === "build";
     state.root = config.root;
-    state.dataDir = null;
-
-    if (state.isBuild || state.isV2) {
-        return;
-    }
-
-    const relativeDataDir = resolveDataDir(config.root);
-    state.dataDir = relativeDataDir === null ? null : join(config.root, relativeDataDir);
 };
 
 const loadResourceModule = (state: PluginState, id: string): string | undefined => {
@@ -1448,7 +1374,7 @@ const loadResourceModule = (state: PluginState, id: string): string | undefined
 const isLegacyDataSpecifier = (source: string): boolean =>
     source.startsWith(DATA_PREFIX) && ASSET_RE.test(stripQuery(source));
 
-const rejectInvalidV2Specifier = (source: string): void => {
+const rejectInvalidSpecifier = (source: string): void => {
     if (BUNDLED_QUERY_MENTION_RE.test(source)) {
         throw new Error(
             `${JSON.stringify(source)} is not a valid bundled asset import; use ?resource, ` +
@@ -1459,7 +1385,7 @@ const rejectInvalidV2Specifier = (source: string): void => {
     if (isBareRelativeAsset(source)) {
         throw new Error(
             `${JSON.stringify(source)} must choose ?resource for a GResource, ?icon for a themed icon, ` +
-            "or ?url for an emitted file",
+            "?font for a bundled font, or ?url for an emitted file",
         );
     }
 };
@@ -1467,7 +1393,7 @@ const rejectInvalidV2Specifier = (source: string): void => {
 const resolveExplicitResourceId = async (
     ctx: ResolveContext,
     state: PluginState,
-    request: LegacyResolveRequest,
+    request: ResolveRequest,
 ): Promise<string | undefined> => {
     const specifier = parseResourceSpecifier(request.source);
 
@@ -1488,7 +1414,7 @@ const resolveExplicitResourceId = async (
 const resolveIconResourceId = async (
     ctx: ResolveContext,
     state: PluginState,
-    request: LegacyResolveRequest,
+    request: ResolveRequest,
 ): Promise<RetainedIconModuleId | undefined> => {
     const specifier = parseIconSpecifier(request.source);
 
@@ -1508,10 +1434,10 @@ const resolveIconResourceId = async (
         : { id: virtualIconId(resolved), moduleSideEffects: true };
 };
 
-const resolveV2ResourceId = async (
+const resolveBundledResourceId = async (
     ctx: ResolveContext,
     state: PluginState,
-    request: LegacyResolveRequest,
+    request: ResolveRequest,
 ): Promise<ResourceModuleId | undefined> => {
     if (isLegacyDataSpecifier(request.source)) {
         throw new Error(
@@ -1534,46 +1460,21 @@ const resolveV2ResourceId = async (
         return resolved;
     }
 
-    rejectInvalidV2Specifier(request.source);
+    rejectInvalidSpecifier(request.source);
 
     return undefined;
 };
 
-const resolveLegacyResourceId = async (
-    ctx: ResolveContext,
-    state: PluginState,
-    request: LegacyResolveRequest,
-): Promise<string | undefined> => {
-    if (BUNDLED_QUERY_MENTION_RE.test(request.source)) {
-        throw new Error(`${JSON.stringify(request.source)} requires future.v2ResourceImports`);
-    }
-
-    if (!isDataAsset(request.source)) {
-        return undefined;
-    }
-
-    const entry = await resolveLegacyAssetEntry(ctx, state, request);
-
-    return entry === undefined ? undefined : virtualAssetId(entry);
-};
-
 const resolveResourceId = (
     ctx: ResolveContext,
     state: PluginState,
-    request: LegacyResolveRequest,
+    request: ResolveRequest,
 ): Promise<ResourceModuleId | undefined> => {
     if (request.source === VIRTUAL_INIT) {
         return Promise.resolve(VIRTUAL_INIT);
     }
 
-    return state.isV2
-        ? resolveV2ResourceId(ctx, state, request)
-        : resolveLegacyResourceId(ctx, state, request);
-};
-
-const configureResourceServer = (state: PluginState, server: ViteDevServer): void => {
-    attachResourceWatcher(state, server);
-    primeLegacyDevBundle(state);
+    return resolveBundledResourceId(ctx, state, request);
 };
 
 const createResourcesPlugin = (state: PluginState, loadConfig: ConfigLoader): Plugin => ({
@@ -1588,7 +1489,7 @@ const createResourcesPlugin = (state: PluginState, loadConfig: ConfigLoader): Pl
     },
 
     configureServer: (server) => {
-        configureResourceServer(state, server);
+        attachResourceWatcher(state, server);
     },
 
     buildStart() {
@@ -1605,14 +1506,18 @@ const createResourcesPlugin = (state: PluginState, loadConfig: ConfigLoader): Pl
         return resolveResourceId(this, state, { source, importer, options });
     },
 
-    load(id) {
-        return loadResourceModule(state, id);
+    load: {
+        filter: { id: { include: [VIRTUAL_INIT_RE, VIRTUAL_ID_RE] } },
+
+        handler(id) {
+            return loadResourceModule(state, id);
+        },
     },
 
     async transform(code, id) {
-        await reconcileV2Importer(this, state, id);
+        await withExclusiveLoad(state, () => reconcileImporter(this, state, id));
 
-        return retainSideEffectIconImport(state, code, id);
+        return retainSideEffectIconImport(code, id);
     },
 
     generateBundle(_options, bundle) {
@@ -1629,7 +1534,6 @@ function gtkxResources(loadConfig: ConfigLoader = createConfigLoader(), entryPat
         prefix: "",
         root: "",
         isBuild: false,
-        isV2: false,
         entries: new Map(),
         bundledSpecifiers: new Map(),
         moduleDependencies: new Map(),
@@ -1643,7 +1547,6 @@ function gtkxResources(loadConfig: ConfigLoader = createConfigLoader(), entryPat
         devBundlePath: "",
         server: null,
         compiledSignature: "",
-        dataDir: null,
         bundleReferenceId: null,
         iconOwners: new Map(),
     };