@voidzero-dev/vite-plus-core 0.2.9 → 0.3.1

package/dist/tsdown/{tsc-JnMl2z7d.js → tsc-ChjRhsoQ.js}

@@ -1,11 +1,11 @@
-import { r as createDebug } from "./main-DiierkER.js";
-import { h as RE_DTS_MAP, m as RE_DTS } from "./target-Bab3CUeB-DQ0pKhCv.js";
-import { n as globalContext, t as requireTS } from "./dist-DyXLnzyh.js";
+import { r as createDebug } from "./main-CyNcZUzu.js";
+import { n as RE_DTS, r as RE_DTS_MAP } from "./internal-D-JfB5uT.js";
+import { n as globalContext, t as requireTSApi } from "./dist-Cuw3Ngo4.js";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-//#region ../../node_modules/.pnpm/rolldown-plugin-dts@0.27.13_@typescript+native-preview@7.0.0-dev.20260605.1_oxc-resolve_19173df252fb1b72b750fe1e656588b8/node_modules/rolldown-plugin-dts/dist/tsc-KtFHcISk.mjs
+//#region ../../node_modules/.pnpm/rolldown-plugin-dts@0.28.5_@typescript+native-preview@7.0.0-dev.20260605.1_oxc-resolver_395c84c3f0e463da1bb9023138bdcb2e/node_modules/rolldown-plugin-dts/dist/tsc-9-3lXpbY.mjs
 const debug$3 = createDebug("rolldown-plugin-dts:tsc-system");
