@gtkx/cli 1.6.0 → 2.0.0-beta.10

package/src/vite-plugins/self-contained.ts

@@ -1,18 +1,13 @@
-import type { ESTree, Plugin, VisitorObject } from "vite";
+import type { Plugin } from "vite";
+import { type NodePath, parseSync, type Scope, traverse } from "@babel/core";
 import { isBuiltin } from "node:module";
 import { posix } from "node:path";
-import { parseSync, Visitor } from "vite";
 
-type Bindings = {
-    declarations: Map<string, number>;
-    factories: Set<string>;
-    requires: Set<string>;
-    urls: Set<string>;
-};
+type BindingKind = "factory" | "module" | "require" | "url";
+
+type ResolvedBinding = NonNullable<ReturnType<Scope["getBinding"]>>;
 
 type Scan = {
-    bindings: Bindings;
-    calls: ESTree.CallExpression[];
     sources: string[];
 };
 
@@ -21,199 +16,208 @@ type Chunk = {
     code: string;
 };
 
-type PatternItem =
-    | ESTree.BindingPattern |
-    ESTree.BindingProperty |
-    ESTree.BindingRestElement |
-    ESTree.FormalParameterRest |
-    ESTree.TSParameterProperty |
-    null;
-
 const REQUIRE_FACTORY = "createRequire";
 const REQUIRE_BINDING = "require";
 const RESOLVE_PROPERTY = "resolve";
-const MODULE_BUILTIN = "node:module";
+const URL_PROPERTY = "url";
+const MODULE_BUILTINS = new Set(["module", "node:module"]);
 const OUTPUT_DIRECTORY = ".";
 const RELATIVE_SPECIFIER = /^\.\.?(?:\/|$)/;
 
