@gtkx/cli 1.4.0 → 1.6.0

package/src/mcp/handlers.ts

@@ -3,6 +3,7 @@ import {
     invalidRequestError,
     methodNotFoundError,
     type ParamsSchema,
+    type Result,
     type ServerInitiatedMethod,
     type ServerRequestParams,
     ServerRequestParamsSchemas,
@@ -18,10 +19,10 @@ type HandlerContext = {
     registry: WidgetRegistry;
 };
 
-type ValidatedHandler = (ctx: HandlerContext, params: unknown) => Promise<unknown>;
+type ValidatedHandler = (ctx: HandlerContext, params: unknown) => Promise<Result>;
 type WidgetTarget = { testing: TestingModule; widget: Gtk.Widget };
 type WidgetParams = { widgetId?: string | undefined };
-type TargetedHandler<Params> = (ctx: HandlerContext, target: WidgetTarget, params: Params) => Promise<unknown>;
+type TargetedHandler<Params> = (ctx: HandlerContext, target: WidgetTarget, params: Params) => Promise<Result>;
 type QueryParams = ServerRequestParams<"widget.query">;
 type QueryBy = QueryParams["by"];
 type QueryRunner = (testing: TestingModule, app: Gtk.Application, params: QueryParams) => Promise<Gtk.Widget[]>;
@@ -110,7 +111,7 @@ const SEARCHED_BY: Record<QueryBy, string> = {
 
 function validated<Params>(
     schema: ParamsSchema<Params>,
-    handler: (ctx: HandlerContext, params: Params) => Promise<unknown>,
+    handler: (ctx: HandlerContext, params: Params) => Promise<Result>,
 ): ValidatedHandler {
     return (ctx, params) => {
         const parsed = schema.safeParse(params ?? {});
@@ -229,7 +230,7 @@ const emptyQueryHint = (params: QueryParams): string =>
     "Call gtkx_get_widget_tree to see what is mounted; by:\"name\" is the widest match, and by:\"role\" accepts " +
     "options.name to match the accessible name of a known role.";
 
-async function handleQuery({ app, registry }: HandlerContext, params: QueryParams): Promise<unknown> {
+async function handleQuery({ app, registry }: HandlerContext, params: QueryParams): Promise<Result> {
     const testing = await loadTestingModule();
     const widgets = await QUERY_RUNNERS[params.by](testing, app, params);
     const resolveId = (widget: Gtk.Widget): string => registry.getOrCreateId(widget);
@@ -254,7 +255,7 @@ const defaultScreenshotTarget = (registry: WidgetRegistry): Gtk.Widget => {
 async function handleScreenshot(
     { registry }: HandlerContext,
     params: ServerRequestParams<"widget.screenshot">,
-): Promise<unknown> {
+): Promise<Result> {
     const testing = await loadTestingModule();
     const target = params.windowId ? requireWidget(registry, params.windowId) : defaultScreenshotTarget(registry);
     const result = await testing.screenshot(target, { path: params.path });
@@ -269,7 +270,7 @@ async function handleScreenshot(
 const isServerInitiatedMethod = (method: string): method is ServerInitiatedMethod =>
     Object.hasOwn(ServerRequestParamsSchemas, method);
 
-const dispatch = async (method: string, params: unknown, ctx: HandlerContext): Promise<unknown> => {
+const dispatch = async (method: string, params: unknown, ctx: HandlerContext): Promise<Result> => {
     if (!isServerInitiatedMethod(method)) {
         throw methodNotFoundError(method);
     }

package/src/settings/render.ts

@@ -13,6 +13,10 @@ type EnvAssetDeclarations = {
     resources: string[];
 };
 
+type EnvModuleOptions = {
+    references?: string[];
+};
+
 const GTKX_ENV_MODULE_HEADER = `/**
  * Project import declarations generated by GTKX. Regenerated by
  * \`gtkx codegen\`, \`gtkx dev\`, and \`gtkx build\`; do not edit.
@@ -226,6 +230,7 @@ const renderBlockedAssetModule = (specifier: string): string => [
 const renderEnvModule = (
     files: ParsedSchemaFile[],
     assetDeclarations?: EnvAssetDeclarations,
+    options: EnvModuleOptions = {},
 ): string => {
     const assets = assetDeclarations ?? { blocked: [], icons: [], legacy: [], resources: [] };
     const usedNames: Set<string> = new Set();
@@ -238,8 +243,17 @@ const renderEnvModule = (
     const icons = assets.icons.map((specifier) => renderIconModule(specifier));
     const legacy = assets.legacy.map((specifier) => renderLegacyAssetModule(specifier));
     const resources = assets.resources.map((specifier) => renderResourceModule(specifier));
-
-    return `${[GTKX_ENV_MODULE_HEADER, ...blocked, ...icons, ...legacy, ...resources, ...schemas].join("\n\n")}\n`;
+    const references = (options.references ?? []).map((path) => `/// <reference path=${JSON.stringify(path)} />`);
+
+    return `${[
+        GTKX_ENV_MODULE_HEADER,
+        ...references,
+        ...blocked,
+        ...icons,
+        ...legacy,
+        ...resources,
+        ...schemas,
+    ].join("\n\n")}\n`;
 };
 
 export { renderRuntimeModule, renderEnvModule };

package/src/settings/schema.ts

@@ -13,6 +13,7 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { I18N_TYPES_FILENAME, i18nTypesPath } from "../i18n/types.js";
 import { DATA_IMPORT_PREFIX } from "../internal/data-dir.js";
 import { discoverSourceImports, type SourceImport } from "../internal/source-imports.js";
 import { removeTempDir } from "../internal/staging-dir.js";
@@ -323,7 +324,8 @@ const emitSchemaEnv = (
     assertUniqueSchemaBasenames(importedFiles);
     const imported = parseProjectSchemas(importedFiles, getRelativeModuleSpecifier);
     const assets = findAssetModuleSpecifiers(imports, isV2ResourceImports);
-    const content = renderEnvModule([...legacy, ...imported], assets);
+    const references = existsSync(i18nTypesPath(rootDir)) ? [`./${I18N_TYPES_FILENAME}`] : [];
+    const content = renderEnvModule([...legacy, ...imported], assets, { references });
     const path = schemaEnvPath(rootDir);
     const isWritten = didWriteChanges(path, content);
 

package/src/vite-plugins/animated.ts

@@ -0,0 +1,486 @@
+import type { ConfigLoader } from "@gtkx/config";
+import type { Plugin, UserConfig } from "vite";
+import { type GeneratedElement, readGeneratedElements } from "@gtkx/codegen";
+import { createConfigLoader } from "@gtkx/config/internal";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { parseSync } from "vite";
+import { sourceLanguage } from "../internal/source-imports.js";
+import { stripQuery } from "./strip-query.js";
+
+type AstNode = {
+    type: string;
+    start: number;
+    end: number;
+} & Record<string, unknown>;
+
+type Edit = {
+    start: number;
+    end: number;
+    replacement: string;
+};
+
+type Rewrite = {
+    edits: Edit[];
+    hasMemberEdits: boolean;
+    hasCallEdits: boolean;
+    hasDynamicUses: boolean;
+};
+
+type RewrittenModule = { code: string; hasDynamicUses: boolean; hasMemberEdits: boolean };
+
+type PluginState = {
+    isEnabled: boolean;
+    isBuild: boolean;
+    root: string;
+    elements: Map<string, GeneratedElement> | null;
+};
+
+const ANIMATED_PACKAGE = "@gtkx/animated";
+const INTERNAL_SPECIFIER = "@gtkx/animated/internal";
+const VIRTUAL_ID = "virtual:gtkx-animated";
+const RESOLVED_VIRTUAL_ID = `\0${VIRTUAL_ID}`;
+const NAMESPACE_HELPER = "__gtkxAnimated";
+const CALL_HELPER = "__gtkxWithAnimated";
+
+const BINDING_PARENT_KEYS: Record<string, string> = {
+    VariableDeclarator: "id",
+    ImportSpecifier: "local",
+    ImportDefaultSpecifier: "local",
+    ImportNamespaceSpecifier: "local",
+    FunctionDeclaration: "id",
+    ClassDeclaration: "id",
+    CatchClause: "param",
+    AssignmentPattern: "left",
+    RestElement: "argument",
+    Property: "value",
+};
+
+const BINDING_PARENT_ARRAY_KEYS: Record<string, string> = {
+    ArrowFunctionExpression: "params",
+    FunctionDeclaration: "params",
+    FunctionExpression: "params",
+    ArrayPattern: "elements",
+};
+
+const isAstNode = (value: unknown): value is AstNode =>
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as AstNode).type === "string" &&
+    typeof (value as AstNode).start === "number" &&
+    typeof (value as AstNode).end === "number";
+
+const walkChildren = (node: AstNode, visit: (node: AstNode, parent: AstNode | null) => void): void => {
+    for (const [key, child] of Object.entries(node)) {
+        if (key !== "type") {
+            walk(child, node, visit);
+        }
+    }
+};
+
+const walk = (value: unknown, parent: AstNode | null, visit: (node: AstNode, parent: AstNode | null) => void): void => {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            walk(item, parent, visit);
+        }
+
+        return;
+    }
+
+    if (!isAstNode(value)) {
+        return;
+    }
+
+    visit(value, parent);
+    walkChildren(value, visit);
+};
+
+const identifierName = (node: unknown): string | undefined => {
+    if (!isAstNode(node)) {
+        return undefined;
+    }
+
+    if (node.type !== "Identifier" && node.type !== "JSXIdentifier") {
+        return undefined;
+    }
+
+    return typeof node.name === "string" ? node.name : undefined;
+};
+
+const isValueImportSpecifier = (specifier: unknown): specifier is AstNode =>
+    isAstNode(specifier) && specifier.type === "ImportSpecifier" && specifier.importKind !== "type";
+
+const animatedSpecifierLocal = (node: AstNode): string | undefined => {
+    const specifiers = (node.specifiers as unknown[] | undefined) ?? [];
+    let local: string | undefined;
+
+    for (const specifier of specifiers) {
+        if (isValueImportSpecifier(specifier) && identifierName(specifier.imported) === "animated") {
+            local ??= identifierName(specifier.local);
+        }
+    }
+
+    return local;
+};
+
+const animatedLocalName = (program: AstNode): string | undefined => {
+    let local: string | undefined;
+
+    walk(program, null, (node) => {
+        if (node.type !== "ImportDeclaration" || (node.source as AstNode | undefined)?.value !== ANIMATED_PACKAGE) {
+            return;
+        }
+
+        if (node.importKind === "type") {
+            return;
+        }
+
+        local ??= animatedSpecifierLocal(node);
+    });
+
+    return local;
+};
+
+const isBindingSlot = (node: AstNode, parent: AstNode): boolean => {
+    const key = BINDING_PARENT_KEYS[parent.type];
+
+    return key !== undefined && parent[key] === node;
+};
+
+const isBindingListEntry = (node: AstNode, parent: AstNode): boolean => {
+    const arrayKey = BINDING_PARENT_ARRAY_KEYS[parent.type];
+    const entries = arrayKey === undefined ? undefined : parent[arrayKey];
+
+    return Array.isArray(entries) && entries.includes(node);
+};
+
+const isBindingParent = (node: AstNode, parent: AstNode): boolean =>
+    isBindingSlot(node, parent) || isBindingListEntry(node, parent);
+
+const isBindingNamed = (node: AstNode, parent: AstNode, name: string): boolean =>
+    node.type === "Identifier" &&
+    node.name === name &&
+    isBindingParent(node, parent);
+
+const countDeclarations = (program: AstNode, name: string): number => {
+    const spans: Set<number> = new Set();
+
+    walk(program, null, (node, parent) => {
+        if (parent !== null && isBindingNamed(node, parent, name)) {
+            spans.add(node.start);
+        }
+    });
+
+    return spans.size;
+};
+
+const isRewritableJsxMember = (node: AstNode, local: string): boolean =>
+    node.type === "JSXMemberExpression" && identifierName(node.object) === local;
+
+const isRewritableObjectMember = (node: AstNode, local: string): boolean =>
+    node.type === "MemberExpression" &&
+    node.computed !== true &&
+    node.optional !== true &&
+    identifierName(node.object) === local;
+
+const isForbiddenTarget = (node: AstNode, parent: AstNode | null): boolean =>
+    parent !== null &&
+    ((parent.type === "AssignmentExpression" && parent.left === node) ||
+        (parent.type === "UpdateExpression" && parent.argument === node) ||
+        (parent.type === "UnaryExpression" && parent.operator === "delete" && parent.argument === node));
+
+const isRewritableMember = (node: AstNode, parent: AstNode | null, local: string): boolean => {
+    if (isRewritableJsxMember(node, local)) {
+        return true;
+    }
+
+    return isRewritableObjectMember(node, local) && !isForbiddenTarget(node, parent);
+};
+
+const collectMemberEdit = (
+    rewrite: Rewrite,
+    claimed: Set<number>,
+    node: AstNode,
+    elements: Map<string, GeneratedElement>,
+): void => {
+    const property = identifierName(node.property);
+
+    if (property !== undefined && elements.get(property)?.isMountable === true) {
+        const object = node.object as AstNode;
+        rewrite.edits.push({ start: object.start, end: object.end, replacement: NAMESPACE_HELPER });
+        rewrite.hasMemberEdits = true;
+        claimed.add(object.start);
+    }
+};
+
+const collectCallEdit = (rewrite: Rewrite, claimed: Set<number>, node: AstNode): void => {
+    const callee = node.callee as AstNode;
+    rewrite.edits.push({ start: callee.start, end: callee.end, replacement: CALL_HELPER });
+    rewrite.hasCallEdits = true;
+    claimed.add(callee.start);
+};
+
+const isPropertyReference = (node: AstNode, parent: AstNode | null): boolean =>
+    parent?.type === "ImportSpecifier" ||
+    (parent?.type === "MemberExpression" && parent.property === node) ||
+    (parent?.type === "JSXMemberExpression" && parent.property === node);
+
+const hasDynamicUse = (program: AstNode, local: string, claimed: Set<number>): boolean => {
+    let isFound = false;
+
+    walk(program, null, (node, parent) => {
+        if (identifierName(node) === local && !claimed.has(node.start) && !isPropertyReference(node, parent)) {
+            isFound = true;
+        }
+    });
+
+    return isFound;
+};
+
+const collectRewrite = (program: AstNode, local: string, elements: Map<string, GeneratedElement>): Rewrite => {
+    const rewrite: Rewrite = { edits: [], hasMemberEdits: false, hasCallEdits: false, hasDynamicUses: false };
+    const claimed: Set<number> = new Set();
+
+    walk(program, null, (node, parent) => {
+        if (isRewritableMember(node, parent, local)) {
+            collectMemberEdit(rewrite, claimed, node, elements);
+
+            return;
+        }
+
+        if (node.type === "CallExpression" && identifierName(node.callee) === local) {
+            collectCallEdit(rewrite, claimed, node);
+        }
+    });
+
+    rewrite.hasDynamicUses = hasDynamicUse(program, local, claimed);
+
+    return rewrite;
+};
+
+const lastImportEnd = (program: AstNode): number => {
+    const statements = (program.body as unknown[] | undefined) ?? [];
+    let end = 0;
+
+    for (const statement of statements) {
+        if (isAstNode(statement) && statement.type === "ImportDeclaration") {
+            end = Math.max(end, statement.end);
+        }
+    }
+
+    return end;
+};
+
+const helperImports = (rewrite: Rewrite): string => {
+    const lines: string[] = [];
+
+    if (rewrite.hasMemberEdits) {
+        lines.push(`import * as ${NAMESPACE_HELPER} from ${JSON.stringify(VIRTUAL_ID)};`);
+    }
+
+    if (rewrite.hasCallEdits) {
+        lines.push(`import { withAnimated as ${CALL_HELPER} } from ${JSON.stringify(INTERNAL_SPECIFIER)};`);
+    }
+
+    return lines.join("\n");
+};
+
+const applyEdits = (code: string, edits: Edit[]): string => {
+    const ordered = edits.toSorted((a, b) => b.start - a.start);
+    let result = code;
+
+    for (const edit of ordered) {
+        result = `${result.slice(0, edit.start)}${edit.replacement}${result.slice(edit.end)}`;
+    }
+
+    return result;
+};
+
+const parseProgram = (path: string, code: string): AstNode | undefined => {
+    const lang = sourceLanguage(path);
+
+    if (lang === undefined) {
+        return undefined;
+    }
+
+    const parsed = parseSync(path, code, { lang });
+
+    return parsed.errors.length > 0 ? undefined : (parsed.program as unknown as AstNode);
+};
+
+const unchangedRewrite = (code: string, rewrite: Rewrite): RewrittenModule | undefined =>
+    rewrite.hasDynamicUses ? { code, hasDynamicUses: true, hasMemberEdits: false } : undefined;
+
+const hasHelperCollision = (code: string): boolean =>
+    code.includes(NAMESPACE_HELPER) || code.includes(CALL_HELPER);
+
+const rewriteModule = (
+    code: string,
+    id: string,
+    elements: Map<string, GeneratedElement>,
+): RewrittenModule | undefined => {
+    if (hasHelperCollision(code)) {
+        return undefined;
+    }
+
+    const program = parseProgram(stripQuery(id), code);
+
+    if (program === undefined) {
+        return undefined;
+    }
+
+    const local = animatedLocalName(program);
+
+    if (local === undefined || countDeclarations(program, local) > 1) {
+        return undefined;
+    }
+
+    const rewrite = collectRewrite(program, local, elements);
+
+    if (rewrite.edits.length === 0) {
+        return unchangedRewrite(code, rewrite);
+    }
+
+    const insertAt = lastImportEnd(program);
+    const helperEdit: Edit = { start: insertAt, end: insertAt, replacement: `\n${helperImports(rewrite)}` };
+    const withHelpers = applyEdits(code, [...rewrite.edits, helperEdit]);
+
+    return { code: withHelpers, hasDynamicUses: rewrite.hasDynamicUses, hasMemberEdits: rewrite.hasMemberEdits };
+};
+
+const renderVirtualModule = (elements: Map<string, GeneratedElement>): string => {
+    const mountable = elements.values().filter((element) => element.isMountable).toArray();
+    const imports = mountable.map((element) => `${element.glibName} as $${element.glibName}`);
+
+    const consts = mountable.map(
+        (element) => `export const ${element.glibName} = /* @__PURE__ */ withAnimated($${element.glibName});`,
+    );
+
+    return (
+        `import { ${imports.join(", ")} } from "@gtkx/jsx";\n` +
+        `import { withAnimated } from ${JSON.stringify(INTERNAL_SPECIFIER)};\n` +
+        `${consts.join("\n")}\n`
+    );
+};
+
+const loadElements = (state: PluginState): Map<string, GeneratedElement> | null => {
+    if (state.elements !== null) {
+        return state.elements;
+    }
+
+    try {
+        const requireFromRoot = createRequire(join(state.root, "package.json"));
+        const jsxStoreDir = dirname(requireFromRoot.resolve("@gtkx/jsx/package.json"));
+        state.elements = new Map(readGeneratedElements(jsxStoreDir).map((element) => [element.glibName, element]));
+    } catch {
+        return null;
+    }
+
+    return state.elements;
+};
+
+const resolveVirtualId = (state: PluginState, source: string): string | undefined => {
+    if (source === VIRTUAL_ID && state.isEnabled) {
+        return RESOLVED_VIRTUAL_ID;
+    }
+
+    return undefined;
+};
+
+const loadVirtualModule = (state: PluginState, id: string): string | undefined => {
+    if (id !== RESOLVED_VIRTUAL_ID || !state.isEnabled) {
+        return undefined;
+    }
+
+    const elements = loadElements(state);
+
+    return elements === null ? undefined : renderVirtualModule(elements);
+};
+
+const dynamicUseWarning = (id: string, hasDynamicUses: boolean): string[] =>
+    hasDynamicUses
+        ? [
+                `${stripQuery(id)} uses the animated binding dynamically, which keeps the whole generated ` +
+                "widget namespace in the bundle; use animated(Component) calls to let unused widgets be dropped",
+            ]
+        : [];
+
+const memberUseWarning = (id: string, hasMemberEdits: boolean): string[] =>
+    hasMemberEdits
+        ? [
+                `${stripQuery(id)} reads widget components off the animated binding, which GTKX 2.0 removes; ` +
+                "import the component and call animated(Component) instead",
+            ]
+        : [];
+
+const warningsFor = (state: PluginState, id: string, rewritten: RewrittenModule): string[] =>
+    state.isBuild
+        ? [
+                ...dynamicUseWarning(id, rewritten.hasDynamicUses),
+                ...memberUseWarning(id, rewritten.hasMemberEdits),
+            ]
+        : [];
+
+const transformCode = (
+    state: PluginState,
+    code: string,
+    id: string,
+): { code: string; warnings: string[] } | undefined => {
+    if (!state.isEnabled || id.startsWith("\0") || !code.includes(ANIMATED_PACKAGE)) {
+        return undefined;
+    }
+
+    const elements = loadElements(state);
+
+    if (elements === null) {
+        return undefined;
+    }
+
+    const rewritten = rewriteModule(code, id, elements);
+
+    if (rewritten === undefined) {
+        return undefined;
+    }
+
+    return { code: rewritten.code, warnings: warningsFor(state, id, rewritten) };
+};
+
+function gtkxAnimated(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
+    const state: PluginState = { isEnabled: false, isBuild: false, root: process.cwd(), elements: null };
+
+    return {
+        name: "gtkx:animated",
+        enforce: "pre",
+
+        async config(config: UserConfig) {
+            const loaded = await loadConfig.load(config.root ?? process.cwd());
+            state.isEnabled = loaded.config.future?.v2TreeShaking === true;
+        },
+
+        configResolved(config) {
+            state.root = config.root;
+            state.isBuild = config.command === "build";
+        },
+
+        resolveId(source) {
+            return resolveVirtualId(state, source);
+        },
+
+        load(id) {
+            return loadVirtualModule(state, id);
+        },
+
+        transform(code, id) {
+            const result = transformCode(state, code, id);
+            const warnings = result?.warnings ?? [];
+
+            for (const warning of warnings) {
+                this.warn(warning);
+            }
+
+            return result?.code;
+        },
+    };
+}
+
+export { gtkxAnimated };

package/src/vite-plugins/asset-imports.ts

@@ -1,8 +1,8 @@
 import type { ConfigLoader } from "@gtkx/config";
-import type { ParseResult, ParserOptions, Plugin, UserConfig } from "vite";
-import { createConfigLoader } from "@gtkx/config/internal";
-import { extname } from "node:path";
+import type { ParseResult, Plugin, UserConfig } from "vite";
+import { createConfigLoader, resolveFuture } from "@gtkx/config/internal";
 import { parseSync } from "vite";
+import { sourceLanguage } from "../internal/source-imports.js";
 import { ASSET_MENTION_RE } from "./asset-extensions.js";
 import {
     DATA_PREFIX,
@@ -15,7 +15,6 @@ import {
 import { RESOURCE_PATH_EXPORT } from "./resource-shared.js";
 import { stripQuery } from "./strip-query.js";
 
-type SourceLanguage = NonNullable<ParserOptions["lang"]>;
 type ParsedModule = ParseResult["module"];
 type ImportStatement = ParsedModule["staticImports"][number];
 type ExportStatement = ParsedModule["staticExports"][number];
@@ -24,17 +23,6 @@ type BindingEntry = { importName: { name: string | null }; isType: boolean };
 type NamedBinding = { name: string; source: string };
 type PluginState = { isV2: boolean };
 
-const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
-    [".cjs", "jsx"],
-    [".cts", "ts"],
-    [".js", "jsx"],
-    [".jsx", "jsx"],
-    [".mjs", "jsx"],
-    [".mts", "ts"],
-    [".ts", "ts"],
-    [".tsx", "tsx"],
-]);
-
 const NODE_MODULES = /(?:^|\/)node_modules\//;
 const VIRTUAL_PREFIX = "\0";
 const DEFAULT_BINDING = "default";
@@ -135,7 +123,7 @@ const hasCheckedAssetMention = (code: string): boolean => ASSET_MENTION_RE.test(
 
 const checkAssetImports = (code: string, id: string, isV2: boolean): void => {
     const path = stripQuery(id);
-    const lang = SOURCE_LANGUAGES.get(extname(path).toLowerCase());
+    const lang = sourceLanguage(path);
 
     if (lang === undefined || !isCheckedSource(path) || !hasCheckedAssetMention(code)) {
         return;
@@ -163,7 +151,7 @@ function gtkxAssetImports(loadConfig: ConfigLoader = createConfigLoader()): Plug
 
         async config(config: UserConfig) {
             const loaded = await loadConfig.load(config.root ?? process.cwd());
-            state.isV2 = loaded.config.future?.v2ResourceImports === true;
+            state.isV2 = resolveFuture(loaded.config.future).isResourceImported;
         },
 
         transform(code, id) {