@vistta/cli 1.0.1 → 1.2.0

package/README.md

@@ -30,21 +30,160 @@ npm install @vistta/cli
 - `vistta project name`
   Outputs the current project name from `package.json`.
 
-- `vistta project version [major|minor|patch]`  
-  Outputs the current project version. If a level (`major`, `minor`, `patch`) is provided, it increments the version accordingly.
+- `vistta project version [increment|version] [prerelease-id]`
+  Prints the current project version, increments it (for example, `patch` or
+  `prerelease`), or sets an explicit version such as `1.2.3`.
+
+- `vistta project outdated [dependency]`
+  Shows installed (`Current`), range-compatible (`Wanted`), and `Latest`
+  versions, plus the owning manifest and dependency type, using `npm outdated`,
+  respecting npm registry settings and policies such as `min-release-age`.
+  Inside a workspace package, only that package's dependencies are checked;
+  running from the workspace root checks all workspace consumers.
+  Linked workspace packages are excluded. Available compatible updates cause a
+  nonzero exit status; newer versions outside the declared range are informational.
+
+- `vistta project update [dependency] [--compatible] [--dry-run]`
+  Updates declared dependency ranges to latest versions by default, which may
+  include major upgrades. `--compatible` selects npm's wanted version within
+  each dependency's existing range instead. `--dry-run` previews the exact
+  manifest changes without writing files.
+
+- `vistta project patch [dependency] [--dry-run]`
+  Backward-compatible alias for `project update --compatible`. Despite the
+  historical name, this can select a compatible minor update, not just patches.
+
+Dependency updates only edit `package.json` ranges; run `npm install` afterward
+to update installed versions and the lockfile. Workspace-root updates preserve
+each consumer's own target version. If no ranges need changing, the command
+says so explicitly. A dependency filter selects matching outdated entries; no
+match means no outdated entry was found, not that the dependency exists.
 
-- `vistta project outdated`  
-  Lists all outdated dependencies in the project.
-
-- `vistta patch [module-name]` or `vistta project patch [module-name]`
-  Updates the version of a specific module (or all outdated modules if none is specified) to the latest patch version in `package.json`.
-
-- `vistta update [module-name]` or `vistta project update [module-name]`
-  Updates the version of a specific module (or all outdated modules if none is specified) to its latest available version in `package.json`.
+```sh
+vistta project --help
+vistta project update --help
+vistta project outdated react
+vistta project update --compatible --dry-run
+vistta project update react --compatible
+vistta project update react --dry-run
+```
 
 - `vistta test [pattern]`  
   Run tests matching the specified pattern.
 