-const ts$3 = requireTS();
+const ts$3 = requireTSApi();
 /**
 * A system that writes files to both memory and disk. It will try read files
 * from memory firstly and fallback to disk if not found.
@@ -21,7 +21,7 @@ function createFsSystem(files) {
 			return ts$3.sys.resolvePath(path);
 		},
 		directoryExists(directory) {
-			if (Array.from(files.keys()).some((path) => path.startsWith(directory))) return true;
+			if (files.keys().some((path) => path.startsWith(directory))) return true;
 			return ts$3.sys.directoryExists(directory);
 		},
 		fileExists(fileName) {
@@ -53,7 +53,7 @@ function createMemorySystem(files) {
 		}
 	};
 }
-const ts$2 = requireTS();
+const ts$2 = requireTSApi();
 const formatHost = {
 	getCurrentDirectory: () => ts$2.sys.getCurrentDirectory(),
 	getNewLine: () => ts$2.sys.newLine,
@@ -81,7 +81,7 @@ function setSourceMapRoot(map, originalFilePath, finalFilePath) {
 	const finalDir = path.posix.dirname(pathToFileURL(finalFilePath).pathname);
 	if (originalDir !== finalDir) map.sourceRoot = path.posix.relative(finalDir, originalDir);
 }
-const ts$1 = requireTS();
+const ts$1 = requireTSApi();
 const debug$2 = createDebug("rolldown-plugin-dts:tsc-build");
 function tscEmitBuild(tscOptions) {
 	const { id, tsconfig, incremental, context = globalContext, sourcemap } = tscOptions;
@@ -152,7 +152,11 @@ function buildProjects(fsSystem, tsconfig, force, sourcemap) {
 	debug$2(`start building projects for ${tsconfig}`);
 	const projects = collectProjectGraph(tsconfig, fsSystem, force, sourcemap);
 	debug$2("collected %d projects: %j", projects.length, projects.map((project) => project.tsconfigPath));
-	const host = ts$1.createSolutionBuilderHost(fsSystem, createProgramWithPatchedCompilerOptions);
+	const host = ts$1.createSolutionBuilderHost(fsSystem, createProgramWithPatchedCompilerOptions({
+		force,
+		sourcemap,
+		tsconfigPath: tsconfig
+	}));
 	const exitStatus = ts$1.createSolutionBuilder(host, [tsconfig], {
 		force,
 		verbose: true
@@ -182,7 +186,7 @@ function collectProjectGraph(rootTsconfigPath, fsSystem, force, sourcemap) {
 		parsedConfig.options = patchCompilerOptions(parsedConfig.options, {
 			tsconfigPath,
 			force,
-			sourcemap
+			sourcemap: sourcemap && parsedConfig.fileNames.length > 0
 		});
 		projects.push({
 			tsconfigPath,
@@ -231,11 +235,13 @@ function patchCompilerOptions(options, extraOptions) {
 	}
 	return options;
 }
-const createProgramWithPatchedCompilerOptions = (rootNames, options, ...args) => {
-	return ts$1.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, patchCompilerOptions(options ?? {}, null), ...args);
-};
+function createProgramWithPatchedCompilerOptions(patchOptions) {
+	return (rootNames, options, ...args) => {
+		return ts$1.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, patchCompilerOptions(options ?? {}, patchOptions), ...args);
+	};
+}
 const debug$1 = createDebug("rolldown-plugin-dts:tsc-compiler");
-const ts = requireTS();
+const ts = requireTSApi();
 const defaultCompilerOptions = {
 	declaration: true,
 	noEmit: false,
@@ -268,10 +274,10 @@ function createOrGetTsModule(options) {
 	context.programs.push(module.program);
 	return module;
 }
-function createTsProgram({ entries, id, tsconfig, tsconfigRaw, volarContext, cwd, context = globalContext }) {
+function createTsProgram({ entries, id, tsconfig, tsconfigRaw, languageContext, cwd, context = globalContext }) {
 	const fsSystem = createFsSystem(context.files);
 	const baseDir = tsconfig ? path.dirname(tsconfig) : cwd;
-	const parsedConfig = ts.parseJsonConfigFileContent(tsconfigRaw, fsSystem, baseDir, void 0, void 0, void 0, volarContext.getExtraFileExtensions());
+	const parsedConfig = ts.parseJsonConfigFileContent(tsconfigRaw, fsSystem, baseDir, void 0, void 0, void 0, languageContext.getExtraFileExtensions());
 	debug$1(`creating program for root project: ${baseDir}`);
 	return createTsProgramFromParsedConfig({
 		parsedConfig,
@@ -279,20 +285,20 @@ function createTsProgram({ entries, id, tsconfig, tsconfigRaw, volarContext, cwd
 		baseDir,
 		id,
 		entries,
-		volarContext
+		languageContext
 	});
 }
-function createTsProgramFromParsedConfig({ parsedConfig, fsSystem, baseDir, id, entries, volarContext }) {
+function createTsProgramFromParsedConfig({ parsedConfig, fsSystem, baseDir, id, entries, languageContext }) {
 	const compilerOptions = {
 		...defaultCompilerOptions,
 		...parsedConfig.options,
 		$configRaw: parsedConfig.raw,
 		$rootDir: baseDir,
-		...volarContext.plugins.length ? { allowNonTsExtensions: true } : void 0
+		...languageContext.languages.length ? { allowNonTsExtensions: true } : void 0
 	};
 	const rootNames = [...new Set([id, ...entries || parsedConfig.fileNames].map((f) => fsSystem.resolvePath(f)))];
 	const host = ts.createCompilerHost(compilerOptions, true);
-	const program = volarContext.getCreateProgram(ts)({
+	const program = languageContext.getCreateProgram(ts)({
 		rootNames,
 		options: compilerOptions,
 		host,

package/dist/tsdown/tsdown-css.js

@@ -1,12 +1,11 @@
-import { A as __toESM, C as resolveComma, E as toArray, y as importWithError } from "./main-DiierkER.js";
-import { i as expandBaselineTarget } from "./target-Bab3CUeB-DQ0pKhCv.js";
-import "./internal-DKworeK4.js";
+import { i as __toESM } from "./rolldown-runtime-B4iAMlE-.js";
+import { a as resolveComma, i as importWithError, o as toArray, r as expandBaselineTarget } from "./internal-lhH-5yya.js";
 import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { ResolverFactory } from "@voidzero-dev/vite-plus-core/rolldown/experimental";
-//#region ../../node_modules/.pnpm/@tsdown+css@0.22.14_jiti@2.7.0_postcss-import@16.1.1_postcss@8.5.25__postcss@8.5.25_sas_6a16dd13a926d2b2137531bbae459a0e/node_modules/@tsdown/css/dist/index.mjs
+//#region ../../node_modules/.pnpm/@tsdown+css@0.23.0_jiti@2.7.0_postcss-import@16.2.0_postcss@8.5.26__postcss-modules@9.0_5274324ff2ff6c48cc66985619453a8b/node_modules/@tsdown/css/dist/index.mjs
 const defaultCssBundleName = "style.css";
 function resolveCssOptions(options = {}, topLevelTarget, unbundle) {
 	let cssTarget;
@@ -40,9 +39,13 @@ function modulesToEsm(modules) {
 function dashToCamel(str) {
 	return str.replaceAll(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
-function applyLocalsConvention(modules, convention) {
+function applyLocalsConvention(modules, convention, inputFile) {
 	const result = {};
 	for (const [key, value] of Object.entries(modules)) {
+		if (typeof convention === "function") {
+			result[convention(key, value, inputFile)] = value;
+			continue;
+		}
 		const camelized = dashToCamel(key);
 		switch (convention) {
 			case "camelCase":
@@ -426,6 +429,7 @@ async function bundleWithLightningCSS(filename, options, code) {
 		sourceMap: options.sourceMap,
 		resolver: {
 			async read(filePath) {
+				if (filePath !== filename) deps.push(filePath);
 				let fileCode;
 				if (code != null && filePath === filename) fileCode = code;
 				else fileCode = readFileSync(filePath, "utf8");
@@ -604,7 +608,7 @@ async function loadFileConfig(searchPath) {
 	if (cached !== void 0) return cached;
 	const promise = (async () => {
 		try {
-			const postcssrc = (await import("./src-drVPfX63.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1))).default;
+			const postcssrc = (await import("./src-BWidcM5N.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1))).default;
 			const result = await postcssrc({}, searchPath);
 			return {
 				options: result.options,
@@ -636,9 +640,9 @@ async function processWithPostCSS$1(code, filename, postcssOption, cwd, injectIm
 	let modules;
 	if (modulesOptions?.isModule) {
 		const postcssModules = await importWithError("postcss-modules");
-		const { localsConvention: _, getJSON: userGetJSON, ...rest } = modulesOptions.config ?? {};
+		const userGetJSON = modulesOptions.config?.getJSON;
 		plugins.push((postcssModules.default ?? postcssModules)({
-			...rest,
+			...modulesOptions.config,
 			getJSON(cssFileName, json, outputFileName) {
 				modules = json;
 				userGetJSON?.(cssFileName, json, outputFileName);
@@ -751,8 +755,10 @@ function CssPlugin(config, { logger }) {
 				if (code.length && !code.endsWith("\n")) code += "\n";
 				if (modules) {
 					const modulesConfig = typeof cssConfig.css.modules === "object" ? cssConfig.css.modules : void 0;
-					if (modulesConfig?.localsConvention) modules = applyLocalsConvention(modules, modulesConfig.localsConvention);
-					modulesConfig?.getJSON?.(cleanId, modules, cleanId);
+					if (cssConfig.css.transformer === "lightningcss") {
+						if (modulesConfig?.localsConvention) modules = applyLocalsConvention(modules, modulesConfig.localsConvention, cleanId);
+						modulesConfig?.getJSON?.(cleanId, modules, cleanId);
+					}
 					modulesMap.set(id, modules);
 				}
 				return {

package/dist/tsdown/tsdown-exe.js

@@ -1,15 +1,26 @@
-import { n as x, r as createDebug } from "./main-DiierkER.js";
-import { O as fsExists, c as isGreaterOrEqual, f as tryParse, k as fsRemove, l as normalize$1, n as NODE_SEA_MIN_VERSION_PARSED, t as NODE_SEA_MIN_VERSION } from "./target-Bab3CUeB-DQ0pKhCv.js";
-import "./internal-DKworeK4.js";
+import { n as x, r as createDebug } from "./main-CyNcZUzu.js";
+import { g as tryParse, n as normalize$1, p as isGreaterOrEqual } from "./version-CQ98ZBpL-Obdnv4J7.js";
+import { n as NODE_SEA_MIN_VERSION_PARSED, t as NODE_SEA_MIN_VERSION } from "./internal-lhH-5yya.js";
 import process from "node:process";
 import path from "node:path";
 import { pipeline } from "node:stream/promises";
 import { Readable } from "node:stream";
 import { createReadStream, createWriteStream } from "node:fs";
-import { chmod, mkdir, rename } from "node:fs/promises";
+import { access, chmod, mkdir, rename, rm } from "node:fs/promises";
 import os from "node:os";
 import { createHash } from "node:crypto";
-//#region ../../node_modules/.pnpm/@tsdown+exe@0.22.14_tsdown@0.22.14/node_modules/@tsdown/exe/dist/index.mjs
+//#region ../../node_modules/.pnpm/tsdown@0.23.0_@arethetypeswrong+core@0.18.2_@tsdown+css@0.23.0_@tsdown+exe@0.23.0_@type_fb7663f033a892291c41712eea6060f6/node_modules/tsdown/dist/format-DLxyxnif.mjs
+function fsExists(path) {
+	return access(path).then(() => true, () => false);
+}
+function fsRemove(path) {
+	return rm(path, {
+		force: true,
+		recursive: true
+	}).catch(() => {});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tsdown+exe@0.23.0_tsdown@0.23.0/node_modules/@tsdown/exe/dist/index.mjs
 function getCacheDir() {
 	const home = os.homedir();
 	if (process.platform === "win32") {

package/dist/tsdown/version-CQ98ZBpL-Obdnv4J7.js

@@ -0,0 +1,141 @@
+//#region ../../node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/comparison-DenM3wCn.js
+const LETTER_DASH_NUMBER = "[a-zA-Z0-9-]";
+const NUMERIC_IDENTIFIER = String.raw`0|[1-9]\d*`;
+const NUMERIC_IDENTIFIER_LOOSE = String.raw`\d+`;
+const NON_NUMERIC_IDENTIFIER = String.raw`\d*[a-zA-Z-]${LETTER_DASH_NUMBER}*`;
+const MAIN_VERSION = String.raw`(${NUMERIC_IDENTIFIER})\.(${NUMERIC_IDENTIFIER})\.(${NUMERIC_IDENTIFIER})`;
+const MAIN_VERSION_LOOSE = String.raw`(${NUMERIC_IDENTIFIER_LOOSE})\.(${NUMERIC_IDENTIFIER_LOOSE})\.(${NUMERIC_IDENTIFIER_LOOSE})`;
+const PRERELEASE_IDENTIFIER = `(?:${NON_NUMERIC_IDENTIFIER}|${NUMERIC_IDENTIFIER})`;
+const PRERELEASE_IDENTIFIER_LOOSE = `(?:${NON_NUMERIC_IDENTIFIER}|${NUMERIC_IDENTIFIER_LOOSE})`;
+const PRERELEASE = String.raw`(?:-(${PRERELEASE_IDENTIFIER}(?:\.${PRERELEASE_IDENTIFIER})*))`;
+const PRERELEASE_LOOSE = String.raw`(?:-?(${PRERELEASE_IDENTIFIER_LOOSE}(?:\.${PRERELEASE_IDENTIFIER_LOOSE})*))`;
+const BUILD_IDENTIFIER = `${LETTER_DASH_NUMBER}+`;
+const BUILD = String.raw`(?:\+(${BUILD_IDENTIFIER}(?:\.${BUILD_IDENTIFIER})*))`;
+const FULL_PLAIN = `v?${MAIN_VERSION}${PRERELEASE}?${BUILD}?`;
+const LOOSE_PLAIN = String.raw`[v=\s]*${MAIN_VERSION_LOOSE}${PRERELEASE_LOOSE}?${BUILD}?`;
+const GREATER_LESS_THAN = "((?:<|>)?=?)";
+const XRANGE_IDENTIFIER = String.raw`${NUMERIC_IDENTIFIER}|x|X|\*`;
+const XRANGE_IDENTIFIER_LOOSE = String.raw`${NUMERIC_IDENTIFIER_LOOSE}|x|X|\*`;
+const XRANGE_PLAIN = String.raw`[v=\s]*(${XRANGE_IDENTIFIER})(?:\.(${XRANGE_IDENTIFIER})(?:\.(${XRANGE_IDENTIFIER})(?:${PRERELEASE})?${BUILD}?)?)?`;
+const XRANGE_PLAIN_LOOSE = String.raw`[v=\s]*(${XRANGE_IDENTIFIER_LOOSE})(?:\.(${XRANGE_IDENTIFIER_LOOSE})(?:\.(${XRANGE_IDENTIFIER_LOOSE})(?:${PRERELEASE_LOOSE})?${BUILD}?)?)?`;
+const LONE_TILDE = "(?:~>?)";
+const LONE_CARET = String.raw`(?:\^)`;
+const COERCE_PLAIN = String.raw`(^|[^\d])(\d{1,${16}})(?:\.(\d{1,${16}}))?(?:\.(\d{1,${16}}))?`;
+const COERCE = String.raw`${COERCE_PLAIN}(?:$|[^\d])`;
+const COERCE_FULL = String.raw`${COERCE_PLAIN}(?:${PRERELEASE})?(?:${BUILD})?(?:$|[^\d])`;
+function makeSafeRegexSource(source) {
+	const replacements = [
+		[String.raw`\s`, 1],
+		[String.raw`\d`, 256],
+		[LETTER_DASH_NUMBER, 250]
+	];
+	for (const [token, maximum] of replacements) source = source.split(`${token}*`).join(`${token}{0,${maximum}}`).split(`${token}+`).join(`${token}{1,${maximum}}`);
+	return source;
+}
+function safeRegex(source, flags) {
+	return new RegExp(makeSafeRegexSource(source), flags);
+}
+const FULL = safeRegex(`^${FULL_PLAIN}$`);
+const LOOSE = safeRegex(`^${LOOSE_PLAIN}$`);
+const NUMERIC$1 = /^\d+$/;
+function formatComparableVersion(version) {
+	const base = `${version.major}.${version.minor}.${version.patch}`;
+	return version.prerelease?.length ? `${base}-${version.prerelease.join(".")}` : base;
+}
+function parse(version, options = {}) {
+	if (typeof version !== "string") return version;
+	if (version.length > 256) throw new TypeError(`Version exceeds the maximum length of 256 characters`);
+	const match = version.trim().match(options.loose ? LOOSE : FULL);
+	if (!match) throw new TypeError(`Invalid version syntax: ${version}`);
+	const major = Number(match[1]);
+	const minor = Number(match[2]);
+	const patch = Number(match[3]);
+	if (major > Number.MAX_SAFE_INTEGER || major < 0) throw new TypeError(`Invalid major version: ${match[1]}`);
+	if (minor > Number.MAX_SAFE_INTEGER || minor < 0) throw new TypeError(`Invalid minor version: ${match[2]}`);
+	if (patch > Number.MAX_SAFE_INTEGER || patch < 0) throw new TypeError(`Invalid patch version: ${match[3]}`);
+	const prerelease = match[4] ? match[4].split(".").map((identifier) => {
+		if (NUMERIC$1.test(identifier)) {
+			const numeric = Number(identifier);
+			if (numeric >= 0 && numeric < Number.MAX_SAFE_INTEGER) return numeric;
+		}
+		return identifier;
+	}) : void 0;
+	return {
+		build: match[5]?.split("."),
+		major,
+		minor,
+		patch,
+		prerelease
+	};
+}
+function tryParse(version, options = {}) {
+	try {
+		return parse(version, options);
+	} catch {
+		return null;
+	}
+}
+const NUMERIC = /^\d+$/;
+function compareIdentifiers(left, right) {
+	if (typeof left === "number" && typeof right === "number") return left === right ? 0 : left < right ? -1 : 1;
+	const leftNumeric = NUMERIC.test(String(left));
+	const rightNumeric = NUMERIC.test(String(right));
+	const normalizedLeft = leftNumeric ? Number(left) : left;
+	const normalizedRight = rightNumeric ? Number(right) : right;
+	return normalizedLeft === normalizedRight ? 0 : leftNumeric && !rightNumeric ? -1 : rightNumeric && !leftNumeric ? 1 : normalizedLeft < normalizedRight ? -1 : 1;
+}
+function compareMainParsed(left, right) {
+	return left.major === right.major ? left.minor === right.minor ? left.patch === right.patch ? 0 : left.patch < right.patch ? -1 : 1 : left.minor < right.minor ? -1 : 1 : left.major < right.major ? -1 : 1;
+}
+function comparePrereleaseParsed(left, right) {
+	const leftPrerelease = left.prerelease;
+	const rightPrerelease = right.prerelease;
+	if (leftPrerelease?.length && !rightPrerelease?.length) return -1;
+	if (!leftPrerelease?.length && rightPrerelease?.length) return 1;
+	if (!leftPrerelease?.length && !rightPrerelease?.length) return 0;
+	for (let index = 0;; index++) {
+		const leftIdentifier = leftPrerelease?.[index];
+		const rightIdentifier = rightPrerelease?.[index];
+		if (leftIdentifier === void 0 && rightIdentifier === void 0) return 0;
+		if (rightIdentifier === void 0) return 1;
+		if (leftIdentifier === void 0) return -1;
+		if (leftIdentifier !== rightIdentifier) return compareIdentifiers(leftIdentifier, rightIdentifier);
+	}
+}
+function compareParsed(left, right) {
+	return compareMainParsed(left, right) || comparePrereleaseParsed(left, right);
+}
+function compare(left, right, options = {}) {
+	return compareParsed(parse(left, options), parse(right, options));
+}
+function isGreaterOrEqual(left, right, options = {}) {
+	return compare(left, right, options) >= 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/version-CQ98ZBpL.js
+const COERCE_EXACT = safeRegex(COERCE);
+const COERCE_FULL_EXACT = safeRegex(COERCE_FULL);
+safeRegex(`^${PRERELEASE}$`);
+safeRegex(`^${PRERELEASE_LOOSE}$`);
+function normalize(version, options = {}) {
+	const parsed = tryParse(version, options);
+	return parsed ? formatComparableVersion(parsed) : null;
+}
+function coerce(value, options = {}) {
+	if (typeof value === "object") return value;
+	const input = typeof value === "number" ? String(value) : value;
+	let match = null;
+	if (options.rtl) {
+		const expression = safeRegex(options.includePrerelease ? COERCE_FULL : COERCE, "g");
+		let next;
+		while ((next = expression.exec(input)) && (!match || match.index + match[0].length !== input.length)) {
+			if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;
+			expression.lastIndex = next.index + next[1].length + next[2].length;
+		}
+	} else match = (options.includePrerelease ? COERCE_FULL_EXACT : COERCE_EXACT).exec(input);
+	if (!match) return null;
+	const major = match[2];
+	return tryParse(`${major}.${match[3] || "0"}.${match[4] || "0"}${options.includePrerelease && match[5] ? `-${match[5]}` : ""}${options.includePrerelease && match[6] ? `+${match[6]}` : ""}`, options);
+}
+//#endregion
+export { GREATER_LESS_THAN as a, LOOSE_PLAIN as c, compareParsed as d, formatComparableVersion as f, tryParse as g, safeRegex as h, FULL_PLAIN as i, XRANGE_PLAIN as l, parse as m, normalize as n, LONE_CARET as o, isGreaterOrEqual as p, BUILD as r, LONE_TILDE as s, coerce as t, XRANGE_PLAIN_LOOSE as u };

package/dist/vite/client/bundledDevClient.mjs

@@ -41,7 +41,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 //#endregion
-//#region \0@oxc-project+runtime@0.143.0/helpers/esm/typeof.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -51,7 +51,7 @@ function _typeof(o) {
 	}, _typeof(o);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.143.0/helpers/esm/toPrimitive.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/toPrimitive.js
 function toPrimitive(t, r) {
 	if ("object" != _typeof(t) || !t) return t;
 	var e = t[Symbol.toPrimitive];
@@ -63,13 +63,13 @@ function toPrimitive(t, r) {
 	return ("string" === r ? String : Number)(t);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.143.0/helpers/esm/toPropertyKey.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/toPropertyKey.js
 function toPropertyKey(t) {
 	var i = toPrimitive(t, "string");
 	return "symbol" == _typeof(i) ? i : i + "";
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.143.0/helpers/esm/defineProperty.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/defineProperty.js
 function _defineProperty(e, r, t) {
 	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 		value: t,
@@ -287,9 +287,9 @@ var DevRuntime = class {
 	}
 	/**
 	* @param {string} id
-	* @param {{ exports: any }} exportsHolder
+	* @param {{ exports: any }} [exportsHolder]
 	*/
