@gtkx/cli 1.3.0 → 1.4.0

package/src/mcp/widget-properties.ts

@@ -6,13 +6,14 @@ import {
     getHandle,
     getInstanceType,
     type Handle,
+    isReadableProperty,
     TYPE_ENUM,
     TYPE_FLAGS,
     typeIsA,
     typeName,
 } from "@gtkx/runtime";
 import { fromValue, getValueType } from "@gtkx/runtime/internal";
-import { camelCase, errorMessage, kebabCase } from "@gtkx/utils";
+import { errorMessage, kebabCase } from "@gtkx/utils";
 import type { WidgetRegistry } from "./widget-registry.js";
 
 type PropertyRepresentation = Omit<SerializedProperty, "type">;
@@ -39,18 +40,6 @@ function prototypesFor(widget: Gtk.Widget): object[] {
     return prototypes;
 }
 
-function getAccessor(widget: Gtk.Widget, member: string): PropertyDescriptor | undefined {
-    for (const prototype of prototypesFor(widget)) {
-        const descriptor = Object.getOwnPropertyDescriptor(prototype, member);
-
-        if (descriptor !== undefined) {
-            return descriptor;
-        }
-    }
-
-    return undefined;
-}
-
 function getReadableNames(prototype: object): string[] {
     const descriptors = Object.entries(Object.getOwnPropertyDescriptors(prototype));
 
@@ -64,7 +53,7 @@ function readablePropertyNames(widget: Gtk.Widget): string[] {
 }
 
 const requireReadableProperty = (widget: Gtk.Widget, property: string): void => {
-    if (getAccessor(widget, camelCase(property))?.get !== undefined) {
+    if (isReadableProperty(getInstanceType(widget), property)) {
         return;
     }
 

package/src/settings/render.ts

@@ -1,19 +1,56 @@
-import { upperFirst } from "@gtkx/utils";
+import { camelCase, sanitizeIdentifier, upperFirst } from "@gtkx/utils";
 import type { ParsedKey, ParsedSchema, ParsedSchemaFile } from "./parser.js";
 
+type NamedSchema = {
+    schema: ParsedSchema;
+    exportName: string;
+};
+
+type EnvAssetDeclarations = {
+    blocked: string[];
+    icons: string[];
+    legacy: string[];
+    resources: string[];
+};
+
 const GTKX_ENV_MODULE_HEADER = `/**
- * GSettings schema modules generated by GTKX from the project's
- * \`.gschema.xml\` files. Regenerated by \`gtkx codegen\`, \`gtkx dev\`, and
- * \`gtkx build\`; do not edit.
+ * Project import declarations generated by GTKX. Regenerated by
+ * \`gtkx codegen\`, \`gtkx dev\`, and \`gtkx build\`; do not edit.
  */`;
 
 const ENUM_KIND = "enum";
 const FLAGS_KIND = "flags";
+const ID_SEPARATOR = /[._]/;
+const NAME_SEPARATOR = "_";
 
 const toJsStringLiteral = (value: string): string =>
     JSON.stringify(value).replaceAll("\u{2028}", String.raw`\u2028`).replaceAll("\u{2029}", String.raw`\u2029`);
 
-const getExportName = (schemaId: string): string => schemaId.replaceAll(".", "_");
+const getExportName = (schemaId: string): string =>
+    sanitizeIdentifier(schemaId.split(ID_SEPARATOR).map((part) => camelCase(part)).join(NAME_SEPARATOR));
+
+const collisionError = (file: ParsedSchemaFile, taken: string, schemaId: string, name: string): Error =>
+    new Error(
+        `${file.fileName} declares ${taken} and ${schemaId}, which both export \`${name}\`. ` +
+        "Rename one of the schema ids so that every schema in the file gets an export of its own.",
+    );
+
+const getNamedSchemas = (file: ParsedSchemaFile): NamedSchema[] => {
+    const owners: Map<string, string> = new Map();
+
+    return file.schemas.map((schema) => {
+        const exportName = getExportName(schema.id);
+        const taken = owners.get(exportName);
+
+        if (taken !== undefined) {
+            throw collisionError(file, taken, schema.id, exportName);
+        }
+
+        owners.set(exportName, schema.id);
+
+        return { schema, exportName };
+    });
+};
 
 const runtimeKindForKey = (key: ParsedKey): string => {
     if (key.enumId !== null) {
@@ -37,26 +74,27 @@ const getRuntimeKeys = (schema: ParsedSchema): string => {
 
 const renderRuntimeModule = (file: ParsedSchemaFile): string => {
     const lines: string[] = [];
+    const named = getNamedSchemas(file);
 
-    for (const [index, schema] of file.schemas.entries()) {
+    for (const [index, { schema, exportName }] of named.entries()) {
         const keysName = `keys_${String(index)}`;
         const id = toJsStringLiteral(schema.id);
         lines.push(`const ${keysName} = ${getRuntimeKeys(schema)};`);
 
         if (schema.path === null) {
             lines.push(
-                `export const ${getExportName(schema.id)} = { id: ${id}, keys: ${keysName}, ` +
+                `export const ${exportName} = { id: ${id}, keys: ${keysName}, ` +
                 `at: (path) => ({ id: ${id}, path, keys: ${keysName} }) };`,
             );
         } else {
-            lines.push(`export const ${getExportName(schema.id)} = { id: ${id}, path: null, keys: ${keysName} };`);
+            lines.push(`export const ${exportName} = { id: ${id}, path: null, keys: ${keysName} };`);
         }
     }
 
-    const first = file.schemas[0];
+    const first = named[0];
 
     if (first !== undefined) {
-        lines.push(`export default ${getExportName(first.id)};`);
+        lines.push(`export default ${first.exportName};`);
     }
 
     return lines.join("\n");
@@ -106,9 +144,7 @@ const boundRefTypeLines = (interfaceName: string, indent: string): string[] => [
     `${indent}keys: ${interfaceName};`,
 ];
 
-const renderSchemaConst = (schema: ParsedSchema, interfaceName: string): string[] => {
-    const exportName = getExportName(schema.id);
-
+const renderSchemaConst = ({ schema, exportName }: NamedSchema, interfaceName: string): string[] => {
     if (schema.path !== null) {
         return [
             `    const ${exportName}: {`,
@@ -130,17 +166,17 @@ const renderSchemaConst = (schema: ParsedSchema, interfaceName: string): string[
 };
 
 const renderFileModule = (file: ParsedSchemaFile, usedNames: Set<string>): string[] => {
-    const lines = [`declare module "${file.fileName}" {`];
+    const lines = [`declare module ${toJsStringLiteral(file.fileName)} {`];
     const exportNames: string[] = [];
 
-    for (const [index, schema] of file.schemas.entries()) {
+    for (const [index, named] of getNamedSchemas(file).entries()) {
         if (index > 0) {
             lines.push("");
         }
 
-        const interfaceName = allocateInterfaceName(schema.id, usedNames);
-        lines.push(...renderKeysType(interfaceName, schema), "", ...renderSchemaConst(schema, interfaceName));
-        exportNames.push(getExportName(schema.id));
+        const interfaceName = allocateInterfaceName(named.schema.id, usedNames);
+        lines.push(...renderKeysType(interfaceName, named.schema), "", ...renderSchemaConst(named, interfaceName));
+        exportNames.push(named.exportName);
     }
 
     const [firstExport] = exportNames;
@@ -154,14 +190,56 @@ const renderFileModule = (file: ParsedSchemaFile, usedNames: Set<string>): strin
     return lines;
 };
 
-const renderEnvModule = (files: ParsedSchemaFile[]): string => {
+const renderResourceModule = (specifier: string): string => [
+    `declare module ${toJsStringLiteral(specifier)} {`,
+    "    const path: string;",
+    "    export { path };",
+    "    export default path;",
+    "}",
+].join("\n");
+
+const renderIconModule = (specifier: string): string => [
+    `declare module ${toJsStringLiteral(specifier)} {`,
+    "    const iconName: string;",
+    "    export default iconName;",
+    "}",
+].join("\n");
+
+const renderLegacyAssetModule = (specifier: string): string => [
+    `declare module ${toJsStringLiteral(specifier)} {`,
+    "    const resourceUri: string;",
+    "    const path: string;",
+    "    export { path };",
+    "    export default resourceUri;",
+    "}",
+].join("\n");
+
+const renderBlockedAssetModule = (specifier: string): string => [
+    `declare module ${toJsStringLiteral(specifier)} {`,
+    "    const assetImportRequiresResourceOrUrlQuery: {",
+    "        readonly __gtkxAssetImportRequiresResourceOrUrlQuery: unique symbol;",
+    "    };",
+    "    export default assetImportRequiresResourceOrUrlQuery;",
+    "}",
+].join("\n");
+
+const renderEnvModule = (
+    files: ParsedSchemaFile[],
+    assetDeclarations?: EnvAssetDeclarations,
+): string => {
+    const assets = assetDeclarations ?? { blocked: [], icons: [], legacy: [], resources: [] };
     const usedNames: Set<string> = new Set();
 
-    const blocks = files
+    const schemas = files
         .filter((file) => file.schemas.length > 0)
         .map((file) => renderFileModule(file, usedNames).join("\n"));
 
-    return `${[GTKX_ENV_MODULE_HEADER, ...blocks].join("\n\n")}\n`;
+    const blocked = assets.blocked.map((specifier) => renderBlockedAssetModule(specifier));
+    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`;
 };
 
 export { renderRuntimeModule, renderEnvModule };

package/src/settings/schema.ts

@@ -1,10 +1,27 @@
 import { sortStrings, warn } from "@gtkx/utils";
 import { createHash } from "node:crypto";
-import { copyFileSync, type Dirent, mkdirSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+    copyFileSync,
+    type Dirent,
+    existsSync,
+    mkdirSync,
+    mkdtempSync,
+    readdirSync,
+    readFileSync,
+    realpathSync,
+    writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join, relative } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 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";
+import {
+    isBareRelativeAsset,
+    isDataAsset,
+    parseIconSpecifier,
+    parseResourceSpecifier,
+} from "../vite-plugins/asset-specifier.js";
 import { compileSchemas } from "./compile.js";
 import { type ParsedSchemaFile, parseSchemaXml, SchemaParseError } from "./parser.js";
 import { renderEnvModule } from "./render.js";
@@ -16,6 +33,9 @@ type SchemaEnvResult = {
 
 const SCHEMA_SUFFIX = ".gschema.xml";
 const STAGED_NAME_LENGTH = 16;
+const SOURCE_DIR = "src";
+const RESOURCE_QUERY = "?resource=";
+const ICON_QUERY = "?icon=";
 
 const prependSchemaDir = (dir: string, existing: string | undefined): string => {
     if (existing === undefined || existing.length === 0) {
@@ -38,9 +58,150 @@ const stageSchema = (dir: string, filePath: string): void => {
 
 const toForwardSlashes = (value: string): string => value.replaceAll(/[/\\]/g, "/");
 
+const projectRelativeSchemaPath = (root: string, filePath: string): string | null => {
+    let rel: string;
+
+    try {
+        rel = relative(realpathSync(root), realpathSync(filePath));
+    } catch {
+        return null;
+    }
+
+    if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+        return null;
+    }
+
+    return toForwardSlashes(rel);
+};
+
 const getModuleSpecifier = (dataDirAbs: string, filePath: string): string =>
     `${DATA_IMPORT_PREFIX}/${toForwardSlashes(relative(dataDirAbs, filePath))}`;
 
+const getRelativeModuleSpecifier = (filePath: string): string => `*/${basename(filePath)}`;
+
+const sourceDirFor = (root: string): string => {
+    const sourceDir = join(root, SOURCE_DIR);
+
+    return existsSync(sourceDir) ? sourceDir : root;
+};
+
+const isRelativeImport = (source: string): boolean => source.startsWith("./") || source.startsWith("../");
+
+const schemaFileFor = ({ importer, source }: SourceImport): string | null =>
+    isRelativeImport(source) && source.endsWith(SCHEMA_SUFFIX) ? resolve(dirname(importer), source) : null;
+
+const findImportedSchemaFiles = (imports: SourceImport[]): string[] => {
+    const files = imports
+        .map((entry) => schemaFileFor(entry))
+        .filter((path): path is string => path !== null);
+
+    return sortStrings(new Set(files));
+};
+
+const legacyAssetSpecifier = (source: string): string | null =>
+    isDataAsset(source) ? source : null;
+
+const blockedAssetSpecifier = (source: string): string | null => {
+    if (!isBareRelativeAsset(source)) {
+        return null;
+    }
+
+    const separator = source.lastIndexOf("/");
+    const name = source.slice(separator + 1);
+
+    if (name.includes("*")) {
+        throw new Error(
+            `Cannot generate an asset declaration for ${JSON.stringify(source)}: filenames cannot contain *`,
+        );
+    }
+
+    return `*/${name}`;
+};
+
+const resourceModuleSpecifier = (source: string): string | null => {
+    const parsed = parseResourceSpecifier(source);
+    const queryIndex = source.indexOf(RESOURCE_QUERY);
+
+    if (queryIndex === -1 || typeof parsed?.resourcePath !== "string") {
+        return null;
+    }
+
+    const query = source.slice(queryIndex);
+
+    if (query.includes("*")) {
+        throw new Error(
+            `Cannot generate an asset declaration for ${JSON.stringify(source)}: resource paths cannot contain *`,
+        );
+    }
+
+    return `*${query}`;
+};
+
+const iconModuleSpecifier = (source: string): string | null => {
+    const parsed = parseIconSpecifier(source);
+    const queryIndex = source.indexOf(ICON_QUERY);
+
+    if (queryIndex === -1 || typeof parsed?.iconName !== "string") {
+        return null;
+    }
+
+    const query = source.slice(queryIndex);
+
+    if (query.includes("*")) {
+        throw new Error(
+            `Cannot generate an asset declaration for ${JSON.stringify(source)}: icon names cannot contain *`,
+        );
+    }
+
+    return `*${query}`;
+};
+
+const findAssetModuleSpecifiers = (
+    imports: SourceImport[],
+    isV2ResourceImports: boolean,
+): { blocked: string[]; icons: string[]; legacy: string[]; resources: string[] } => {
+    const collect = (getSpecifier: (source: string) => string | null): string[] =>
+        sortStrings(new Set(imports.map((entry) => getSpecifier(entry.source)).filter((value) => value !== null)));
+
+    if (isV2ResourceImports) {
+        return {
+            blocked: collect(blockedAssetSpecifier),
+            icons: collect(iconModuleSpecifier),
+            legacy: [],
+            resources: collect(resourceModuleSpecifier),
+        };
+    }
+
+    return { blocked: [], icons: [], legacy: collect(legacyAssetSpecifier), resources: [] };
+};
+
+const canonicalPath = (path: string): string => {
+    try {
+        return realpathSync(path);
+    } catch {
+        return resolve(path);
+    }
+};
+
+const assertUniqueSchemaBasenames = (schemaFiles: string[]): void => {
+    const owners: Map<string, string> = new Map();
+    const canonicalFiles = sortStrings(new Set(schemaFiles.map((path) => canonicalPath(path))));
+
+    for (const filePath of canonicalFiles) {
+        const name = basename(filePath);
+        const owner = owners.get(name);
+
+        if (owner !== undefined && owner !== filePath) {
+            throw new Error(
+                `Cannot generate types for both ${owner} and ${filePath}: relative GSettings schema imports are ` +
+                `typed by basename, and both files are named ${name}. Rename one of them.`,
+            );
+        }
+
+        owners.set(name, filePath);
+    }
+};
+
 const readVisibleEntries = (dir: string): Dirent[] => {
     try {
         return readdirSync(dir, { withFileTypes: true }).filter((entry) => !entry.name.startsWith("."));
@@ -71,11 +232,11 @@ const findSchemaFiles = (dataDir: string): string[] => {
 };
 
 const stageAndCompileProjectSchemas = (root: string, dataDir: string | null): string | null => {
-    if (dataDir === null) {
-        return null;
-    }
-
-    const schemaFiles = findSchemaFiles(join(root, dataDir));
+    const imports = discoverSourceImports(sourceDirFor(root));
+    const imported = findImportedSchemaFiles(imports);
+    assertUniqueSchemaBasenames(imported);
+    const legacy = dataDir === null ? [] : findSchemaFiles(join(root, dataDir));
+    const schemaFiles = sortStrings(new Set([...legacy, ...imported]));
 
     if (schemaFiles.length === 0) {
         return null;
@@ -98,9 +259,7 @@ const stageAndCompileProjectSchemas = (root: string, dataDir: string | null): st
 
 const schemaEnvPath = (rootDir: string): string => join(rootDir, "node_modules", ".gtkx", "env.d.ts");
 
-const parseSchemaFileOrWarn = (filePath: string, dataDirAbs: string): ParsedSchemaFile | null => {
-    const specifier = getModuleSpecifier(dataDirAbs, filePath);
-
+const parseSchemaFileOrWarn = (filePath: string, specifier: string): ParsedSchemaFile | null => {
     try {
         return parseSchemaXml(readFileSync(filePath, "utf8"), specifier);
     } catch (error) {
@@ -114,11 +273,11 @@ const parseSchemaFileOrWarn = (filePath: string, dataDirAbs: string): ParsedSche
     }
 };
 
-const parseProjectSchemas = (schemaFiles: string[], dataDirAbs: string): ParsedSchemaFile[] => {
+const parseProjectSchemas = (schemaFiles: string[], specifierFor: (filePath: string) => string): ParsedSchemaFile[] => {
     const parsed: ParsedSchemaFile[] = [];
 
     for (const filePath of schemaFiles) {
-        const result = parseSchemaFileOrWarn(filePath, dataDirAbs);
+        const result = parseSchemaFileOrWarn(filePath, specifierFor(filePath));
 
         if (result !== null) {
             parsed.push(result);
@@ -147,11 +306,24 @@ const didWriteChanges = (path: string, content: string): boolean => {
     return true;
 };
 
-const emitSchemaEnv = (rootDir: string, dataDir: string | null): SchemaEnvResult => {
+const emitSchemaEnv = (
+    rootDir: string,
+    dataDir: string | null,
+    isV2ResourceImports = false,
+): SchemaEnvResult => {
     const dataDirAbs = dataDir === null ? null : join(rootDir, dataDir);
-    const schemaFiles = dataDirAbs === null ? [] : findSchemaFiles(dataDirAbs);
-    const parsed = dataDirAbs === null ? [] : parseProjectSchemas(schemaFiles, dataDirAbs);
-    const content = renderEnvModule(parsed);
+    const legacyFiles = dataDirAbs === null ? [] : findSchemaFiles(dataDirAbs);
+    const imports = discoverSourceImports(sourceDirFor(rootDir));
+
+    const legacy = dataDirAbs === null
+        ? []
+        : parseProjectSchemas(legacyFiles, (filePath) => getModuleSpecifier(dataDirAbs, filePath));
+
+    const importedFiles = findImportedSchemaFiles(imports);
+    assertUniqueSchemaBasenames(importedFiles);
+    const imported = parseProjectSchemas(importedFiles, getRelativeModuleSpecifier);
+    const assets = findAssetModuleSpecifiers(imports, isV2ResourceImports);
+    const content = renderEnvModule([...legacy, ...imported], assets);
     const path = schemaEnvPath(rootDir);
     const isWritten = didWriteChanges(path, content);
 
@@ -162,7 +334,8 @@ export {
     SCHEMA_SUFFIX,
     prependSchemaDir,
     stageSchema,
-    findSchemaFiles,
+    assertUniqueSchemaBasenames,
+    projectRelativeSchemaPath,
     stageAndCompileProjectSchemas,
     emitSchemaEnv,
 };

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

@@ -1,5 +1,5 @@
 type AssetEmitter = {
-    emitFile: (file: { type: "asset"; fileName: string; source: Buffer }) => void;
+    emitFile: (file: { type: "asset"; fileName: string; source: Buffer | string }) => void;
 };
 
 export { type AssetEmitter };

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

@@ -4,6 +4,7 @@ const ASSET_EXTENSIONS = [
     "jpeg",
     "gif",
     "svg",
+    "xpm",
     "webp",
     "webm",
     "mp4",

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

@@ -1,8 +1,17 @@
-import type { ParseResult, ParserOptions, Plugin } from "vite";
+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 { parseSync } from "vite";
 import { ASSET_MENTION_RE } from "./asset-extensions.js";
-import { DATA_PREFIX, isAssetSpecifier, isDataAsset } from "./asset-specifier.js";
+import {
+    DATA_PREFIX,
+    isAssetSpecifier,
+    isDataAsset,
+    isUrlSpecifier,
+    parseIconSpecifier,
+    parseResourceSpecifier,
+} from "./asset-specifier.js";
 import { RESOURCE_PATH_EXPORT } from "./resource-shared.js";
 import { stripQuery } from "./strip-query.js";
 
@@ -13,6 +22,7 @@ type ExportStatement = ParsedModule["staticExports"][number];
 type ExportEntry = ExportStatement["entries"][number];
 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"],
@@ -37,8 +47,12 @@ const BUNDLE_ADVICE =
     "nothing else.";
 
 const QUERY_ADVICE =
-    "A query suffix hands the import to the Vite asset pipeline instead of the GResource bundle; drop the " +
-    `query to keep ${RESOURCE_BINDING}${URL_FALLBACK}`;
+    `A URL asset exports only its default filesystem path; import the default instead of ${RESOURCE_BINDING}.`;
+
+const RESOURCE_ADVICE =
+    `A resource asset exports only its default GResource path and ${RESOURCE_BINDING}, and nothing else.`;
+
+const ICON_ADVICE = "An icon asset exports only its default icon-theme name, and nothing else.";
 
 const RELATIVE_ADVICE =
     `Only assets imported through "${DATA_PREFIX}" are staged into the GResource bundle and export ` +
@@ -76,34 +90,54 @@ const bindings = (parsed: ParsedModule): NamedBinding[] => [
     ...parsed.staticExports.flatMap((statement) => exportBindings(statement)),
 ];
 
-const isBacked = ({ name, source }: NamedBinding): boolean =>
-    isDataAsset(source) && name === RESOURCE_PATH_EXPORT;
+const isBacked = ({ name, source }: NamedBinding, isV2: boolean): boolean => {
+    if (name !== RESOURCE_PATH_EXPORT) {
+        return false;
+    }
+
+    return isV2 ? parseResourceSpecifier(source) !== null : isDataAsset(source);
+};
+
+const isCheckedSpecifier = (source: string): boolean => isAssetSpecifier(source) || isUrlSpecifier(source);
+
+const unbackedBinding = (parsed: ParsedModule, isV2: boolean): NamedBinding | undefined =>
+    bindings(parsed).find((binding) => isCheckedSpecifier(binding.source) && !isBacked(binding, isV2));
 
-const unbackedBinding = (parsed: ParsedModule): NamedBinding | undefined =>
-    bindings(parsed).find((binding) => isAssetSpecifier(binding.source) && !isBacked(binding));
+const isBundledResource = (source: string, isV2: boolean): boolean =>
+    isV2
+        ? parseResourceSpecifier(source) !== null || parseIconSpecifier(source) !== null
+        : isDataAsset(source);
 
-const bundleAdvice = (source: string): string => {
-    if (isDataAsset(source)) {
-        return BUNDLE_ADVICE;
+const v2BundleAdvice = (source: string): string =>
+    parseIconSpecifier(source) === null ? RESOURCE_ADVICE : ICON_ADVICE;
+
+const bundleAdvice = (source: string, isV2: boolean): string => {
+    if (isBundledResource(source, isV2)) {
+        return isV2 ? v2BundleAdvice(source) : BUNDLE_ADVICE;
+    }
+
+    if (isUrlSpecifier(source)) {
+        return QUERY_ADVICE;
     }
 
     return source.startsWith(DATA_PREFIX) ? QUERY_ADVICE : RELATIVE_ADVICE;
 };
 
-const unbackedBindingError = (path: string, binding: NamedBinding): Error =>
+const unbackedBindingError = (path: string, binding: NamedBinding, isV2: boolean): Error =>
     new Error(
         `${path}: ${JSON.stringify(binding.source)} does not export ${JSON.stringify(binding.name)}, which ` +
         "gtkx build rejects and gtkx dev would bind as undefined. " +
-        bundleAdvice(binding.source),
+        bundleAdvice(binding.source, isV2),
     );
 
 const isCheckedSource = (path: string): boolean => !path.startsWith(VIRTUAL_PREFIX) && !NODE_MODULES.test(path);
+const hasCheckedAssetMention = (code: string): boolean => ASSET_MENTION_RE.test(code) || code.includes("?url");
 
-const checkAssetImports = (code: string, id: string): void => {
+const checkAssetImports = (code: string, id: string, isV2: boolean): void => {
     const path = stripQuery(id);
     const lang = SOURCE_LANGUAGES.get(extname(path).toLowerCase());
 
-    if (lang === undefined || !isCheckedSource(path) || !ASSET_MENTION_RE.test(code)) {
+    if (lang === undefined || !isCheckedSource(path) || !hasCheckedAssetMention(code)) {
         return;
     }
 
@@ -113,20 +147,27 @@ const checkAssetImports = (code: string, id: string): void => {
         return;
     }
 
-    const binding = unbackedBinding(parsed.module);
+    const binding = unbackedBinding(parsed.module, isV2);
 
     if (binding !== undefined) {
-        throw unbackedBindingError(path, binding);
+        throw unbackedBindingError(path, binding, isV2);
     }
 };
 
-function gtkxAssetImports(): Plugin {
+function gtkxAssetImports(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
+    const state: PluginState = { isV2: false };
+
     return {
         name: "gtkx:asset-imports",
         enforce: "pre",
 
+        async config(config: UserConfig) {
+            const loaded = await loadConfig.load(config.root ?? process.cwd());
+            state.isV2 = loaded.config.future?.v2ResourceImports === true;
+        },
+
         transform(code, id) {
-            checkAssetImports(code, id);
+            checkAssetImports(code, id, state.isV2);
         },
     };
 }