+For browser-based test harnesses, import `TestRunner` from `@vistta/cli/test-runner` to avoid bundling Node-only CLI modules.
+
+### Unified Project Configuration
+
+Keep VISTTA settings in the `cli` block of `tsconfig.json` or `jsconfig.json`.
+Comments and trailing commas are supported. If both files exist, `tsconfig.json`
+takes precedence. The existing `cliOptions` block remains supported; `cli` wins
+when both specify the same setting.
+
+Install the tools you want to use locally:
+
+```sh
+npm install --save-dev eslint prettier typescript
+```
+
+```jsonc
+{
+  "$schema": "./node_modules/@vistta/cli/config.schema.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true,
+  },
+  "include": ["src/**/*.js", "src/**/*.ts"],
+  "exclude": ["dist"],
+  "cli": {
+    "check": { "format": true, "lint": true, "types": true },
+    "format": {
+      "engine": "prettier",
+      "options": { "printWidth": 120, "semi": true },
+    },
+    "lint": {
+      "engine": "eslint",
+      "rules": { "no-unused-vars": "warn" },
+    },
+    "tasks": {
+      "validate": { "dependsOn": ["check", "test"] },
+      "release": { "dependsOn": ["validate"], "script": "publish:package" },
+    },
+  },
+}
+```
+
+The optional `$schema` enables completion and validation for VISTTA settings.
+The schema leaves other TypeScript and framework settings open; TypeScript
+validates compiler options during `vistta types` or `vistta check`.
+
+```sh
+vistta check
+vistta check --fix
+vistta lint "src/**/*.js" --fix
+vistta fmt --check
+vistta fmt --write
+vistta types
+vistta config
+vistta config --sources
+vistta task validate
+vistta run validate
+```
+
+- `check` runs formatting, linting, and type checking by default. Disable a stage
+  with `cli.check`. All enabled stages run, and any failure produces a nonzero
+  exit code. Lint warnings also fail the check.
+- Checks are read-only unless `--fix` or `fmt --write` is supplied. Fix mode
+  applies Prettier formatting and ESLint fixes; type checking never emits files.
+- Tools are resolved from the current project, not downloaded automatically.
+  Only enabled tools need to be installed. ESLint 9+ and Prettier 3 are supported.
+- `format.include` and `lint.include` override top-level `include`. Explicit
+  command-line patterns override both and are relative to the working directory.
+  The corresponding `exclude` settings, `compilerOptions.outDir`, dependencies,
+  and Git metadata are excluded. Inherited patterns are relative to their owning
+  configuration file. Type checking always covers the whole configured project.
+- Existing ESLint and Prettier configs are used when present. Inline settings
+  override them. Without an ESLint config, inline rules/options provide the flat
+  config. `lint.options` contains flat-config properties, not ESLint constructor
+  options. Without explicit includes, lint scans JS/TS and formatting scans files
+  supported by Prettier. An empty match set passes without changing files.
+- For plugins, parsers, or other executable settings, set `lint.config` or
+  `format.config` to a module path such as `"./tools/eslint.js"`. It must default
+  export the relevant tool configuration. Relative paths resolve from the owning
+  config file; package references resolve from that same directory. Referenced
+  lint configs replace ESLint config discovery; inline settings still win.
+
+### Presets And Tasks
+
+`extends` accepts a relative JSON/JSONC config, a package config export, or an
+array of either. Parents apply left to right, then local settings override them.
+Objects merge recursively; arrays and scalar values replace inherited values.
+Circular presets, malformed JSONC, and invalid VISTTA tool/task settings fail
+explicitly. `vistta config --sources` shows the merged configuration and the
+file responsible for each leaf setting, including built-in check defaults.
+
+Workspace packages can extend a shared root/preset config and override `cli`
+locally. Commands run in the current package directory; they do not automatically
+fan out across workspaces. Existing `compilerOptions`, `bundlerOptions`, and
+custom commands continue to work.
+
+Tasks run their `dependsOn` dependencies once, in order, before their optional
+package `script`. Dependencies can name other tasks, current-package scripts, or
+registered commands such as `check`, `lint`, `fmt`, `types`, `test`, and `bundle`
+(or `build` when provided by a framework).
+Missing tasks/scripts and dependency cycles fail before execution. The first
+failed command stops the plan and propagates its exit status. Arguments after
+`--` are forwarded only to the requested task's command or script:
+
+```sh
+vistta task release -- --dry-run
+```
+
+`vistta run` is a task alias in the base CLI. Framework command overrides are
+preserved: `@vistta/js` keeps its application-oriented `run`, so use `vistta task`
+there. Task caching and automatic cross-workspace scheduling are not implemented.
+
 ## Extending the CLI
 
 You can create custom loaders and commands to fit your workflow.
@@ -108,7 +247,7 @@ vistta my-command [options]
 
 ## **License**
 
-Apache 2.0 with Commons Clause
+Licensed under the GNU General Public License version 3 only (`GPL-3.0-only`). See [LICENSE](LICENSE) for the full terms.
 
 ## **Contributing**
 

package/bin.js

@@ -9,7 +9,7 @@ const dirname = import.meta.dirname;
 const cwd = process.cwd();
 const rootPackage = await importJSON(fs.resolve(dirname, "package.json"));
 const projectPackage = await importJSON(fs.resolve(cwd, "package.json"));
-const env = await importEnv(fs.resolve(cwd, ".env"));
+const env = { ...process.env, ...(await importEnv(fs.resolve(cwd, ".env"))) };
 const projectEnvKeys = Object.keys(projectPackage?.env || {});
 for (let i = 0, len = projectEnvKeys.length; i < len; i++) env[projectEnvKeys[i]] = projectPackage.env[projectEnvKeys[i]];
 env.NODE_ENV = "production";