-const exportName = (name: ESTree.ModuleExportName): string | null => (name.type === "Identifier" ? name.name : null);
-const referenceName = (node: ESTree.Argument): string | null => (node.type === "Identifier" ? node.name : null);
-
-const countName = (declarations: Map<string, number>, name: string | null): void => {
-    if (name !== null) {
-        declarations.set(name, (declarations.get(name) ?? 0) + 1);
+const importedName = (path: NodePath): string | null => {
+    if (!path.isImportSpecifier()) {
+        return null;
     }
+
+    const { imported } = path.node;
+
+    return imported.type === "Identifier" ? imported.name : imported.value;
 };
 
-const boundPattern = (item: PatternItem): ESTree.BindingPattern | null => {
-    if (item === null) {
+const importKind = (path: NodePath): BindingKind | null => {
+    const declaration = path.parentPath;
+
+    if (!declaration.isImportDeclaration() || !MODULE_BUILTINS.has(declaration.node.source.value)) {
         return null;
     }
 
-    if (item.type === "Property") {
-        return item.value;
+    if (importedName(path) === REQUIRE_FACTORY) {
+        return "factory";
     }
 
-    if (item.type === "RestElement") {
-        return item.argument;
+    return path.isImportNamespaceSpecifier() || path.isImportDefaultSpecifier() ? "module" : null;
+};
+
+const memberName = (path: NodePath): string | null => {
+    if (!path.isMemberExpression()) {
+        return null;
     }
 
-    return item.type === "TSParameterProperty" ? item.parameter : item;
-};
+    const property = path.get("property");
 
-const countPatterns = (declarations: Map<string, number>, items: PatternItem[]): void => {
-    for (const item of items) {
-        countPattern(declarations, boundPattern(item));
+    if (path.node.computed) {
+        return property.isStringLiteral() ? property.node.value : null;
     }
+
+    return property.isIdentifier() ? property.node.name : null;
 };
 
-const countPattern = (declarations: Map<string, number>, pattern: ESTree.BindingPattern | null): void => {
-    if (pattern === null) {
-        return;
+const isImportMeta = (path: NodePath): boolean =>
+    path.isMetaProperty() && path.node.meta.name === "import" && path.node.property.name === "meta";
+
+const isDirectMetaUrl = (path: NodePath): boolean => {
+    if (!path.isMemberExpression() || memberName(path) !== URL_PROPERTY) {
+        return false;
     }
 
-    if (pattern.type === "Identifier") {
-        countName(declarations, pattern.name);
+    const object = path.get("object");
 
-        return;
+    return isImportMeta(object);
+};
+
+const bindingKind = (binding: ResolvedBinding, seen: Set<ResolvedBinding>): BindingKind | null => {
+    if (seen.has(binding)) {
+        return null;
     }
 
-    if (pattern.type === "AssignmentPattern") {
-        countPattern(declarations, pattern.left);
+    const next = new Set(seen).add(binding);
+    const imported = importKind(binding.path);
 
-        return;
+    if (imported !== null) {
+        return imported;
+    }
+
+    if (!binding.path.isVariableDeclarator()) {
+        return null;
     }
 
-    countPatterns(declarations, pattern.type === "ObjectPattern" ? pattern.properties : pattern.elements);
+    const initializer = binding.path.get("init");
+
+    return initializer.node === null ? null : expressionKind(initializer, next);
 };
 
-const countFunction = (
-    declarations: Map<string, number>,
-    node: ESTree.ArrowFunctionExpression | ESTree.Function,
-): void => {
-    countPattern(declarations, node.id);
-    countPatterns(declarations, node.params);
+const nameKind = (scope: Scope, name: string, seen: Set<ResolvedBinding>): BindingKind | null => {
+    const binding = scope.getBinding(name);
+
+    if (binding !== undefined) {
+        return bindingKind(binding, seen);
+    }
+
+    if (name === REQUIRE_FACTORY) {
+        return "factory";
+    }
+
+    return name === REQUIRE_BINDING ? "require" : null;
 };
 
-const declarationVisitor = (declarations: Map<string, number>): VisitorObject => ({
-    ArrowFunctionExpression: (node) => {
-        countFunction(declarations, node);
-    },
-    CatchClause: (node) => {
-        countPattern(declarations, node.param);
-    },
-    ClassDeclaration: (node) => {
-        countPattern(declarations, node.id);
-    },
-    ClassExpression: (node) => {
-        countPattern(declarations, node.id);
-    },
-    ExportSpecifier: (node) => {
-        countName(declarations, exportName(node.local));
-    },
-    FunctionDeclaration: (node) => {
-        countFunction(declarations, node);
-    },
-    FunctionExpression: (node) => {
-        countFunction(declarations, node);
-    },
-    ImportDefaultSpecifier: (node) => {
-        countPattern(declarations, node.local);
-    },
-    ImportNamespaceSpecifier: (node) => {
-        countPattern(declarations, node.local);
-    },
-    ImportSpecifier: (node) => {
-        countPattern(declarations, node.local);
-    },
-    VariableDeclarator: (node) => {
-        countPattern(declarations, node.id);
-    },
-});
-
-const isUnshadowed = (name: string, bindings: Bindings): boolean => (bindings.declarations.get(name) ?? 0) <= 1;
-
-const templateString = (node: ESTree.TemplateLiteral): string | null => {
-    const [quasi] = node.quasis;
-
-    return quasi === undefined || node.expressions.length > 0 ? null : quasi.value.cooked;
+const isModuleExpression = (path: NodePath, seen: Set<ResolvedBinding>): boolean => {
+    if (path.isIdentifier()) {
+        return nameKind(path.scope, path.node.name, seen) === "module";
+    }
+
+    if (!path.isCallExpression()) {
+        return false;
+    }
+
+    const [source] = path.get("arguments");
+    const callee = path.get("callee");
+    const sourceName = source === undefined ? null : literalString(source);
+
+    return (
+        sourceName !== null &&
+        MODULE_BUILTINS.has(sourceName) &&
+        isRequireExpression(callee, seen)
+    );
 };
 
-const literalString = (node: ESTree.Argument | null): string | null => {
-    if (node?.type === "TemplateLiteral") {
-        return templateString(node);
+const isFactoryExpression = (path: NodePath, seen: Set<ResolvedBinding>): boolean => {
+    if (path.isIdentifier()) {
+        return nameKind(path.scope, path.node.name, seen) === "factory";
     }
 
-    return node?.type === "Literal" && typeof node.value === "string" ? node.value : null;
+    if (!path.isMemberExpression() || memberName(path) !== REQUIRE_FACTORY) {
+        return false;
+    }
+
+    return isModuleExpression(path.get("object"), seen);
 };
 
-const isMetaUrl = (node: ESTree.Argument, bindings: Bindings): boolean => {
-    if (node.type === "MemberExpression") {
-        return node.object.type === "MetaProperty";
+const isRequireFactoryCall = (path: NodePath, seen: Set<ResolvedBinding>): boolean => {
+    if (!path.isCallExpression()) {
+        return false;
     }
 
-    const name = referenceName(node);
+    const callee = path.get("callee");
 
-    return name !== null && bindings.urls.has(name) && isUnshadowed(name, bindings);
+    return isFactoryExpression(callee, seen);
 };
 
-const hasMetaUrl = (node: ESTree.CallExpression, bindings: Bindings): boolean =>
-    node.arguments.some((argument) => isMetaUrl(argument, bindings));
+const expressionKind = (path: NodePath, seen: Set<ResolvedBinding>): BindingKind | null => {
+    if (isDirectMetaUrl(path)) {
+        return "url";
+    }
 
-const isRequireName = (name: string | null, bindings: Bindings): boolean =>
-    name !== null && (name === REQUIRE_BINDING || bindings.requires.has(name)) && isUnshadowed(name, bindings);
+    if (path.isIdentifier()) {
+        return nameKind(path.scope, path.node.name, seen);
+    }
 
-const isFactoryName = (name: string | null, bindings: Bindings): boolean =>
-    name !== null && (name === REQUIRE_FACTORY || bindings.factories.has(name)) && isUnshadowed(name, bindings);
+    if (isFactoryExpression(path, seen)) {
+        return "factory";
+    }
 
-const isRequireFactory = (node: ESTree.Argument, bindings: Bindings): boolean =>
-    node.type === "CallExpression" &&
-    (isFactoryName(referenceName(node.callee), bindings) || hasMetaUrl(node, bindings));
+    if (isModuleExpression(path, seen)) {
+        return "module";
+    }
 
-const isResolveTarget = (object: ESTree.Expression, bindings: Bindings): boolean =>
-    object.type === "MetaProperty" ||
-    isRequireName(referenceName(object), bindings) ||
-    isRequireFactory(object, bindings);
+    return isRequireFactoryCall(path, seen) ? "require" : null;
+};
 
-const isResolveMember = (callee: ESTree.Expression, bindings: Bindings): boolean =>
-    callee.type === "MemberExpression" &&
-    !callee.computed &&
-    callee.property.type === "Identifier" &&
-    callee.property.name === RESOLVE_PROPERTY &&
-    isResolveTarget(callee.object, bindings);
+const isMetaUrl = (path: NodePath): boolean =>
+    isDirectMetaUrl(path) ||
+    (path.isIdentifier() && nameKind(path.scope, path.node.name, new Set()) === "url");
 
-const isResolvingCall = (call: ESTree.CallExpression, bindings: Bindings): boolean =>
-    hasMetaUrl(call, bindings) ||
-    isRequireName(referenceName(call.callee), bindings) ||
-    isRequireFactory(call.callee, bindings) ||
-    isResolveMember(call.callee, bindings);
+const isRequireExpression = (path: NodePath, seen: Set<ResolvedBinding> = new Set()): boolean =>
+    isRequireFactoryCall(path, seen) ||
+    (path.isIdentifier() && nameKind(path.scope, path.node.name, seen) === "require");
 
-const collectFactories = (node: ESTree.ImportDeclaration, bindings: Bindings): void => {
-    if (node.source.value !== MODULE_BUILTIN) {
-        return;
+const hasMetaUrlArgument = (path: NodePath): boolean => {
+    if (!path.isCallExpression()) {
+        return false;
     }
 
-    for (const specifier of node.specifiers) {
-        if (specifier.type === "ImportSpecifier" && exportName(specifier.imported) === REQUIRE_FACTORY) {
-            bindings.factories.add(specifier.local.name);
-        }
-    }
+    return path.get("arguments").some((argument) => isMetaUrl(argument));
 };
 
-const collectBinding = (node: ESTree.VariableDeclarator, bindings: Bindings): void => {
-    const { id, init } = node;
+const isResolveMember = (path: NodePath): boolean => {
+    if (!path.isMemberExpression() || memberName(path) !== RESOLVE_PROPERTY) {
+        return false;
+    }
 
-    if (init === null || id.type !== "Identifier") {
-        return;
+    const object = path.get("object");
+
+    return isImportMeta(object) || isRequireExpression(object);
+};
+
+const isResolvingCall = (path: NodePath): boolean => {
+    if (!path.isCallExpression()) {
+        return false;
     }
 
-    if (isMetaUrl(init, bindings)) {
-        bindings.urls.add(id.name);
+    const callee = path.get("callee");
+
+    return hasMetaUrlArgument(path) || isRequireExpression(callee) || isResolveMember(callee);
+};
+
+const literalString = (path: NodePath): string | null => {
+    if (path.isStringLiteral()) {
+        return path.node.value;
     }
 
-    if (isRequireFactory(init, bindings)) {
-        bindings.requires.add(id.name);
+    if (!path.isTemplateLiteral() || path.node.expressions.length > 0) {
+        return null;
     }
+
+    return path.node.quasis[0]?.value.cooked ?? null;
 };
 
 const collectSource = (scan: Scan, source: string | null): void => {
@@ -222,55 +226,51 @@ const collectSource = (scan: Scan, source: string | null): void => {
     }
 };
 
-const collectCall = (scan: Scan, node: ESTree.CallExpression): void => {
-    if (node.arguments.some((argument) => literalString(argument) !== null)) {
-        scan.calls.push(node);
+const collectCallSources = (scan: Scan, path: NodePath): void => {
+    if (!isResolvingCall(path) || !path.isCallExpression()) {
+        return;
     }
-};
 
-const scanVisitor = (scan: Scan): VisitorObject => ({
-    CallExpression: (node) => {
-        collectCall(scan, node);
-    },
-    ExportAllDeclaration: (node) => {
-        collectSource(scan, node.source.value);
-    },
-    ExportNamedDeclaration: (node) => {
-        collectSource(scan, node.source?.value ?? null);
-    },
-    ImportDeclaration: (node) => {
-        collectFactories(node, scan.bindings);
-        collectSource(scan, node.source.value);
-    },
-    ImportExpression: (node) => {
-        collectSource(scan, literalString(node.source));
-    },
-    VariableDeclarator: (node) => {
-        collectBinding(node, scan.bindings);
-    },
-});
+    for (const argument of path.get("arguments")) {
+        collectSource(scan, literalString(argument));
+    }
+};
 
 const scanChunk = (chunk: Chunk): Scan => {
-    const scan: Scan = {
-        bindings: { declarations: new Map(), factories: new Set(), requires: new Set(), urls: new Set() },
-        calls: [],
-        sources: [],
-    };
+    const scan: Scan = { sources: [] };
+    const ast = parseSync(chunk.code, {
+        ast: true,
+        babelrc: false,
+        configFile: false,
+        filename: chunk.fileName,
+        sourceType: "module",
+    });
+
+    if (ast === null) {
+        throw new Error(`Cannot inspect ${chunk.fileName}`);
+    }
 
-    const { program } = parseSync(chunk.fileName, chunk.code);
-    new Visitor(declarationVisitor(scan.bindings.declarations)).visit(program);
-    new Visitor(scanVisitor(scan)).visit(program);
+    traverse(ast, {
+        CallExpression: (path) => {
+            collectCallSources(scan, path);
+        },
+        ExportAllDeclaration: (path) => {
+            collectSource(scan, path.node.source.value);
+        },
+        ExportNamedDeclaration: (path) => {
+            collectSource(scan, path.node.source?.value ?? null);
+        },
+        ImportDeclaration: (path) => {
+            collectSource(scan, path.node.source.value);
+        },
+        ImportExpression: (path) => {
+            collectSource(scan, literalString(path.get("source")));
+        },
+    });
 
     return scan;
 };
 
-const callSpecifiers = (scan: Scan): string[] =>
-    scan.calls
-        .filter((call) => isResolvingCall(call, scan.bindings))
-        .flatMap((call) => call.arguments)
-        .map((argument) => literalString(argument))
-        .filter((specifier) => specifier !== null);
-
 const isReachable = (specifier: string, directory: string, emitted: Set<string>): boolean => {
     if (isBuiltin(specifier)) {
         return true;
@@ -286,10 +286,9 @@ const isReachable = (specifier: string, directory: string, emitted: Set<string>)
 };
 
 const unreachableSpecifiers = (chunk: Chunk, emitted: Set<string>): string[] => {
-    const scan = scanChunk(chunk);
     const directory = posix.dirname(chunk.fileName);
 
-    return new Set([...scan.sources, ...callSpecifiers(scan)])
+    return new Set(scanChunk(chunk).sources)
         .values()
         .filter((specifier) => !isReachable(specifier, directory, emitted))
         .toArray()

package/src/vite-plugins/settings-worker-env.ts

@@ -1,20 +1,18 @@
 import type { UserConfig } from "vite";
 import type { Plugin } from "vitest/config";
-import { createConfigLoader, resolveFuture } from "@gtkx/config/internal";
-import { resolveDataDir } from "../internal/data-dir.js";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
 import { prependSchemaDir, stageAndCompileProjectSchemas } from "../settings/schema.js";
 
-function gtkxSettingsWorkerEnv(): Plugin {
-    const loadConfig = createConfigLoader();
+function gtkxSettingsWorkerEnv(configFile?: string): Plugin {
+    const loadConfig = createConfigLoader({ configFile });
 
     return {
         name: "gtkx:settings-worker-env",
         enforce: "pre",
 
         async config(config: UserConfig) {
-            const loaded = await loadConfig.load(config.root ?? process.cwd());
-            const dataDir = resolveFuture(loaded.config.future).isResourceImported ? null : resolveDataDir(loaded.root);
-            const dir = stageAndCompileProjectSchemas(loaded.root, dataDir);
+            const loaded = await loadConfig.load(viteProjectRoot(config));
+            const dir = stageAndCompileProjectSchemas(loaded.root);
 
             if (dir === null) {
                 return;

package/src/vite-plugins/settings.ts

@@ -1,13 +1,10 @@
-import type { ConfigLoader } from "@gtkx/config";
-import type { ModuleNode, Plugin, ResolvedConfig, UserConfig, ViteDevServer } from "vite";
-import { resolveFuture } from "@gtkx/config/internal";
+import type { ModuleNode, Plugin, ResolvedConfig, Rollup, ViteDevServer } from "vite";
 import { error, errorMessage, info, sortStrings } from "@gtkx/utils";
 import { readFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import type { BuildManifestCollector } from "../internal/build-manifest.js";
 import type { AssetEmitter } from "./asset-emitter.js";
-import { prependBanner } from "../internal/banner.js";
-import { resolveDataDir } from "../internal/data-dir.js";
+import { outputRootUrlExpression, prependBanner } from "../internal/banner.js";
 import { createRetainedStagingDir, type RetainedStagingDir, withStagingDir } from "../internal/staging-dir.js";
 import { compileSchemas } from "../settings/compile.js";
 import { parseSchemaXml, SchemaParseError } from "../settings/parser.js";
@@ -25,8 +22,6 @@ import { createVirtualNamespace } from "./virtual-module.js";
 type PluginState = {
     schemaDir: RetainedStagingDir;
     rootDir: string | null;
-    dataDir: string | null;
-    isV2ResourceImports: boolean;
     isBuild: boolean;
     schemaEnvTimer: ReturnType<typeof setTimeout> | null;
     trackedSchemas: Map<string, string>;
@@ -37,16 +32,21 @@ type PluginContext = AssetEmitter & {
     error: (message: string) => never;
 };
 
+type SchemaResolveContext = Parameters<typeof resolveToVirtual>[0];
+type SchemaResolveRequest = Parameters<typeof resolveToVirtual>[1];
+
 const VIRTUAL_PREFIX = "\0gtkx-settings:";
 const SCHEMA_STAGING_PREFIX = "schemas";
 const SOURCE_MODULE_RE = /\.[cm]?[jt]sx?$/;
+const SCHEMA_ID_RE = /\.gschema\.xml$/;
 const SCHEMA_ENV_DEBOUNCE_MS = 50;
+const VIRTUAL_ID_RE = new RegExp(`^${VIRTUAL_PREFIX}`);
 const { isVirtual, fromVirtualId, resolveToVirtual } = createVirtualNamespace(VIRTUAL_PREFIX);
 
-const SCHEMA_ENV_BANNER = [
-    "process.env.GSETTINGS_SCHEMA_DIR = [",
-    "    decodeURIComponent(new URL(\".\", import.meta.url).pathname),",
-    "    process.env.GSETTINGS_SCHEMA_DIR,",
+const schemaEnvBanner = (chunk: Rollup.RenderedChunk): string => [
+    "globalThis.process.env.GSETTINGS_SCHEMA_DIR = [",
+    `    ${outputRootUrlExpression(chunk)},`,
+    "    globalThis.process.env.GSETTINGS_SCHEMA_DIR,",
     "]",
     "    .filter(Boolean)",
     "    .join(\":\");",
@@ -81,7 +81,7 @@ const syncSchemaEnv = (state: PluginState): void => {
     }
 
     try {
-        emitSchemaEnv(state.rootDir, state.dataDir, state.isV2ResourceImports);
+        emitSchemaEnv(state.rootDir);
     } catch (error_) {
         error(`Failed to generate GSettings schema types: ${errorMessage(error_)}`);
     }
@@ -105,12 +105,6 @@ const scheduleSchemaEnvSync = (state: PluginState): void => {
     }, SCHEMA_ENV_DEBOUNCE_MS);
 };
 
-const applyUserConfig = async (state: PluginState, config: UserConfig, loadConfig: ConfigLoader): Promise<void> => {
-    const loaded = await loadConfig.load(config.root ?? process.cwd());
-    state.isV2ResourceImports = resolveFuture(loaded.config.future).isResourceImported;
-    state.dataDir = state.isV2ResourceImports ? null : resolveDataDir(loaded.root);
-};
-
 const applyResolvedConfig = (state: PluginState, config: ResolvedConfig): void => {
     state.isBuild = config.command === "build";
     state.rootDir = typeof config.root === "string" ? config.root : null;
@@ -173,6 +167,25 @@ const compileBuildSchemas = (schemaFiles: string[]): Buffer =>
         return readFileSync(join(dir, "gschemas.compiled"));
     });
 
+const rejectLegacySchemaSpecifier = (source: string): void => {
+    if (source.startsWith("#data/")) {
+        throw new Error(`${JSON.stringify(source)} uses the legacy #data schema form`);
+    }
+};
+
+const resolveSchemaId = async (
+    ctx: SchemaResolveContext,
+    request: SchemaResolveRequest,
+): Promise<string | undefined> => {
+    if (!request.source.endsWith(SCHEMA_SUFFIX)) {
+        return;
+    }
+
+    rejectLegacySchemaSpecifier(request.source);
+
+    return resolveToVirtual(ctx, request);
+};
+
 const buildSchemaPaths = (rootDir: string, schemaFiles: string[]): string[] =>
     schemaFiles.map((filePath) => {
         const rel = projectRelativeSchemaPath(rootDir, filePath);
@@ -262,12 +275,10 @@ const watchSchemaFiles = (state: PluginState, server: ViteDevServer): void => {
     server.watcher.on("unlink", refreshSchemaTypes);
 };
 
-function gtkxSettings(loadConfig: ConfigLoader, buildManifest?: BuildManifestCollector): Plugin {
+function gtkxSettings(buildManifest?: BuildManifestCollector): Plugin {
     const state: PluginState = {
         schemaDir: createRetainedStagingDir(SCHEMA_STAGING_PREFIX),
         rootDir: null,
-        dataDir: null,
-        isV2ResourceImports: false,
         isBuild: false,
         schemaEnvTimer: null,
         trackedSchemas: new Map(),
@@ -278,10 +289,6 @@ function gtkxSettings(loadConfig: ConfigLoader, buildManifest?: BuildManifestCol
         name: "gtkx:settings",
         enforce: "pre",
 
-        async config(config: UserConfig) {
-            await applyUserConfig(state, config, loadConfig);
-        },
-
         configResolved(config) {
             applyResolvedConfig(state, config);
         },
@@ -295,19 +302,23 @@ function gtkxSettings(loadConfig: ConfigLoader, buildManifest?: BuildManifestCol
                 return;
             }
 
-            return prependBanner(options, SCHEMA_ENV_BANNER);
+            return prependBanner(options, schemaEnvBanner);
         },
 
-        async resolveId(source, importer, options) {
-            if (!source.endsWith(SCHEMA_SUFFIX)) {
-                return;
-            }
+        resolveId: {
+            filter: { id: SCHEMA_ID_RE },
 
-            return resolveToVirtual(this, { source, importer, options });
+            handler(source, importer, options) {
+                return resolveSchemaId(this, { source, importer, options });
+            },
         },
 
-        load(id) {
-            return loadSchemaModule(this, state, id);
+        load: {
+            filter: { id: VIRTUAL_ID_RE },
+
+            handler(id) {
+                return loadSchemaModule(this, state, id);
+            },
         },
 
         buildEnd() {