-	registerModule(id, exportsHolder) {
+	registerModule(id, exportsHolder = { exports: {} }) {
 		const module = new Module(id);
 		module.exportsHolder = exportsHolder;
 		this.moduleCache.set(id, module);
@@ -585,7 +585,11 @@ var BundledDevHMRClient = class extends HMRClient {
 			reason: `update propagated back to ${firstInvalidatedBy}, which already called \`import.meta.hot.invalidate()\``
 		};
 		if (this.isSelfAccepted(id)) {
-			boundaries.push([id, id]);
+			boundaries.push({
+				boundary: id,
+				acceptedVia: id,
+				isWithinCircularImport: this.isNodeWithinCircularImports(id, stack)
+			});
 			return;
 		}
 		const parents = this.runtime.getImporters(id).filter((p) => this.runtime.isExecuted(p));
@@ -594,17 +598,52 @@ var BundledDevHMRClient = class extends HMRClient {
 			reason: `no hmr boundary found for module \`${id}\``
 		};
 		for (const parent of parents) {
+			const subChain = [...stack, parent];
 			if (this.acceptsDep(parent, id)) {
-				boundaries.push([parent, id]);
+				boundaries.push({
+					boundary: parent,
+					acceptedVia: id,
+					isWithinCircularImport: this.isNodeWithinCircularImports(parent, subChain)
+				});
 				continue;
 			}
-			if (stack.includes(parent)) return {
-				type: "full-reload",
-				reason: `circular import chain between \`${id}\` and \`${parent}\``
-			};
-			const fullReload = this.bubble(parent, [...stack, parent], updateSet, boundaries, firstInvalidatedBy, traversedModules);
-			if (fullReload) return fullReload;
+			if (!stack.includes(parent)) {
+				const fullReload = this.bubble(parent, subChain, updateSet, boundaries, firstInvalidatedBy, traversedModules);
+				if (fullReload) return fullReload;
+			}
+		}
+	}
+	/**
+	* Check importers recursively if it's an import loop. An accepted module within
+	* an import loop cannot recover its execution order and should be reloaded.
+	*
+	* @param node The node that accepts HMR and is a boundary
+	* @param nodeChain The chain of nodes/imports that lead to the node.
+	*   (The last node in the chain imports the `node` parameter)
+	* @param currentChain The current chain tracked from the `node` parameter
+	* @param traversedModules The set of modules that have traversed
+	*/
+	isNodeWithinCircularImports(node, nodeChain, currentChain = [node], traversedModules = /* @__PURE__ */ new Set()) {
+		if (traversedModules.has(node)) return false;
+		traversedModules.add(node);
+		for (const importer of this.runtime.getImporters(node)) {
+			if (importer === node) continue;
+			const importerIndex = nodeChain.indexOf(importer);
+			if (importerIndex > -1) {
+				const importChain = [
+					importer,
+					...[...currentChain].reverse(),
+					...nodeChain.slice(importerIndex, -1).reverse()
+				];
+				this.logger.debug(`circular imports detected: ${importChain.join(" -> ")}`);
+				return true;
+			}
+			if (!currentChain.includes(importer)) {
+				const result = this.isNodeWithinCircularImports(importer, nodeChain, currentChain.concat(importer), traversedModules);
+				if (result) return result;
+			}
 		}
+		return false;
 	}
 	handlePush(payload) {
 		this.applyQueue = this.applyQueue.then(() => this.applyPush(payload)).catch((err) => {
@@ -674,15 +713,25 @@ var BundledDevHMRClient = class extends HMRClient {
 			this.requestFullReload(`no factory for module \`${id}\``);
 			return;
 		}
-		const applies = update.boundaries.map(([boundary, acceptedVia]) => ({
+		const applies = update.boundaries.map(({ boundary, acceptedVia, isWithinCircularImport }) => ({
 			boundary,
 			acceptedVia,
+			isWithinCircularImport,
 			callbacks: this.hotModulesMap.get(boundary)?.callbacks.filter((c) => c.deps.includes(acceptedVia)) ?? []
 		}));
 		for (const id of update.updateSet) this.runtime.removeModuleCache(id);
-		for (const { boundary, acceptedVia, callbacks } of applies) {
-			this.runtime.initModule(acceptedVia);
-			const fresh = this.runtime.loadExports(acceptedVia);
+		for (const { boundary, acceptedVia, isWithinCircularImport, callbacks } of applies) {
+			let fresh;
+			try {
+				this.runtime.initModule(acceptedVia);
+				fresh = this.runtime.loadExports(acceptedVia);
+			} catch (err) {
+				if (isWithinCircularImport) {
+					this.requestFullReload(`${acceptedVia} failed to apply HMR as it's within a circular import. Reloading page to reset the execution order.`);
+					return;
+				}
+				throw err;
+			}
 			try {
 				this.currentFirstInvalidatedBy = firstInvalidatedBy;
 				for (const { deps, fn } of callbacks) fn(deps.map((dep) => dep === acceptedVia ? fresh : void 0));
@@ -695,11 +744,12 @@ var BundledDevHMRClient = class extends HMRClient {
 	toUpdatePayload(boundaries, firstInvalidatedBy) {
 		return {
 			type: "update",
-			updates: boundaries.map(([boundary, acceptedVia]) => ({
+			updates: boundaries.map(({ boundary, acceptedVia, isWithinCircularImport }) => ({
 				type: "js-update",
 				path: boundary,
 				acceptedPath: acceptedVia,
 				timestamp: Date.now(),
+				isWithinCircularImport,
 				firstInvalidatedBy
 			}))
 		};

package/dist/vite/client/client.mjs

@@ -1,5 +1,5 @@
 import "@vite/env";
-//#region \0@oxc-project+runtime@0.143.0/helpers/esm/typeof.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -9,7 +9,7 @@ function _typeof(o) {
 	}, _typeof(o);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.143.0/helpers/esm/toPrimitive.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/toPrimitive.js
 function toPrimitive(t, r) {
 	if ("object" != _typeof(t) || !t) return t;
 	var e = t[Symbol.toPrimitive];
@@ -21,13 +21,13 @@ function toPrimitive(t, r) {
 	return ("string" === r ? String : Number)(t);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.143.0/helpers/esm/toPropertyKey.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/toPropertyKey.js
 function toPropertyKey(t) {
 	var i = toPrimitive(t, "string");
 	return "symbol" == _typeof(i) ? i : i + "";
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.143.0/helpers/esm/defineProperty.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/defineProperty.js
 function _defineProperty(e, r, t) {
 	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 		value: t,