@@ -22,6 +22,10 @@ const argv = [];
 const execArgv = ["--import", pathToFileURL(fs.resolve(dirname, "register.js")), "--experimental-sqlite", "--title=VISTTA"];
 for (let i = 2, len = process.argv.length; i < len; i++) {
   const [arg, value] = process.argv[i].toLowerCase().split("=");
+  if (process.argv[i] === "--") {
+    argv.push(...process.argv.slice(i));
+    break;
+  }
   const nodeOption = ENABLED_NODE_OPTIONS[arg];
   if (nodeOption) {
     if (typeof nodeOption === "string") env[nodeOption] = value || true;
@@ -43,9 +47,15 @@ start(fs.resolve(dirname, "main.js"), argv, {
   stdio: env.NODE_SILENT ? "ignore" : "inherit",
 });
 
-function start(...args) {
-  fork(...args).on("exit", (code) => {
-    if (env.NODE_AUTO_RESTART && code != 0) start(...args);
+function start(modulePath, argv, options) {
+  const subprocess = fork(modulePath, argv, options);
+  let restart = false;
+  subprocess.on("message", (message) => {
+    if (typeof message === "object" && message && "restart" in message && message.restart)
+      ((restart = true), subprocess.kill());
+  });
+  subprocess.on("exit", (code) => {
+    if ((env.NODE_AUTO_RESTART && code != 0) || restart) start(modulePath, argv, options);
     else process.exit(code);
   });
 }

package/classes/bundler.js

@@ -1,56 +1,124 @@
 import fs from "@vistta/fs";
 import { build } from "esbuild";
-import { pathToFileURL } from "node:url";
-import { assign, extract } from "../utils.js";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { assign, extract, stripBundler } from "../utils.js";
 import { Command } from "./command.js";
 import { Runtime } from "./runtime.js";
 
+/**
+ * @typedef {{
+ *  paths?: Record<string, any>;
+ *  exports?: string;
+ *  sideEffects?: "none" | string | boolean;
+ *  importAttributes?: Record<string, any>;
+ *  [key: string]: any;
+ * }} BundlerRunOptions
+ */
+
+/**
+ * @typedef {{
+ *  code: string;
+ *  files: string[];
+ *  resources: Record<string, any>;
+ *  errors: any[];
+ *  warnings: any[];
+ *  warning?: any;
+ * }} BundlerRunResult
+ */
+
+/**
+ * @typedef {{
+ *  entries: string[];
+ *  files: string[];
+ *  resources: Record<string, any>;
+ *  loader: Runtime;
+ *  paths?: Record<string, any>;
+ *  exports?: string;
+ *  sideEffects?: boolean;
+ *  platform?: string;
+ *  importAttributes?: Record<string, any>;
+ * }} SetupOptions
+ */
+
 export class Bundler {
+  /** @type {Runtime} */
   #loader;
+  /** @type {BundlerRunOptions} */
   #options;
 
+  /**
+   * @param {Runtime | Command | undefined} [arg1]
+   */
   constructor(arg1) {
     if (arg1 instanceof Runtime) this.#loader = arg1;
-    else if (arg1 instanceof Command) this.#loader = new Runtime(arg1);
+    else if (arg1 instanceof Command)
+      this.#loader = new Runtime({
+        loaders: arg1.loaders,
+        resolvers: arg1.resolvers,
+        options: process.vistta?.options || {},
+      });
     else if (!arg1) this.#loader = new Runtime(process.vistta);
     else throw new Error("Invalid first argument. Expected Loader or CLI instance.");
     this.#options = this.#loader?.options?.bundler ?? {};
   }
 
-  async run(filename, options = {}) {
+  /**
+   * @param {string | string[]} target
+   * @param {BundlerRunOptions} [options]
+   * @returns {Promise<BundlerRunResult>}
+   */
+  async run(target, options = {}) {
     const files = [];
     const resources = {};
-    assign(options, this.#options);
-    const [paths, exports] = extract(options, "paths", "exports");
-    options.entryPoints = [exports ? "@exports" : filename];
+    options = assign({ ...options }, this.#options);
+    const [paths, exports, sideEffects, importAttributes] = extract(
+      options,
+      "paths",
+      "exports",
+      "sideEffects",
+      "importAttributes",
+    );
+    const multiple = Array.isArray(target);
+    if (exports && multiple) throw new Error("Cannot use 'exports' option with multiple entry points");
+    const entries = multiple ? target : [target];
+    options.entryPoints = exports ? ["@exports"] : multiple ? ["@bundle"] : entries;
     options.bundle = true;
     options.outdir ??= "dist";
     options.legalComments ??= "none";
     options.keepNames ??= true;
     options.treeShaking ??= true;
-    options.define ??= {};
     options.plugins = [];
     options.minify ??= process.env.NODE_ENV === "production";
     options.format ??= options.globalName ? "iife" : "esm";
     options.target ??= "esnext";
-    options.define[`process`] = "undefined";
-    const keys = Object.keys(process.env);
-    for (let i = 0, len = keys.length; i < len; i++) {
-      if (/[():;,.\s]/.test(keys[i])) continue;
-      options.define[`process.env.${keys[i]}`] = JSON.stringify(process.env[keys[i]]);
+    options.logLevel ??= "error";
+    options.define ??= {};
+    if (options.platform !== "node") {
+      options.define[`process`] = "undefined";
+      const keys = Object.keys(process.env);
+      for (let i = 0, len = keys.length; i < len; i++) {
+        if (/[():;,.\s]/.test(keys[i])) continue;
+        options.define[`process.env.${keys[i]}`] = JSON.stringify(process.env[keys[i]]);
+      }
     }
     options.plugins.unshift(
       setup({
+        entries,
         loader: this.#loader,
         paths,
-        filename,
         files,
         resources,
         exports,
+        sideEffects: sideEffects !== "none",
         platform: options.platform,
+        importAttributes,
       }),
     );
     const { outputFiles, errors, warnings } = await build(options);
+    if ((outputFiles?.length ?? 0) > 1)
+      throw new Error(
+        `Unexpected Bundler Error: Expected 1 output file, but got ${outputFiles.length}. Please report this issue.`,
+      );
     return {
       code: outputFiles?.[0]?.text ?? "",
       files: Array.from(new Set(files)),
@@ -60,49 +128,92 @@ export class Bundler {
     };
   }
 
-  async import(filename, options = {}) {
+  /**
+   * @param {string} target
+   * @param {BundlerRunOptions} [options]
+   * @returns {Promise<any>}
+   */
+  async import(target, options = {}) {
     options.write = false;
-    const { code, errors, warning } = await this.run(filename, options);
+    const { code, errors, warning } = await this.run(target, options);
     if (code === "") return { errors, warning };
     return await import(`data:text/javascript;base64,${Buffer.from(code).toString(`base64`)}`);
   }
 }
 
-function setup({ files: bundlerFiles, resources: bundlerResources, filename, loader, paths = {}, exports, platform }) {
+/**
+ * @param {SetupOptions} options
+ */
+function setup({
+  entries,
+  files: bundlerFiles,
+  resources: bundlerResources,
+  loader,
+  paths = {},
+  exports,
+  sideEffects,
+  platform,
+  importAttributes: bundlerImportAttributes = {},
+}) {
   const filter = /.*/;
-  const basename = fs.basename(filename);
-  const dirname = fs.dirname(filename);
   return {
     name: "vistta",
     setup: (build) => (
       build.onResolve({ filter }, async ({ path, importer, resolveDir }) => {
-        if (path === "@exports") return { path: basename, namespace: "exports" };
-        if (paths[path]) return paths[path];
-        if (!fs.isAbsolute(importer)) importer = fs.resolve(resolveDir, importer);
+        const cleanPath = stripBundler(path);
+        if (cleanPath === "@exports") return { path: "@exports", namespace: "exports", sideEffects };
+        if (cleanPath === "@bundle") return { path: "@bundle", namespace: "bundle", sideEffects };
+        if (paths[cleanPath]) {
+          const mapping = paths[cleanPath];
+          if (mapping.namespace !== "window") return Object.assign({ sideEffects }, mapping);
+          const names = await getImportNames(importer, cleanPath);
+          return {
+            path: `${cleanPath}?window-import=${encodeURIComponent(importer)}`,
+            namespace: "window",
+            pluginData: { name: mapping.path, names },
+            sideEffects,
+          };
+        }
+        const isVirtualPath = importer === "@exports" || importer === "@bundle";
+        if (!isVirtualPath && !fs.isAbsolute(importer)) importer = fs.resolve(resolveDir, importer);
         const { final, builtin, file } = await loader.resolve(
-          path,
+          cleanPath,
           {
             conditions: ["bundler"],
-            parentURL: pathToFileURL(importer).href,
+            parentURL: !isVirtualPath ? pathToFileURL(importer).href : undefined,
           },
           (final, { builtin, file }) => ({ final, builtin, file }),
         );
-        if (!builtin && file) return { path: final };
+        const cleanFinal = stripBundler(final);
+        const finalPath = cleanFinal.startsWith("file://") ? fileURLToPath(cleanFinal) : cleanFinal;
+        if (!builtin && file) return { path: finalPath, sideEffects };
+        if (!builtin) return { sideEffects };
         if (platform === "node") return { external: true };
-        if (!builtin) return {};
-        return { path: final, namespace: "ignore" };
+        return { path: finalPath, namespace: "ignore" };
       }),
-      build.onLoad({ filter }, async ({ path, namespace, with: importAttributes = {} }) => {
+      build.onLoad({ filter }, async ({ path, namespace, pluginData, with: importAttributes }) => {
+        const cleanPath = stripBundler(path);
         if (namespace === "ignore") return { contents: "" };
-        if (namespace === "window") return { contents: `module.exports = window.${path};` };
-        if (namespace === "global") return { contents: `module.exports = global.${path};` };
-        if (namespace === "exports")
-          return {
-            contents: `export { ${exports} } from "./${basename}";`,
-            resolveDir: dirname,
-          };
+        if (namespace === "window") return { contents: createWindowModule(pluginData.name, pluginData.names) };
+        if (namespace === "global") return { contents: `module.exports = global.${cleanPath};` };
+        if (namespace === "exports") {
+          if (exports === "*") return { contents: `export * from ${JSON.stringify(entries[0])};` };
+          return { contents: `export { ${exports} } from ${JSON.stringify(entries[0])};` };
+        }
+        if (namespace === "bundle") {
+          let contents = "";
+          for (let i = 0, len = entries.length; i < len; i++) contents += `export * from ${JSON.stringify(entries[i])};\n`;
+          return { contents };
+        }
+        if (importAttributes.type === "bundler") delete importAttributes.type;
         importAttributes.bundler = true;
-        const { source, resources, files = [] } = await loader.load(path, { importAttributes }, () => ({}));
+        const mergedImportAttributes = { ...bundlerImportAttributes, ...importAttributes };
+        if (cleanPath.match(/\.(jsx|tsx)$/)) delete mergedImportAttributes.type;
+        const {
+          source,
+          resources,
+          files = [],
+        } = await loader.load(cleanPath, { importAttributes: mergedImportAttributes }, () => ({}));
         bundlerFiles.push(...files);
         if (!source) return { loader: "js" };
         for (let i = 0, len = resources?.length || 0; i < len; i++) {
@@ -114,3 +225,28 @@ function setup({ files: bundlerFiles, resources: bundlerResources, filename, loa
     ),
   };
 }
+
+async function getImportNames(importer, path) {
+  if (!importer || !fs.existsSync(importer)) return [];
+  const source = String(await fs.readFile(importer, "utf8"));
+  const escapedPath = path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `(?:import\\s+(?:[\\w$]+\\s*,\\s*)?|export\\s*){([^}]+)}\\s*from\\s*["']${escapedPath}["']`,
+    "g",
+  );
+  const names = new Set();
+  for (const match of source.matchAll(pattern)) {
+    for (const specifier of match[1].split(",")) names.add(specifier.trim().split(/\s+as\s+/i)[0]);
+  }
+  return [...names].filter(Boolean);
+}
+
+function createWindowModule(name, names) {
+  const getNamespace = `() => window[${JSON.stringify(name)}]`;
+  let contents = `const getNamespace = ${getNamespace};\nconst exports = {};\nObject.defineProperty(exports, "__esModule", { value: true });\n`;
+  contents += `Object.defineProperty(exports, "default", { enumerable: true, get: () => { const namespace = getNamespace(); return namespace?.default ?? namespace; } });\n`;
+  for (const exportName of names)
+    contents += `Object.defineProperty(exports, ${JSON.stringify(exportName)}, { enumerable: true, get: () => getNamespace()?.[${JSON.stringify(exportName)}] });\n`;
+  contents += `module.exports = new Proxy(exports, { get: (exports, name) => Reflect.has(exports, name) ? Reflect.get(exports, name) : (getNamespace()?.default ?? getNamespace())?.[name] });\n`;
+  return contents;
+}

package/classes/loader.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-unused-vars */
 export class Loader {
-  constructor() {}
+  constructor(options) {}
 
   /**
    * Main method to execute the loader.

package/classes/runtime.js

@@ -1,11 +1,9 @@
 import fs from "@vistta/fs";
 import { isBuiltin } from "node:module";
 import { fileURLToPath, pathToFileURL, URLSearchParams } from "node:url";
+import { CWD, FALLBACK, markAttributes, markBundler, stripBundler, WITH_TYPE_RE } from "../utils.js";
 import { Loader } from "./loader.js";
 
-const CWD = process.cwd();
-const FALLBACK = "*";
-
 export class Runtime {
   static Error = class extends Error {
     constructor(name, message) {
@@ -17,22 +15,27 @@ export class Runtime {
   #init;
   #loaders;
   #resolvers;
+  /** @type {Record<string, any>} */
   #options;
 
   get loaders() {
     return this.#loaders;
   }
 
+  /** @returns {Record<string, any>} */
   get options() {
     return this.#options;
   }
 
-  constructor({ loaders, resolvers, options }) {
+  /**
+   * @param {{ loaders?: any[]; resolvers?: string[]; options?: Record<string, any> }} [config]
+   */
+  constructor({ loaders = [], resolvers = [], options = {} } = {}) {
     this.#init = async () => {
       this.#loaders = {};
-      for (let i = 0, len = loaders?.length || 0; i < len; i++) {
+      for (let i = 0, len = loaders.length; i < len; i++) {
         let { main, type, filter } = loaders[i];
-        const { default: LoaderClass } = await import(main);
+        const { default: LoaderClass } = await import(pathToFileURL(main).href);
         if (!(LoaderClass?.prototype instanceof Loader)) throw new Runtime.Error(`Invalid loader "${loaders[i].main}"`);
         if (!type) type = FALLBACK;
         if (!this.#loaders[type]) this.#loaders[type] = {};
@@ -48,8 +51,11 @@ export class Runtime {
     [specifier, options] = specifier.split(/\?(.*)/);
     options = new URLSearchParams(options);
     const { parentURL = CWD, conditions: [type] = [] } = context;
+    const importType = context?.importAttributes?.type;
+    const isBundler = type === "bundler" || importType === "bundler";
+    const cleanParentURL = stripBundler(parentURL);
     if (isBuiltin(specifier)) {
-      if (type === "bundler") context.builtin = true;
+      if (isBundler) context.builtin = true;
       return nextResolve(specifier, context);
     }
 
@@ -74,7 +80,7 @@ export class Runtime {
     if (specifier?.startsWith("file://")) specifier = fileURLToPath(specifier);
 
     if (!fs.isAbsolute(specifier))
-      specifier = fs.resolve(parentURL?.startsWith("file://") ? fs.dirname(parentURL) : parentURL, specifier);
+      specifier = fs.resolve(cleanParentURL?.startsWith("file://") ? fs.dirname(cleanParentURL) : cleanParentURL, specifier);
     const len = this.#resolvers.length;
     if (fs.existsSync(specifier)) {
       if (fs.isDirectory(specifier)) {
@@ -95,22 +101,26 @@ export class Runtime {
         }
       }
 
-    if (type === "bundler") {
+    if (isBundler) {
       if (fs.isAbsolute(specifier)) context.file = true;
-      return nextResolve(specifier, context);
+      return nextResolve(markBundler(pathToFileURL(specifier).href), context);
     }
 
+    let query = "";
     const params = options.toString();
-    specifier = pathToFileURL(specifier).href;
-    if (params.length > 0) return nextResolve(`${specifier}?${params}`, context);
-    return nextResolve(specifier, context);
+    if (params) query = params;
+    const attrSuffix = markAttributes(context?.importAttributes);
+    if (attrSuffix) query += (query ? "&" : "") + attrSuffix;
+    let url = pathToFileURL(specifier).href;
+    if (query) url += (url.includes("?") ? "&" : "?") + query;
+    return nextResolve(url, context);
   }
 
   async load(url, context, nextLoad) {
     if (isBuiltin(url)) return nextLoad(url, context);
     const { ...options } = context?.importAttributes || {};
-    url = options.bundler ? pathToFileURL(url.split("?")[0]).href : url.split("?")[0];
-    const path = fileURLToPath(url);
+    const cleanUrl = url.replace(WITH_TYPE_RE, "").split("?")[0];
+    const path = cleanUrl.startsWith("file://") ? fileURLToPath(cleanUrl) : cleanUrl;
     const loader = match(this.#loaders, path, options.type);
     if (!loader) return nextLoad(url, context);
     options.path = path;