@stencil/core 5.0.0-beta.0 → 5.0.0-beta.10

package/dist/{compiler-NrvbUOX1.mjs → compiler-PoywOlbq.mjs}

@@ -1,9 +1,9 @@
 import { n as __require } from "./rolldown-runtime-BhDjJH2R.mjs";
-import { S as HYDRATED_CSS } from "./client-BRu0GtRn.mjs";
+import { S as HYDRATED_CSS } from "./client-Db2rdxUM.mjs";
 import { $ as VALID_CONFIG_OUTPUT_TARGETS, A as DIST_LAZY, D as COPY, E as COLLECTION_MANIFEST_FILE_NAME, J as STANDALONE, L as EVENT_FLAGS, P as DOCS_JSON, Q as TYPES, R as GENERATED_DTS, S as ASSETS, T as COLLECTION_APP_DATA_FILE_NAME, U as LOADER_BUNDLE, X as STYLE_EXT, Y as STATS, a as isBoolean$1, b as unique, c as isFunction, d as isObject, et as WATCH_FLAGS, f as isString$1, g as sortBy, i as fromEntries, l as isIterable, m as noop, p as mergeIntoWith, r as flatOne, t as dashToPascalCase, u as isNumber$1, v as toDashCase, w as COLLECTION, y as toTitleCase, z as GLOBAL_STYLE } from "./helpers-Cpp3qc3u.mjs";
 import { E as escapeRegExpSpecialCharacters, S as formatComponentRuntimeMeta, T as byteSize, _ as loadRolldownDiagnostics, a as getSourceMappingUrlForEndOfFile, b as splitLineBreaks, c as err, f as augmentDiagnosticWithNode, g as isRolldownError, h as createOnWarnFn, i as getInlineSourceMappingUrlLinker, l as map, m as loadTypeScriptDiagnostics, n as validateComponentTag, p as loadTypeScriptDiagnostic, r as isRemoteUrl, s as rolldownToStencilSourceMap, t as validateComponentModes, u as ok, w as stringifyRuntimeData, x as isRootPath, y as normalizeDiagnostics } from "./validation-DAdGTrys.mjs";
 import { $ as catchError, A as isOutputTargetDocsVscode, B as relativeImport, C as isOutputTargetDistLazy, D as isOutputTargetDocsCustomElementsManifest, E as isOutputTargetDocsCustom, F as isOutputTargetStandalone, G as normalizeFsPathQuery, H as join$2, I as isOutputTargetStats, J as resolve$2, K as normalizePath, L as isOutputTargetTypes, M as isOutputTargetLoaderBundle, N as isOutputTargetSsr, O as isOutputTargetDocsJson, P as isOutputTargetSsrWasm, Q as buildWarn, R as isOutputTargetWww, S as isOutputTargetCustom, T as isOutputTargetDocsAgentSkill, W as normalizeFsPath, X as buildError, Z as buildJsonFileError, a as hasDependency, b as isOutputTargetCollection, d as parsePackageJson, et as hasError, f as readOnlyArrayHasStringMember, g as getComponentsDtsSrcFilePath, h as filterExcludedComponents, i as getTextDocs, j as isOutputTargetGlobalStyle, k as isOutputTargetDocsReadme, l as isTsFile, m as filterActiveTargets, n as createJsVarName, o as isDtsFile, p as readPackageJson, q as relative$1, r as generatePreamble, rt as isGlob, t as addDocBlock, tt as hasWarning, u as isTsxFile, v as getComponentsFromModules, w as isOutputTargetDocs, x as isOutputTargetCopy, y as isOutputTargetAssets, z as isValidConfigOutputTarget } from "./util-IKfWWLJo.mjs";
-import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-75gQKkFz.mjs";
+import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-BKtLn2R9.mjs";
 import ts, { default as ts$1 } from "typescript";
 import { readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
@@ -17,6 +17,7 @@ import postcssSelectorParser from "postcss-selector-parser";
 import MagicString from "magic-string";
 import { rolldown } from "rolldown";
 import resolve$1 from "resolve";
+import { minifySync } from "rolldown/utils";
 import { minify } from "terser";
 import { SelectorType, parse, stringify } from "css-what";
 import { execFile } from "node:child_process";
@@ -72,12 +73,13 @@ const restoreSafeSelector = (placeholders, content) => {
 const _polyfillHost = "-shadowcsshost";
 const _polyfillSlotted = "-shadowcssslotted";
 const _polyfillHostContext = "-shadowcsscontext";
+const _parenSuffix = ")(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))?([^,{]*)";
 let _cssColonHostRe;
 let _cssColonHostContextRe;
 let _cssColonSlottedRe;
-const getCssColonHostRe = () => _cssColonHostRe ??= /* @__PURE__ */ new RegExp("(-shadowcsshost)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))?([^,{]*)", "gim");
-const getCssColonHostContextRe = () => _cssColonHostContextRe ??= /* @__PURE__ */ new RegExp("(-shadowcsscontext)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))?([^,{]*)", "gim");
-const getCssColonSlottedRe = () => _cssColonSlottedRe ??= /* @__PURE__ */ new RegExp("(-shadowcssslotted)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))?([^,{]*)", "gim");
+const getCssColonHostRe = () => _cssColonHostRe ??= new RegExp("(-shadowcsshost" + _parenSuffix, "gim");
+const getCssColonHostContextRe = () => _cssColonHostContextRe ??= new RegExp("(-shadowcsscontext" + _parenSuffix, "gim");
+const getCssColonSlottedRe = () => _cssColonSlottedRe ??= new RegExp("(-shadowcssslotted" + _parenSuffix, "gim");
 const _polyfillHostNoCombinator = "-shadowcsshost-no-combinator";
 const _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\s]*)/;
 const _shadowDOMSelectorsRe = [/::shadow/g, /::content/g];
@@ -340,12 +342,13 @@ const scopeSelector = (selector, scopeSelectorText, hostSelector, slotSelector)
 		else return shallowPart.trim();
 	}).join(", ");
 };
+const isScopableAtRule = (selector) => selector.startsWith("@media") || selector.startsWith("@supports") || selector.startsWith("@page") || selector.startsWith("@document") || selector.startsWith("@layer");
 const scopeSelectors = (cssText, scopeSelectorText, hostSelector, slotSelector, commentOriginalSelector) => {
 	return processRules(cssText, (rule) => {
 		let selector = rule.selector;
 		let content = rule.content;
 		if (rule.selector[0] !== "@") selector = scopeSelector(rule.selector, scopeSelectorText, hostSelector, slotSelector);
-		else if (rule.selector.startsWith("@media") || rule.selector.startsWith("@supports") || rule.selector.startsWith("@page") || rule.selector.startsWith("@document")) content = scopeSelectors(rule.content, scopeSelectorText, hostSelector, slotSelector, commentOriginalSelector);
+		else if (isScopableAtRule(rule.selector)) content = scopeSelectors(rule.content, scopeSelectorText, hostSelector, slotSelector, commentOriginalSelector);
 		return {
 			selector: selector.replace(/\s{2,}/g, " ").trim(),
 			content
@@ -437,14 +440,12 @@ const scopeCss = (cssText, scopeId, commentOriginalSelector) => {
 			rule.selector = placeholder + rule.selector;
 			return rule;
 		};
-		cssText = processRules(cssText, (rule) => {
+		const commentSelectors = (input) => processRules(input, (rule) => {
 			if (rule.selector[0] !== "@") return processCommentedSelector(rule);
-			else if (rule.selector.startsWith("@media") || rule.selector.startsWith("@supports") || rule.selector.startsWith("@page") || rule.selector.startsWith("@document")) {
-				rule.content = processRules(rule.content, processCommentedSelector);
-				return rule;
-			}
+			if (isScopableAtRule(rule.selector)) rule.content = commentSelectors(rule.content);
 			return rule;
 		});
+		cssText = commentSelectors(cssText);
 	}
 	const scoped = scopeCssText(cssText, scopeId, hostScopeId, slotScopeId, commentOriginalSelector);
 	cssText = [scoped.cssText, ...commentsWithHash].join("\n");
@@ -460,9 +461,9 @@ const scopeCss = (cssText, scopeId, commentOriginalSelector) => {
 };
 //#endregion
 //#region src/version.ts
-const version = "5.0.0-beta.0";
-const buildId = "1787699045";
-const vermoji = "🐥";
+const version = "5.0.0-beta.10";
+const buildId = "1789054824";
+const vermoji = "🚘";
 /**
 * Get the installed version of a tool/dependency.
 * Handles packages with exports maps that point to subdirectories.
@@ -1020,6 +1021,7 @@ const REGISTER_HOST = "__stencil_registerHost";
 const H = "__stencil_h";
 const TRANSFORM_TAG = "__stencil_transformTag";
 const GET_REGISTRY = "__stencil_getRegistry";
+const INJECT_SIDE_EFFECT_STYLE = "__stencil_injectSideEffectStyle";
 const RUNTIME_APIS = {
 	createEvent: `createEvent as ${CREATE_EVENT}`,
 	defineCustomElement: `defineCustomElement as ${DEFINE_CUSTOM_ELEMENT}`,
@@ -2421,7 +2423,7 @@ function addTagTransformToCssString(cssCode, tagNames) {
 			rule.selectors = rule.selectors.map((sel) => {
 				const parsedSelector = postcssSelectorParser().astSync(sel);
 				parsedSelector.walkTags((tag) => {
-					if (tagNames.includes(tag.value)) tag.value = "${__stencil_transformTag(\"" + tag.value + "\")}";
+					if (tagNames.includes(tag.value)) tag.value = "${" + TRANSFORM_TAG + "(\"" + tag.value + "\")}";
 				});
 				return parsedSelector.toString();
 			});
@@ -3354,9 +3356,9 @@ const runPluginTransformsEsmImports = async (config, compilerCtx, buildCtx, code
 	return transformResults;
 };
 //#endregion
-//#region src/compiler/style/optimize-css.ts
+//#region src/compiler/style/optimize-style-css.ts
 const getCssToolVersions = () => `autoprefixer@${getToolVersion("autoprefixer")}_postcss@${getToolVersion("postcss")}`;
-const optimizeCss$1 = async (config, compilerCtx, diagnostics, styleText, filePath) => {
+const optimizeStyleCss = async (config, compilerCtx, diagnostics, styleText, filePath) => {
 	if (typeof styleText !== "string" || !styleText.length) return styleText;
 	if ((config.autoprefixCss === false || config.autoprefixCss === null) && !config.minifyCss) return styleText;
 	if (typeof filePath === "string") filePath = normalizePath(filePath);
@@ -3441,7 +3443,7 @@ const collectAndBuildComponentGlobalStyles = async (config, compilerCtx, buildCt
 			if (!result) continue;
 			const cssCode = typeof result === "string" ? result : result.code;
 			if (!cssCode) continue;
-			const optimized = await optimizeCss$1(config, compilerCtx, buildCtx.diagnostics, cssCode, path);
+			const optimized = await optimizeStyleCss(config, compilerCtx, buildCtx.diagnostics, cssCode, path);
 			compilerCtx.globalStyleCache.set(path, optimized);
 			parts.push(optimized);
 		}
@@ -3523,7 +3525,7 @@ const buildGlobalStyleFromInput = async (config, compilerCtx, buildCtx, inputPat
 			}
 			if (hasStencilGlobalsImport(cssCode)) cssCode = await resolveStencilGlobalsImport(cssCode, config, compilerCtx, buildCtx, normalizedPath);
 			if (hasStencilHydrateImport(cssCode)) cssCode = resolveStencilHydrateImport(cssCode, config, buildCtx);
-			const optimizedCss = await optimizeCss$1(config, compilerCtx, buildCtx.diagnostics, cssCode, normalizedPath);
+			const optimizedCss = await optimizeStyleCss(config, compilerCtx, buildCtx.diagnostics, cssCode, normalizedPath);
 			compilerCtx.globalStyleCache.set(normalizedPath, optimizedCss);
 			if (Array.isArray(dependencies)) {
 				const cssModuleImports = compilerCtx.cssModuleImports.get(normalizedPath) || [];
@@ -3795,9 +3797,22 @@ const appendGlobalStyles = async (config, compilerCtx, buildCtx, s, platform) =>
 * @param s a `MagicString` to append the generated constant onto
 */
 const appendBuildConditionals = (config, buildConditionals, s) => {
-	const buildData = Object.keys(buildConditionals).sort().map((key) => key + ": " + JSON.stringify(buildConditionals[key])).join(", ");
+	const buildData = getSortedBuildConditionalEntries(buildConditionals).map(([key, value]) => key + ": " + JSON.stringify(value)).join(", ");
 	s.append(`export const BUILD = /* ${config.fsNamespace} */ { ${buildData} };\n`);
 };
+/**
+* Builds a `<flag> -> literal-value-as-source-text` map for every build conditional, for use by
+* {@link buildConditionalsPlugin} to replace `BUILD.<flag>` reads with their literal values.
+*
+* @param buildConditionals the build conditionals for this build
+* @returns a flag name > literal source text map
+*/
+const getBuildConditionalsLiterals = (buildConditionals) => {
+	const literals = /* @__PURE__ */ new Map();
+	for (const [key, value] of getSortedBuildConditionalEntries(buildConditionals)) literals.set(key, JSON.stringify(value));
+	return literals;
+};
+const getSortedBuildConditionalEntries = (buildConditionals) => Object.keys(buildConditionals).sort().map((key) => [key, buildConditionals[key]]);
 const appendEnv = (config, s) => {
 	s.append(`export const Env = /* ${config.fsNamespace} */ ${JSON.stringify(config.env)};\n`);
 };
@@ -3912,7 +3927,6 @@ const coreResolvePlugin = (config, compilerCtx, platform, externalRuntime, lazyL
 	const hydratedFlag = config.hydratedFlag;
 	const hydratedFlagHead = hydratedFlag ? getHydratedFlagHead(hydratedFlag) : null;
 	const hydratedReplacements = hydratedFlag && hydratedFlagHead !== "{visibility:hidden}.hydrated{visibility:inherit}" ? buildHydratedReplacements(hydratedFlag, hydratedFlagHead) : null;
-	const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 	return {
 		name: "coreResolvePlugin",
 		resolveId: {
@@ -3952,7 +3966,7 @@ const coreResolvePlugin = (config, compilerCtx, platform, externalRuntime, lazyL
 			}
 		},
 		load: {
-			filter: { id: new RegExp(`^(${escapeRegex(internalClient)}|${escapeRegex(internalSsr)})(\\?.*)?$`) },
+			filter: { id: getStencilInternalModuleFilter(internalClient, internalSsr) },
 			async handler(filePath) {
 				if (filePath && !filePath.startsWith("\0")) {
 					filePath = normalizeFsPath(filePath);
@@ -3984,6 +3998,19 @@ export const Build = {
 		}
 	};
 };
+/**
+* Builds a filter regex matching only Stencil's own resolved internal runtime module(s),
+* tolerant of query-string suffixes (e.g. `?app-data=conditional` for lazy builds). Shared by
+* any plugin that needs to scope its work to Stencil's own runtime code, rather than the rest
+* of a downstream app's bundle.
+*
+* @param moduleIds absolute paths to Stencil's resolved internal runtime module(s)
+* @returns a regex suitable for a rolldown hook's `id` filter
+*/
+const getStencilInternalModuleFilter = (...moduleIds) => {
+	const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(`^(${moduleIds.map(escapeRegex).join("|")})(\\?.*)?$`);
+};
 const getStencilInternalModule = (config, compilerExe, internalModule) => {
 	if (isRemoteUrl(compilerExe)) return normalizePath(config.sys.getLocalModulePath({
 		rootDir: config.rootDir,
@@ -4016,6 +4043,53 @@ const buildHydratedReplacements = (hydratedFlag, hydratedFlagHead) => {
 	return replacements;
 };
 //#endregion
+//#region src/compiler/bundle/build-conditionals-plugin.ts
+const BUILD_FLAG_RE = /\bBUILD(?:\$\d+)?\.([A-Za-z_$][\w$]*)\b/g;
+/**
+* Scoped by `id` to Stencil's own resolved internal runtime module(s) only
+* and only when the `jsMinifier` = `oxc`.
+*
+* Replaces `BUILD.<flag>` reads with their literal values, so a minifier's basic literal-boolean
+* folding (e.g. `false && x` -> nothing) can eliminate the resulting dead branches.
+* Oxc cannot dead-code-eliminate using `BUILD.<flag>` reads directly.
+*
+* @param config the Stencil configuration for the project
+* @param buildConditionals the build conditionals for this build
+* @returns a rolldown plugin, or null if this build doesn't need it
+*/
+const buildConditionalsPlugin = (config, buildConditionals) => {
+	if (config.jsMinifier !== "oxc" || !buildConditionals) return null;
+	const literals = getBuildConditionalsLiterals(buildConditionals);
+	if (literals.size === 0) return null;
+	const compilerExe = config.sys.getCompilerExecutingPath();
+	const internalClient = getStencilInternalModule(config, compilerExe, "client/runtime.js");
+	const internalSsr = getStencilInternalModule(config, compilerExe, "server/index.mjs");
+	return {
+		name: "stencil-build-conditionals",
+		transform: {
+			filter: {
+				id: getStencilInternalModuleFilter(internalClient, internalSsr),
+				code: /\bBUILD(?:\$\d+)?\.\w/
+			},
+			handler(code) {
+				const s = new MagicString(code);
+				let didReplace = false;
+				for (const match of code.matchAll(BUILD_FLAG_RE)) {
+					const literal = literals.get(match[1]);
+					if (literal === void 0) continue;
+					s.overwrite(match.index, match.index + match[0].length, literal);
+					didReplace = true;
+				}
+				if (!didReplace) return null;
+				return {
+					code: s.toString(),
+					map: s.generateMap({ hires: true })
+				};
+			}
+		}
+	};
+};
+//#endregion
 //#region src/compiler/bundle/constants.ts
 const DEV_MODULE_DIR = `~dev-module`;
 //#endregion
@@ -4250,9 +4324,10 @@ const extTransformsPlugin = (config, compilerCtx, buildCtx) => {
 					if (typeof code !== "string") compilerCtx.cssTransformCache.set(id, null);
 					else {
 						const pluginTransforms = await runPluginTransformsEsmImports(config, compilerCtx, buildCtx, code, filePath);
+						const cssInput = data.tag ? pluginTransforms.code : inlineRelativeCssUrlAssets(pluginTransforms.code, filePath);
 						const cssTransformResults = await compilerCtx.worker.transformCssToEsm({
 							file: pluginTransforms.id,
-							input: pluginTransforms.code,
+							input: cssInput,
 							tag: data.tag,
 							tags: buildCtx.components.map((c) => c.tagName),
 							addTagTransformers: !!buildCtx.config.compat.additionalTagTransformers,
@@ -4340,13 +4415,46 @@ const extTransformsPlugin = (config, compilerCtx, buildCtx) => {
 				return {
 					code: cacheEntry.cssTransformOutput.output,
 					map: cacheEntry.cssTransformOutput.map,
-					moduleSideEffects: false
+					moduleSideEffects: cacheEntry.cssTransformOutput.moduleSideEffects ?? false
 				};
 			}
 			return null;
 		}
 	};
 };
+/**
+* 3rd-party stylesheets with relative `url(./font.ttf)` (font-face `src`, a background-image, ...)
+* have nowhere to resolve that path once this CSS is self-injected as a CSSStyleSheet:
+* there's no bundler output location for it to be relative *to*.
+* Inlining the referenced file as a `data:` URI sidesteps needing one - no separate asset
+* to serve, works the same regardless of how/where the final bundle is deployed.
+*/
+const CSS_URL_RE = /url\(\s*(['"]?)([^'"()]+)\1\s*\)/g;
+const CSS_URL_ASSET_MIME_TYPES = {
+	ttf: "font/ttf",
+	otf: "font/otf",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	eot: "application/vnd.ms-fontobject",
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	svg: "image/svg+xml"
+};
+const inlineRelativeCssUrlAssets = (cssText, cssFilePath) => cssText.replace(CSS_URL_RE, (original, _quote, url) => {
+	if (/^(data:|[a-z][a-z0-9+.-]*:|\/\/|\/)/i.test(url)) return original;
+	const cleanUrl = url.split(/[?#]/)[0];
+	const ext = cleanUrl.split(".").pop()?.toLowerCase();
+	const mimeType = ext && CSS_URL_ASSET_MIME_TYPES[ext];
+	if (!mimeType) return original;
+	try {
+		const assetPath = resolve(dirname(cssFilePath), cleanUrl);
+		return `url("data:${mimeType};base64,${readFileSync(assetPath).toString("base64")}")`;
+	} catch {
+		return original;
+	}
+});
 //#endregion
 //#region src/compiler/bundle/file-load-plugin.ts
 const RESOLVE_EXTENSIONS = [
@@ -4482,11 +4590,13 @@ const pluginHelper = (config, builtCtx, platform) => {
 			handler(importee, importer) {
 				if (importee.endsWith("/")) importee = importee.slice(0, -1);
 				if (builtIns.has(importee)) {
+					const alias = config.nodeResolve?.alias;
+					if (alias?.[importee] ?? alias?.[`${importee}$`]) return null;
 					let fromMsg = "";
 					if (importer) fromMsg = ` from ${relative$1(config.rootDir, importer)}`;
 					const diagnostic = buildError(builtCtx.diagnostics);
 					diagnostic.header = `Node Polyfills Required`;
-					diagnostic.messageText = `For the import "${importee}" to be bundled${fromMsg}, ensure the "rolldown-plugin-node-polyfills" plugin is installed and added to the stencil config plugins (${platform}). Please see the bundling docs for more information.
+					diagnostic.messageText = `For the import "${importee}" to be bundled${fromMsg}, ensure the "@rolldown/plugin-node-polyfills" plugin is installed and added to the stencil config plugins (${platform}). Please see the bundling docs for more information.
         Further information: https://stenciljs.com/docs/module-bundling`;
 				}
 				return null;
@@ -4713,7 +4823,59 @@ const userIndexPlugin = (config, compilerCtx) => {
 	};
 };
 //#endregion
-//#region src/compiler/optimize/minify-js.ts
+//#region src/compiler/optimize/minify-js-oxc.ts
+/**
+* Performs the minification of JavaScript source using oxc
+* @param input the JavaScript source to minify
+* @param opts the options used by the minifier
+* @returns the resulting minified JavaScript
+*/
+const minifyJsOxc = async (input, opts) => {
+	const results = {
+		output: input,
+		sourceMap: null,
+		diagnostics: []
+	};
+	try {
+		const minifyResult = minifySync("module.js", input, opts);
+		if (minifyResult.errors.length > 0) {
+			loadMinifyJsOxcDiagnostics(results.diagnostics, minifyResult.errors);
+			return results;
+		}
+		results.output = minifyResult.code;
+		results.sourceMap = minifyResult.map ? {
+			file: minifyResult.map.file ?? "module.js",
+			mappings: minifyResult.map.mappings,
+			names: minifyResult.map.names,
+			sourceRoot: minifyResult.map.sourceRoot,
+			sources: minifyResult.map.sources,
+			sourcesContent: minifyResult.map.sourcesContent,
+			version: minifyResult.map.version
+		} : null;
+	} catch (e) {
+		if (e instanceof Error) console.log(e.stack);
+		loadMinifyJsOxcDiagnostics(results.diagnostics, [{
+			message: String(e),
+			codeframe: null
+		}]);
+	}
+	return results;
+};
+const loadMinifyJsOxcDiagnostics = (diagnostics, errors) => {
+	for (const error of errors) diagnostics.push({
+		level: "error",
+		type: "build",
+		language: "javascript",
+		header: "Minify JS (oxc)",
+		code: "",
+		messageText: error.codeframe ?? error.message,
+		absFilePath: void 0,
+		relFilePath: void 0,
+		lines: []
+	});
+};
+//#endregion
+//#region src/compiler/optimize/minify-js-terser.ts
 /**
 * Performs the minification of JavaScript source
 * @param input the JavaScript source to minify
@@ -4732,14 +4894,6 @@ const minifyJs = async (input, opts) => {
 			const mangleProperties = mangle.properties;
 			if (mangleProperties && mangleProperties.regex) mangleProperties.regex = new RegExp(mangleProperties.regex);
 		}
-		if (opts.sourceMap)
- /**
-		* sourceMap, when used in conjunction with compress, can lead to sourcemaps that don't in every browser. despite
-		* there being a sourcemap spec, each browser has it's own tricks for trying to get sourcemaps to properly map
-		* minified JS back to its original form. for the most consistent results across all browsers, explicitly disable
-		* compress.
-		*/
-		opts.compress = void 0;
 	}
 	try {
 		const minifyResults = await minify(input, opts);
@@ -4845,7 +4999,8 @@ const optimizeModule = async (config, compilerCtx, opts) => {
 		sourceMap: opts.sourceMap
 	};
 	const isDebug = config.logLevel === "debug";
-	const cacheKey = await compilerCtx.cache.createKey("optimizeModule", getToolVersion("terser"), opts, isDebug);
+	const jsMinifier = config.jsMinifier;
+	const cacheKey = await compilerCtx.cache.createKey("optimizeModule", jsMinifier, getToolVersion(jsMinifier === "oxc" ? "rolldown" : "terser"), opts, isDebug);
 	const cachedContent = await compilerCtx.cache.get(cacheKey);
 	if (cachedContent != null) {
 		const cachedMap = await compilerCtx.cache.get(cacheKey + "Map");
@@ -4855,8 +5010,26 @@ const optimizeModule = async (config, compilerCtx, opts) => {
 			sourceMap: cachedMap ? JSON.parse(cachedMap) : null
 		};
 	}
-	const minifyOpts = getTerserOptions(config, opts.sourceTarget, isDebug);
 	const code = opts.input;
+	const results = jsMinifier === "oxc" ? await minifyJsOxc(code, getOxcMinifyOptions(config, opts, isDebug)) : await compilerCtx.worker.prepareModule(code, getTerserMinifyOptions(config, opts, isDebug));
+	if (results != null && typeof results.output === "string" && results.diagnostics.length === 0 && compilerCtx != null) {
+		if (opts.isCore) results.output = results.output.replace(/disconnectedCallback\(\)\{\},/g, "");
+		await compilerCtx.cache.put(cacheKey, results.output);
+		if (results.sourceMap) await compilerCtx.cache.put(cacheKey + "Map", JSON.stringify(results.sourceMap));
+	}
+	return results;
+};
+/**
+* Builds the terser options for a specific module being optimized, layering the module's
+* `isCore`/source map needs on top of the baseline options from {@link getTerserOptions}.
+*
+* @param config the Stencil configuration file that was provided as a part of the build step
+* @param opts the options for the module being optimized
+* @param isDebug if true, set the necessary flags to produce readable, debuggable output
+* @returns the minification options to hand to terser
+*/
+const getTerserMinifyOptions = (config, opts, isDebug) => {
+	const minifyOpts = getTerserOptions(config, opts.sourceTarget, isDebug);
 	if (config.sourceMap) minifyOpts.sourceMap = { content: opts.sourceMap != null ? {
 		...opts.sourceMap,
 		version: 3
@@ -4878,13 +5051,7 @@ const optimizeModule = async (config, compilerCtx, opts) => {
 		compressOpts.unsafe = true;
 		compressOpts.unsafe_undefined = true;
 	}
-	const results = await compilerCtx.worker.prepareModule(code, minifyOpts);
-	if (results != null && typeof results.output === "string" && results.diagnostics.length === 0 && compilerCtx != null) {
-		if (opts.isCore) results.output = results.output.replace(/disconnectedCallback\(\)\{\},/g, "");
-		await compilerCtx.cache.put(cacheKey, results.output);
-		if (results.sourceMap) await compilerCtx.cache.put(cacheKey + "Map", JSON.stringify(results.sourceMap));
-	}
-	return results;
+	return minifyOpts;
 };
 /**
 * Builds a configuration object to be used by Terser for the purposes of minifying a user's JavaScript
@@ -4941,6 +5108,81 @@ function getTerserManglePropertiesConfig() {
 	};
 }
 /**
+* Builds the oxc (rolldown minifier) options for a specific module being optimized.
+*
+* A few terser knobs have no oxc equivalent and so are dropped:
+* - `global_defs` (used to fold `supportsListenerOptions` to `true` in the core runtime bundle)
+* - `unsafe`/`unsafe_undefined`/`inline` compress passes
+* - `passes` (oxc's compressor iterates to a fix point automatically)
+*
+* @param config the Stencil configuration file that was provided as a part of the build step
+* @param opts the options for the module being optimized
+* @param isDebug if true, set the necessary flags to produce readable, debuggable output
+* @returns the minification options to hand to oxc
+*/
+const getOxcMinifyOptions = (config, opts, isDebug) => {
+	const minifyOpts = {
+		module: true,
+		sourcemap: !!config.sourceMap,
+		inputMap: config.sourceMap ? opts.sourceMap ?? void 0 : void 0,
+		mangleProps: getOxcManglePropertiesConfig(isDebug)
+	};
+	if (isDebug) {
+		minifyOpts.mangle = false;
+		minifyOpts.compress = {
+			dropConsole: false,
+			dropDebugger: false
+		};
+		minifyOpts.codegen = {
+			removeWhitespace: false,
+			legalComments: "inline"
+		};
+	} else {
+		minifyOpts.mangle = { toplevel: true };
+		minifyOpts.compress = { treeshake: {
+			propertyReadSideEffects: false,
+			manualPureFunctions: opts.isCore ? ["getHostRef"] : []
+		} };
+	}
+	return minifyOpts;
+};
+/**
+* `ComponentRuntimeMeta` (the shape of a component class's static `cmpMeta` getter) is
+* produced by one compiled unit and read by another (e.g. a component's own chunk vs the
+* SSR/hydrate runtime, or a lazy component's entry chunk vs the core runtime chunk).
+*
+* Oxc's mangleProps` has been observed to mangle a property at its read site but leave the same
+* property's key unmangled silently breaking that read (e.g. `cmpMeta.$tagName$` reads as `undefined`).
+* Reserving these names avoids the mismatch entirely.
+*
+* Assess in time with rolldown / oxc updates via `cd test/build/output && pnpm test`
+*/
+const RESERVED_CMP_META_PROPS = [
+	"$flags$",
+	"$tagName$",
+	"$members$",
+	"$listeners$",
+	"$attrsToReflect$",
+	"$watchers$",
+	"$lazyBundleId$",
+	"$serializers$",
+	"$deserializers$"
+];
+/**
+* Get baseline configuration for oxc's `mangleProps` option, mirroring
+* {@link getTerserManglePropertiesConfig}.
+*
+* @param isDebug if true, produce readable `_$name$_`-style output names instead of minified ones
+* @returns an object with our baseline property mangling configuration
+*/
+function getOxcManglePropertiesConfig(isDebug) {
+	return {
+		include: /^\$.+\$$/,
+		reserved: ["$hostElement$", ...RESERVED_CMP_META_PROPS],
+		debug: isDebug
+	};
+}
+/**
 * This method is likely to be called by a worker on the compiler context, rather than directly.
 * @param input the source code to minify
 * @param minifyOpts options to be used by the minifier
@@ -5089,7 +5331,7 @@ const buildWorker = async (config, compilerCtx, buildCtx, ctx, workerEntryPath)
 		let code = entryPoint.code;
 		const results = await optimizeModule(config, compilerCtx, {
 			input: code,
-			sourceTarget: "es2017",
+			sourceTarget: "es2022",
 			isCore: false,
 			minify: config.minifyJs,
 			inlineHelpers: true
@@ -5393,6 +5635,7 @@ const getRolldownOptions = (config, compilerCtx, buildCtx, bundleOpts) => {
 			},
 			coreResolvePlugin(config, compilerCtx, bundleOpts.platform, !!bundleOpts.externalRuntime, bundleOpts.conditionals?.lazyLoad ?? false),
 			appDataPlugin(config, compilerCtx, buildCtx, bundleOpts.conditionals, bundleOpts.platform),
+			buildConditionalsPlugin(config, bundleOpts.conditionals),
 			lazyComponentPlugin(buildCtx),
 			loaderPlugin(bundleOpts.loader),
 			userIndexPlugin(config, compilerCtx),
@@ -6569,10 +6812,6 @@ const addStaticImports = (rolldownChunkResults, bundleModules) => {
 		const generateCjs = isCjsFormat(index) ? generateCaseClauseCjs : generateCaseClause;
 		index.code = index.code.replace("/*!__STENCIL_STATIC_IMPORT_SWITCH__*/", `
         if (!hmrVersionId || !BUILD.hotModuleReplacement) {
-          const processMod = importedModule => {
-              cmpModules.set(bundleId, importedModule);
-              return importedModule[exportName];
-          }
           switch(bundleId) {
               ${bundleModules.map((mod) => generateCjs(mod.output.bundleId)).join("")}
           }
@@ -6606,7 +6845,7 @@ const generateCaseClause = (bundleId) => {
                 case '${bundleId}':
                     return import(
                       /* webpackMode: "lazy" */
-                      './${bundleId}.entry.js').then(processMod, consoleError);`;
+                      './${bundleId}.entry.js').then(onLoad, onError);`;
 };
 /**
 * Generate a 'case' clause to be used within a `switch` statement. The case clause generated will key-off the provided
@@ -6619,7 +6858,7 @@ const generateCaseClauseCjs = (bundleId) => {
                 case '${bundleId}':
                     return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
                         /* webpackMode: "lazy" */
-                        './${bundleId}.entry.js')); }).then(processMod, consoleError);`;
+                        './${bundleId}.entry.js')); }).then(onLoad, onError);`;
 };
 const generateLazyEntryModule = async (config, compilerCtx, buildCtx, rolldownResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild) => {
 	const entryModule = buildCtx.entryModules.find((em) => em.entryKey === rolldownResult.entryKey);
@@ -6847,7 +7086,7 @@ const generateCjs = async (config, compilerCtx, buildCtx, rolldownBuild, outputT
 		const results = await generateRolldownOutput(rolldownBuild, esmOpts, config, buildCtx.entryModules);
 		if (results != null) {
 			const destinations = cjsOutputs.map((o) => o.cjsDir).filter((cjsDir) => typeof cjsDir === "string");
-			buildCtx.commonJsComponentBundle = await generateLazyModules(config, compilerCtx, buildCtx, outputTargetType, destinations, results, "es2017", false);
+			buildCtx.commonJsComponentBundle = await generateLazyModules(config, compilerCtx, buildCtx, outputTargetType, destinations, results, "es2022", false);
 			await generateShortcuts$1(compilerCtx, results, cjsOutputs);
 		}
 	}
@@ -7133,7 +7372,13 @@ function createEntryModule(cmps) {
 }
 const getLazyEntry = (isBrowser, assetPath, externalRuntime = false) => {
 	const s = new MagicString(``);
-	s.append(`export { setNonce, setRegistry, setTagTransformer } from '${STENCIL_CORE_ID}';\n`);
+	const platformExports = [
+		"setNonce",
+		"setRegistry",
+		"setTagTransformer"
+	];
+	if (assetPath) platformExports.push("setAssetPath");
+	s.append(`export { ${platformExports.join(", ")} } from '${STENCIL_CORE_ID}';\n`);
 	s.append(`import { bootstrapLazy } from '${STENCIL_CORE_ID}';\n`);
 	if (isBrowser) {
 		if (assetPath) s.append(`import { setAssetPath } from '${STENCIL_CORE_ID}';\n`);
@@ -9148,15 +9393,17 @@ const generateStandaloneTypesOutput = async (config, compilerCtx, buildCtx, type
 	if (outputTarget.autoLoader) {
 		const loaderFileName = typeof outputTarget.autoLoader === "object" ? outputTarget.autoLoader.fileName || "loader" : "loader";
 		const loaderDtsPath = join$2(outputTarget.dir, `${loaderFileName}.d.ts`);
-		const loaderDtsCode = generateLoaderType();
+		const hasAssets = buildCtx.components.some((cmp) => cmp.assetsDirs != null && cmp.assetsDirs.length > 0);
+		const loaderDtsCode = generateLoaderType(hasAssets);
 		await compilerCtx.fs.writeFile(loaderDtsPath, loaderDtsCode, { outputTargetType: outputTarget.type });
 	}
 };
 /**
 * Generate a type declaration file for the auto-loader module
+* @param hasAssets whether any component declares assets, matching whether setAssetPath is actually exported
 * @returns the contents of the type declaration file for the loader
 */
-const generateLoaderType = () => {
+const generateLoaderType = (hasAssets) => {
 	return [
 		`/**`,
 		` * Start the auto-loader, scanning the DOM and watching for changes.`,
@@ -9170,7 +9417,18 @@ const generateLoaderType = () => {
 		` * Stop the auto-loader and disconnect the MutationObserver.`,
 		` */`,
 		`export declare function stop(): void;`,
-		``
+		``,
+		...hasAssets ? [
+			`/**`,
+			` * Used to manually set the base path where component assets can be found. The`,
+			` * default is relative to this module's own location, which may not hold once a`,
+			` * consuming bundler relocates it - call this before start() to override.`,
+			` * @param path the asset path to set`,
+			` * @returns the set path`,
+			` */`,
+			`export declare function setAssetPath(path: string): string;`,
+			``
+		] : []
 	].join("\n");
 };
 /**
@@ -9660,7 +9918,7 @@ const FORM_ASSOCIATED_ATTRIBUTES = [
 * @param cmp the metadata for the component that a type definition string is generated for
 * @param typeImportData locally/imported/globally used type names, which may be used to prevent naming collisions
 * @param areTypesInternal `true` if types being generated are for a project's internal purposes, `false` otherwise
-* @param signalBacking `true` if the component is using signal backing for its props; includes the signals map on the element interface
+* @param signalBacking `true` if the component is using signal backing for its props; includes the signals map on the element interface and unions JSX prop types with `ReadonlySignal<T>`
 * @returns the generated types string alongside additional metadata
 */
 const generateComponentTypes = (cmp, typeImportData, areTypesInternal, signalBacking = false) => {
@@ -9677,8 +9935,12 @@ const generateComponentTypes = (cmp, typeImportData, areTypesInternal, signalBac
 	const isDep = cmp.isCollectionDependency;
 	const propNames = new Set(propAttributes.map((p) => p.name));
 	const formAssociatedAttrs = cmp.formAssociated ? FORM_ASSOCIATED_ATTRIBUTES.filter((attr) => !propNames.has(attr.name)) : [];
+	const jsxPropAttributes = signalBacking ? propAttributes.map((attr) => ({
+		...attr,
+		type: `${attr.type} | ReadonlySignal<${attr.type}>`
+	})) : propAttributes;
 	const jsxAttributes = attributesToMultiLineString([
-		...propAttributes,
+		...jsxPropAttributes,
 		...eventAttributes,
 		...formAssociatedAttrs
 	], true, areTypesInternal);
@@ -10115,8 +10377,9 @@ const generateTypesOutput = async (config, compilerCtx, buildCtx, outputTarget)
 	await generateAppTypes(config, compilerCtx, buildCtx, distPath);
 	const typesDir = outputTarget.dir;
 	if (distDtsFilePath) await generateStandaloneTypes(config, compilerCtx, buildCtx, typesDir);
-	if (config.outputTargets.some(isOutputTargetLoaderBundle)) await generateLoaderTypes(compilerCtx, typesDir);
-	if (config.outputTargets.some(isOutputTargetStandalone)) await generateStandaloneApiTypes(compilerCtx, typesDir);
+	const hasAssets = buildCtx.components.some((cmp) => cmp.assetsDirs != null && cmp.assetsDirs.length > 0);
+	if (config.outputTargets.some(isOutputTargetLoaderBundle)) await generateLoaderTypes(compilerCtx, typesDir, hasAssets);
+	if (config.outputTargets.some(isOutputTargetStandalone)) await generateStandaloneApiTypes(compilerCtx, typesDir, hasAssets);
 };
 /**
 * Generate loader.d.ts file for the loader entry point.
@@ -10124,8 +10387,9 @@ const generateTypesOutput = async (config, compilerCtx, buildCtx, outputTarget)
 *
 * @param compilerCtx the current compiler context
 * @param typesDir the directory to write the loader.d.ts file to
+* @param hasAssets whether any component declares assets, matching whether setAssetPath is actually exported
 */
-const generateLoaderTypes = async (compilerCtx, typesDir) => {
+const generateLoaderTypes = async (compilerCtx, typesDir, hasAssets) => {
 	const loaderDtsContent = `export * from './components';
 export interface CustomElementsDefineOptions {
   exclude?: string[];
@@ -10161,7 +10425,17 @@ export type TagTransformer = (tag: string) => string;
  * Useful for namespacing (e.g. \`my-button\` → \`acme-button\`) in multi-library pages.
  */
 export declare function setTagTransformer(transformer: TagTransformer): void;
-`;
+${hasAssets ? `
+/**
+ * Used to manually set the base path where component assets can be found. The
+ * default is relative to this module's own location, which may not hold once a
+ * bundler relocates it, or once its CDN URL diverges from the assets' own -
+ * import and call this before the module's default has been used to override it.
+ * @param path the asset path to set
+ * @returns the set path
+ */
+export declare function setAssetPath(path: string): string;
+` : ""}`;
 	const loaderDtsPath = join$2(typesDir, "loader.d.ts");
 	await compilerCtx.fs.writeFile(loaderDtsPath, loaderDtsContent);
 };
@@ -10171,8 +10445,9 @@ export declare function setTagTransformer(transformer: TagTransformer): void;
 *
 * @param compilerCtx the current compiler context
 * @param typesDir the directory to write the standalone.d.ts file to
+* @param hasAssets whether any component declares assets, matching whether setAssetPath is actually exported
 */
-const generateStandaloneApiTypes = async (compilerCtx, typesDir) => {
+const generateStandaloneApiTypes = async (compilerCtx, typesDir, hasAssets) => {
 	const standaloneDtsContent = `/**
  * Used to specify a nonce value that corresponds with an application's CSP.
  * When set, the nonce will be added to all dynamically created script and style tags at runtime.
@@ -10205,7 +10480,16 @@ export interface SetPlatformOptions {
   rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
 }
 export declare const setPlatformOptions: (opts: SetPlatformOptions) => void;
-`;
+${hasAssets ? `
+/**
+ * Used to manually set the base path where component assets can be found. The
+ * default is relative to this module's own location, which may not hold once a
+ * consuming bundler relocates it - call this before any component module is imported to override.
+ * @param path the asset path to set
+ * @returns the set path
+ */
+export declare const setAssetPath: (path: string) => string;
+` : ""}`;
 	const standaloneDtsPath = join$2(typesDir, "standalone.d.ts");
 	await compilerCtx.fs.writeFile(standaloneDtsPath, standaloneDtsContent);
 };
@@ -12166,7 +12450,7 @@ const generateLoaderModule = (components, outputTarget, relativeAssetPath) => {
 	const autoStart = typeof autoLoaderConfig === "object" ? autoLoaderConfig.autoStart !== false : true;
 	const tagsList = components.map((cmp) => `'${cmp.tagName}'`).join(", ");
 	const switchCases = components.map((cmp) => `      case '${cmp.tagName}': module = await import('./${cmp.tagName}.js'); break;`).join("\n");
-	const assetPathImport = relativeAssetPath ? `import { setAssetPath } from '${STENCIL_INTERNAL_STANDALONE_CLIENT_PLATFORM_ID}';\n` : "";
+	const assetPathImport = relativeAssetPath ? `import { setAssetPath } from '${STENCIL_INTERNAL_STANDALONE_CLIENT_PLATFORM_ID}';\nexport { setAssetPath };\n` : "";
 	const assetPathInit = relativeAssetPath ? `setAssetPath(new URL('${relativeAssetPath}', String(import.meta.url)).href);\n` : "";
 	return `
 import { transformTag, getRegistry } from '${STENCIL_INTERNAL_STANDALONE_CLIENT_PLATFORM_ID}';
@@ -12527,12 +12811,25 @@ const addStandaloneInputs = (config, buildCtx, bundleOpts, outputTarget) => {
 	const indexImports = [];
 	const indexExports = [];
 	const exportNames = [];
+	let relativeAssetPath;
+	if (components.some((cmp) => cmp.assetsDirs != null && cmp.assetsDirs.length > 0)) {
+		const assetsTarget = config.outputTargets.find(isOutputTargetAssets);
+		if (assetsTarget?.dir && outputTarget.dir) {
+			const rel = relative$1(outputTarget.dir, assetsTarget.dir);
+			relativeAssetPath = rel.endsWith("/") ? rel : rel + "/";
+		}
+	}
 	components.forEach((cmp) => {
 		const exp = [];
 		const exportName = dashToPascalCase(cmp.tagName);
 		const importName = cmp.componentClassName;
 		const importAs = `$Cmp${exportName}`;
 		const coreKey = `\0${exportName}`;
+		if (relativeAssetPath) {
+			exp.push(`import { setAssetPath } from '${STENCIL_INTERNAL_STANDALONE_CLIENT_PLATFORM_ID}';`);
+			exp.push(`export { setAssetPath };`);
+			exp.push(`setAssetPath(new URL('${relativeAssetPath}', import.meta.url).href);`);
+		}
 		if (cmp.isPlain) {
 			exp.push(`export { ${importName} as ${exportName} } from '${cmp.sourceFilePath}';`);
 			indexExports.push(`export { ${exportName} } from '${coreKey}';`);
@@ -12547,14 +12844,6 @@ const addStandaloneInputs = (config, buildCtx, bundleOpts, outputTarget) => {
 		bundleOpts.inputs[cmp.tagName] = coreKey;
 		bundleOpts.loader[coreKey] = exp.join("\n");
 	});
-	let relativeAssetPath;
-	if (components.some((cmp) => cmp.assetsDirs != null && cmp.assetsDirs.length > 0)) {
-		const assetsTarget = config.outputTargets.find(isOutputTargetAssets);
-		if (assetsTarget?.dir && outputTarget.dir) {
-			const rel = relative$1(outputTarget.dir, assetsTarget.dir);
-			relativeAssetPath = rel.endsWith("/") ? rel : rel + "/";
-		}
-	}
 	bundleOpts.loader["\0core"] = generateEntryPoint(outputTarget, indexImports, indexExports, exportNames, relativeAssetPath);
 	if (outputTarget.autoLoader) {
 		const loaderFileName = typeof outputTarget.autoLoader === "object" ? outputTarget.autoLoader.fileName || "loader" : "loader";
@@ -12578,6 +12867,7 @@ const generateEntryPoint = (outputTarget, cmpImports = [], cmpExports = [], cmpN
 	exports.push(`export { setNonce, setRegistry, setTagTransformer, setPlatformOptions } from '${STENCIL_INTERNAL_STANDALONE_CLIENT_PLATFORM_ID}';`, `export * from '${USER_INDEX_ENTRY_ID}';`);
 	if (relativeAssetPath) {
 		imports.push(`import { setAssetPath } from '${STENCIL_INTERNAL_STANDALONE_CLIENT_PLATFORM_ID}';`);
+		exports.push(`export { setAssetPath };`);
 		body.push(`setAssetPath(new URL('${relativeAssetPath}', import.meta.url).href);`);
 	}
 	if (outputTarget.includeGlobalScripts !== false) {
@@ -12688,6 +12978,7 @@ const IS_CASE_SENSITIVE_FILE_NAMES = !(process.platform === "win32");
 //#endregion
 //#region src/compiler/sys/typescript/typescript-sys.ts
 const patchTsSystemFileSystem = (config, compilerSys, inMemoryFs, tsSys) => {
+	if (!tsSys) return;
 	const realpath = (path) => {
 		const rp = compilerSys.realpathSync(path);
 		if (isString$1(rp)) return rp;
@@ -12765,6 +13056,7 @@ const patchTsSystemFileSystem = (config, compilerSys, inMemoryFs, tsSys) => {
 	return tsSys;
 };
 const patchTsSystemWatch = (compilerSystem, tsSys) => {
+	if (!tsSys) return;
 	tsSys.watchDirectory = (p, cb, recursive) => {
 		const watcher = compilerSystem.watchDirectory(p, (filePath) => {
 			cb(filePath);
@@ -12788,26 +13080,6 @@ const patchTypescript = (config, inMemoryFs) => {
 	patchTsSystemFileSystem(config, config.sys, inMemoryFs, ts.sys);
 	patchTsSystemWatch(config.sys, ts.sys);
 };
-const patchTypeScriptSysMinimum = () => {
-	if (!ts.sys) ts.sys = {
-		args: [],
-		createDirectory: noop,
-		directoryExists: () => false,
-		exit: noop,
-		fileExists: () => false,
-		getCurrentDirectory: process.cwd,
-		getDirectories: () => [],
-		getExecutingFilePath: () => "./",
-		readDirectory: () => [],
-		readFile: noop,
-		newLine: "\n",
-		resolvePath: resolve$2,
-		useCaseSensitiveFileNames: false,
-		write: noop,
-		writeFile: noop
-	};
-};
-patchTypeScriptSysMinimum();
 const getTypescriptPathFromUrl = (config, tsExecutingUrl, url) => {
 	const tsBaseUrl = new URL("..", tsExecutingUrl).href;
 	if (url.startsWith(tsBaseUrl)) {
@@ -15003,14 +15275,16 @@ const parseWatchDecorator = (typeChecker, method, decoratorName) => {
 * @param diagnostics for surfacing errors and warnings
 * @param typeChecker a TypeScript typechecker instance
 * @param program a {@link ts.Program} object
+* @param includeClassExpressions also convert `ts.ClassExpression` nodes (e.g. a mixin factory's
+* `(Base) => class extends Base {}`), not just named `ts.ClassDeclaration`s
 * @returns a TypeScript transformer factory which can be passed to
 * TypeScript to transform source code during the compilation process
 */
-const convertDecoratorsToStatic = (config, diagnostics, typeChecker, program) => {
+const convertDecoratorsToStatic = (config, diagnostics, typeChecker, program, includeClassExpressions = false) => {
 	return (transformCtx) => {
 		let sourceFile;
 		const visit = (node) => {
-			if (ts.isClassDeclaration(node)) return visitClassDeclaration(config, diagnostics, typeChecker, program, node, sourceFile);
+			if (ts.isClassDeclaration(node) || includeClassExpressions && ts.isClassExpression(node)) return visitClassDeclaration(config, diagnostics, typeChecker, program, node, sourceFile);
 			return ts.visitEachChild(node, visit, transformCtx);
 		};
 		return (tsSourceFile) => {
@@ -15020,10 +15294,10 @@ const convertDecoratorsToStatic = (config, diagnostics, typeChecker, program) =>
 	};
 };
 /**
-* Visit {@link ts.ClassDeclaration} nodes as part of the tree-traversal
+* Visit {@link ts.ClassDeclaration}/{@link ts.ClassExpression} nodes as part of the tree-traversal
 * required for {@link convertDecoratorsToStatic} to work.
 *
-* If a given class declaration node is not decorated with `@Component` this
+* If a given class node is not decorated with `@Component` this
 * function will simply return it as-is. If it _is_ decorated, then it will
 *
 * 1. Convert the arguments to the `@Component` decorator to static values.
@@ -15032,7 +15306,7 @@ const convertDecoratorsToStatic = (config, diagnostics, typeChecker, program) =>
 * to static values.
 * 3. Validate that the various options selected by the component author are
 * valid, both individually and in combination.
-* 4. Return an updated class declaration node which is ready to be used in
+* 4. Return an updated class node which is ready to be used in
 * the rest of the Stencil compilation pipeline (e.g. in output target
 * generation).
 *
@@ -15051,7 +15325,7 @@ const visitClassDeclaration = (config, diagnostics, typeChecker, program, classN
 	const decoratedMembers = classMembers.filter((member) => (retrieveTsDecorators(member)?.length ?? 0) > 0);
 	if (!decoratedMembers.length && !componentDecorator) return classNode;
 	const filteredMethodsAndFields = removeStencilMethodDecorators(Array.from(classMembers), diagnostics, importAliasMap);
-	if (componentDecorator) componentDecoratorToStatic(config, typeChecker, diagnostics, classNode, filteredMethodsAndFields, componentDecorator);
+	if (componentDecorator && ts.isClassDeclaration(classNode)) componentDecoratorToStatic(config, typeChecker, diagnostics, classNode, filteredMethodsAndFields, componentDecorator);
 	if (decoratedMembers.length > 0) {
 		const serializers = serializeDecoratorsToStatic(typeChecker, decoratedMembers, filteredMethodsAndFields, importAliasMap.get("PropSerialize"), "PropSerialize", importAliasMap.get("Prop"));
 		const deserializers = serializeDecoratorsToStatic(typeChecker, decoratedMembers, filteredMethodsAndFields, importAliasMap.get("AttrDeserialize"), "AttrDeserialize", importAliasMap.get("Prop"));
@@ -15067,7 +15341,8 @@ const visitClassDeclaration = (config, diagnostics, typeChecker, program, classN
 	validateMethods(diagnostics, classMembers);
 	const currentDecorators = retrieveTsDecorators(classNode);
 	const updatedClassFields = updateConstructor(classNode, filteredMethodsAndFields, []);
-	return ts.factory.updateClassDeclaration(classNode, [...filterDecorators(currentDecorators, CLASS_DECORATORS_TO_REMOVE.map((decorator) => importAliasMap.get(decorator))) ?? [], ...retrieveTsModifiers(classNode) ?? []], classNode.name, classNode.typeParameters, classNode.heritageClauses, updatedClassFields);
+	const updatedModifiers = [...filterDecorators(currentDecorators, CLASS_DECORATORS_TO_REMOVE.map((decorator) => importAliasMap.get(decorator))) ?? [], ...retrieveTsModifiers(classNode) ?? []];
+	return ts.isClassDeclaration(classNode) ? ts.factory.updateClassDeclaration(classNode, updatedModifiers, classNode.name, classNode.typeParameters, classNode.heritageClauses, updatedClassFields) : ts.factory.updateClassExpression(classNode, updatedModifiers, classNode.name, classNode.typeParameters, classNode.heritageClauses, updatedClassFields);
 };
 /**
 * Take a list of `ClassElement` AST nodes and remove any decorators from
@@ -15251,23 +15526,44 @@ const parseStaticWatchers = (staticMembers) => {
 //#endregion
 //#region src/compiler/transformers/static-to-meta/class-extension/shared.ts
 /**
-* Walks the AST looking for a class declaration, optionally by name - descends
-* into a mixin factory's wrapping function (arrow function or `function`
-* declaration) body too, since a mixin factory's class is always nested one
-* level inside it (e.g. `const Foo = (Base) => class extends Base {}`).
+* Warns when an `extends`/`Mixin(...)` target resolved to *something* but no class literal
+* could be found inside it - e.g. a mixin factory that returns an existing class by reference
+* (`(Base) => SomeExistingClass`) rather than a class literal. Without this, the target is
+* silently dropped: any `@Prop`/`@State` etc. it declares just never appears on the extending
+* component, with no diagnostic explaining why.
+* @param buildCtx used to surface the warning - omit to warn silently (e.g. from tests)
+* @param targetName the identifier the target was reached through
+* @param anchor the node to attach the warning to
+*/
+function warnMixinFactoryClassNotFound(buildCtx, targetName, anchor) {
+	if (!buildCtx) return;
+	const err = buildWarn(buildCtx.diagnostics);
+	err.messageText = `Found "${targetName}", but couldn't find a class inside it. If it's meant to be a mixin factory, make sure it returns a class literal directly, e.g. \`(Base) => class extends Base {}\` or \`(Base) => { class ${targetName}Class extends Base {} return ${targetName}Class; }\` - returning an existing class by reference (\`(Base) => SomeExistingClass\`) isn't recognized, and any \`@Prop\`/\`@State\`/etc. it declares won't be applied.`;
+	if (!buildCtx.config._isTesting) augmentDiagnosticWithNode(err, anchor);
+}
+/**
+* Walks the AST looking for a class declaration or class expression, optionally by name -
+* descends into a mixin factory's wrapping function (arrow function or `function` declaration)
+* body too, since a mixin factory's class is always nested one level inside it. Recognizes all of:
+* `const Foo = (Base) => class extends Base {}` (concise arrow body), `const Foo = (Base) => {
+* return class extends Base {}; }` (block body, `return` of a class expression), and `const Foo =
+* (Base) => { class FooClass extends Base {} return FooClass; }` (block body, named declaration).
 * @param node the node to search from
-* @param name if given, only matches a class declaration with this name
-* @returns the found class declaration, or `undefined`
+* @param name if given, only matches a class with this name
+* @returns the found class, or `undefined`
 */
 function findClassWalk(node, name) {
 	if (!node) return void 0;
-	if (ts.isClassDeclaration(node)) {
+	if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
 		if (!name || node.name?.text === name) return node;
 	} else if (ts.isVariableDeclaration(node) && (!name || name === node.name?.text) && node.initializer && ts.isArrowFunction(node.initializer)) {
+		const body = node.initializer.body;
+		if (ts.isClassExpression(body)) return body;
 		let found;
-		ts.forEachChild(node.initializer.body, (child) => {
+		ts.forEachChild(body, (child) => {
 			if (found) return;
 			if (ts.isClassDeclaration(child)) found = child;
+			else if (ts.isReturnStatement(child) && child.expression && ts.isClassExpression(child.expression)) found = child.expression;
 		});
 		return found;
 	}
@@ -15280,6 +15576,22 @@ function findClassWalk(node, name) {
 	return found;
 }
 /**
+* The declared name of a mixin-factory statement (`function Foo() {}`, or `const Foo = ...`) -
+* survives the decorator-to-static-getter transform even when the factory's inner class doesn't
+* have a name of its own, so it can anchor a post-transform re-lookup via `findClassWalk`.
+* @param node the factory statement (or its variable declaration) to read a name from
+* @returns the declared name, or `undefined` if it can't be determined
+*/
+function factoryDeclaredName(node) {
+	if (!node) return void 0;
+	if (ts.isFunctionDeclaration(node)) return node.name?.text;
+	if (ts.isVariableDeclaration(node)) return ts.isIdentifier(node.name) ? node.name.text : void 0;
+	if (ts.isVariableStatement(node)) {
+		const decl = node.declarationList.declarations[0];
+		return decl && ts.isIdentifier(decl.name) ? decl.name.text : void 0;
+	}
+}
+/**
 * Matches a top-level class/function/variable declaration by name - the three
 * shapes a mixin or base-class export can take (a plain class, a mixin
 * factory function declaration, or a mixin factory assigned to a `const`).
@@ -15401,7 +15713,7 @@ function convertDiskSourceFileDecorators(sourceFile, config, target = ts.ScriptT
 	const program = ts.createProgram([sourceFile.fileName], compilerOptions, host);
 	const typeChecker = program.getTypeChecker();
 	const ownSourceFile = program.getSourceFile(sourceFile.fileName) ?? sourceFile;
-	const result = ts.transform(ownSourceFile, [convertDecoratorsToStatic(config, [], typeChecker, program)]);
+	const result = ts.transform(ownSourceFile, [convertDecoratorsToStatic(config, [], typeChecker, program, true)]);
 	const printed = ts.createPrinter({ removeComments: false }).printFile(result.transformed[0]);
 	return ts.createSourceFile(sourceFile.fileName, printed, target, true);
 }
@@ -15453,6 +15765,7 @@ function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration,
 	if (!foundClassDeclaration && matchedStatement) {
 		foundClassDeclaration = findClassWalk(matchedStatement);
 		keepLooking = false;
+		if (!foundClassDeclaration) warnMixinFactoryClassNotFound(buildCtx, className, classDeclaration);
 	}
 	if (foundClassDeclaration && !dependentClasses.some((dc) => dc.classNode === foundClassDeclaration)) {
 		dependentClasses.push({
@@ -15487,6 +15800,7 @@ function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeC
 	const targetScriptTarget = (ogModule?.staticSourceFile)?.languageVersion ?? ts.ScriptTarget.ESNext;
 	let classIdentifiers = [];
 	let foundClassDeclaration;
+	let foundClassName;
 	let keepLooking = true;
 	extendsClause.types.forEach((type) => {
 		if (ts.isExpressionWithTypeArguments(type) && ts.isCallExpression(type.expression) && type.expression.expression.getText() === "Mixin") classIdentifiers = type.expression.arguments.filter(ts.isIdentifier);
@@ -15503,17 +15817,20 @@ function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeC
 				declarations = [...source.statements];
 			}
 			foundClassDeclaration = declarations?.find(ts.isClassDeclaration);
+			foundClassName = foundClassDeclaration?.name?.getText();
 			if (!foundClassDeclaration) {
 				const node = declarations?.[0];
 				foundClassDeclaration = findClassWalk(node);
+				foundClassName = foundClassDeclaration?.name?.getText() ?? factoryDeclaredName(node);
 				if (!node) throw "revert to sad path";
 				keepLooking = false;
+				if (!foundClassDeclaration) warnMixinFactoryClassNotFound(buildCtx, extendee.getText(), classDeclaration);
 			}
 			if (foundClassDeclaration && !dependentClasses.some((dc) => dc.classNode === foundClassDeclaration)) {
 				const foundModule = compilerCtx.moduleMap.get(foundClassDeclaration.getSourceFile().fileName);
 				if (foundModule) {
 					const moduleSourceFile = foundModule.staticSourceFile;
-					const sourceClass = findClassWalk(moduleSourceFile, foundClassDeclaration.name?.getText());
+					const sourceClass = findClassWalk(moduleSourceFile, foundClassName);
 					if (sourceClass) {
 						dependentClasses.push({
 							classNode: sourceClass,
@@ -15534,19 +15851,24 @@ function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeC
 				if (!buildCtx.config._isTesting) augmentDiagnosticWithNode(err, classDeclaration);
 				return;
 			}
-			if (matchedStatement && ts.isClassDeclaration(matchedStatement)) foundClassDeclaration = matchedStatement;
-			else if (matchedStatement) {
+			if (matchedStatement && ts.isClassDeclaration(matchedStatement)) {
+				foundClassDeclaration = matchedStatement;
+				foundClassName = foundClassDeclaration.name?.getText();
+			} else if (matchedStatement) {
 				foundClassDeclaration = findClassWalk(matchedStatement);
+				foundClassName = foundClassDeclaration?.name?.getText() ?? extendee.getText();
 				keepLooking = false;
+				if (!foundClassDeclaration) warnMixinFactoryClassNotFound(buildCtx, extendee.getText(), classDeclaration);
 			} else {
 				foundClassDeclaration = findClassWalk(currentSource, extendee.getText());
+				foundClassName = foundClassDeclaration?.name?.getText() ?? extendee.getText();
 				keepLooking = false;
 			}
 			if (foundClassDeclaration && !dependentClasses.some((dc) => dc.classNode === foundClassDeclaration)) {
 				const foundModule = compilerCtx.moduleMap.get(currentSource.fileName);
 				if (foundModule?.staticSourceFile) {
 					const transformedSource = foundModule.staticSourceFile;
-					const transformedClass = findClassWalk(transformedSource, foundClassDeclaration.name?.getText());
+					const transformedClass = findClassWalk(transformedSource, foundClassName);
 					if (transformedClass) {
 						dependentClasses.push({
 							classNode: transformedClass,
@@ -15831,7 +16153,7 @@ function convertInMemorySourceDecorators(sourceFile, config) {
 		const program = ts.createProgram([sourceFile.fileName], compilerOptions, compilerHost);
 		const typeChecker = program.getTypeChecker();
 		const ownSourceFile = program.getSourceFile(sourceFile.fileName) ?? sourceFile;
-		const result = ts.transform(ownSourceFile, [convertDecoratorsToStatic(config, [], typeChecker, program)]);
+		const result = ts.transform(ownSourceFile, [convertDecoratorsToStatic(config, [], typeChecker, program, true)]);
 		const printed = ts.createPrinter({ removeComments: false }).printFile(result.transformed[0]);
 		const scriptKind = sourceFile.fileName.endsWith(".tsx") || sourceFile.fileName.endsWith(".ts") ? ts.ScriptKind.TSX : ts.ScriptKind.JS;
 		return ts.createSourceFile(sourceFile.fileName, printed, sourceFile.languageVersion, true, scriptKind);
@@ -15971,6 +16293,7 @@ function resolveAncestors(classNode, sf, path, resolveImport, visited, ancestors
 			else {
 				foundClass = findClassWalk(sameFileStatement);
 				keepLooking = false;
+				if (!foundClass) warnMixinFactoryClassNotFound(buildCtx, parentName, rootClassDeclaration);
 			}
 		} else {
 			const specifier = findImportSpecifier(sf, parentName);
@@ -15998,13 +16321,15 @@ function resolveAncestors(classNode, sf, path, resolveImport, visited, ancestors
 			else {
 				foundClass = findClassWalk(found.statement);
 				keepLooking = false;
+				if (!foundClass) warnMixinFactoryClassNotFound(buildCtx, parentName, rootClassDeclaration);
 			}
 		}
 		if (!foundClass || ancestors.some((a) => a.classNode === foundClass)) continue;
 		ancestors.push({
 			classNode: foundClass,
 			sourceFile: foundSf,
-			path: foundPath
+			path: foundPath,
+			factoryName: parentName
 		});
 		if (keepLooking) resolveAncestors(foundClass, foundSf, foundPath, resolveImport, visited, ancestors, rootClassDeclaration, buildCtx);
 	}
@@ -16021,8 +16346,8 @@ function resolveAncestors(classNode, sf, path, resolveImport, visited, ancestors
 * @returns the ancestor's metadata
 */
 function extractAncestorMeta(ancestor, cmpSourceFile, resolveImport, config) {
-	const { classNode, sourceFile: parentSf, path: resolvedPath } = ancestor;
-	const className = classNode.name?.text;
+	const { classNode, sourceFile: parentSf, path: resolvedPath, factoryName } = ancestor;
+	const className = classNode.name?.text ?? factoryName;
 	const parentStaticMembers = classNode.members.filter(isStaticGetter);
 	let resolvedClassNode = classNode;
 	let resolvedStaticMembers = parentStaticMembers;
@@ -16727,7 +17052,7 @@ const parseCollectionComponents = (config, compilerCtx, buildCtx, collectionDir,
 };
 const transpileCollectionModule = (config, compilerCtx, buildCtx, collection, inputFileName) => {
 	const sourceText = compilerCtx.fs.readFileSync(inputFileName);
-	const sourceFile = ts.createSourceFile(inputFileName, sourceText, ts.ScriptTarget.ES2017, true, ts.ScriptKind.JS);
+	const sourceFile = ts.createSourceFile(inputFileName, sourceText, ts.ScriptTarget.ES2022, true, ts.ScriptKind.JS);
 	return updateModule(config, compilerCtx, buildCtx, sourceFile, sourceText, inputFileName, void 0, collection);
 };
 //#endregion
@@ -17878,13 +18203,17 @@ const getPackageJsonRecommendations = (config, compilerCtx) => {
 	const loaderBundle = config.outputTargets.find(isOutputTargetLoaderBundle);
 	const standalone = config.outputTargets.find(isOutputTargetStandalone);
 	const types = config.outputTargets.find(isOutputTargetTypes);
+	const srcIndexPath = join$2(config.srcDir, "index.ts");
+	const hasSrcIndex = compilerCtx.fs.accessSync(srcIndexPath);
 	const moduleOptions = [];
-	if (loaderBundle?.dir) moduleOptions.push(normalizePath(relative$1(config.rootDir, join$2(loaderBundle.dir, "index.js"))));
+	if (loaderBundle?.dir) {
+		const loaderEntry = hasSrcIndex ? join$2(loaderBundle.dir, "index.js") : join$2(loaderBundle.dir, "esm", "loader.js");
+		moduleOptions.push(normalizePath(relative$1(config.rootDir, loaderEntry)));
+	}
 	if (standalone?.dir) moduleOptions.push(normalizePath(relative$1(config.rootDir, join$2(standalone.dir, "index.js"))));
 	const typesOptions = [];
 	if (types?.dir) {
-		const srcIndexPath = join$2(config.srcDir, "index.ts");
-		if (compilerCtx.fs.accessSync(srcIndexPath)) typesOptions.push(normalizePath(relative$1(config.rootDir, join$2(types.dir, "index.d.ts"))));
+		if (hasSrcIndex) typesOptions.push(normalizePath(relative$1(config.rootDir, join$2(types.dir, "index.d.ts"))));
 		else {
 			if (loaderBundle) typesOptions.push(normalizePath(relative$1(config.rootDir, join$2(types.dir, "loader.d.ts"))));
 			if (standalone) typesOptions.push(normalizePath(relative$1(config.rootDir, join$2(types.dir, "standalone.d.ts"))));
@@ -17902,6 +18231,31 @@ const getPackageJsonRecommendations = (config, compilerCtx) => {
 	};
 };
 /**
+* Collect the rootDir-relative directories of every configured output target that must
+* ship in the published npm package for consumers (and their tooling) to be able to use
+* it - as opposed to dev-only artifacts like `www`.
+* @param config The validated Stencil configuration
+* @param buildCtx The build context (used to check whether there are actually component
+* assets to copy - the `assets` output target is otherwise a no-op and its directory is
+* never written)
+* @returns a de-duplicated list of rootDir-relative directory paths
+*/
+const getDistributableOutputDirs = (config, buildCtx) => {
+	const loaderBundle = config.outputTargets.find(isOutputTargetLoaderBundle);
+	const standalone = config.outputTargets.find(isOutputTargetStandalone);
+	const types = config.outputTargets.find(isOutputTargetTypes);
+	const collections = config.outputTargets.filter(isOutputTargetCollection);
+	const assets = buildCtx.components.some((cmp) => cmp.assetsDirs != null && cmp.assetsDirs.length > 0) ? config.outputTargets.find(isOutputTargetAssets) : void 0;
+	const dirs = [
+		loaderBundle?.dir,
+		standalone?.dir,
+		types?.dir,
+		assets?.dir,
+		...collections.map((c) => c.dir)
+	].filter((dir) => !!dir).map((dir) => normalizePath(relative$1(config.rootDir, dir)));
+	return Array.from(new Set(dirs));
+};
+/**
 * Validate the package.json file for a project, checking that various fields
 * are set correctly for the currently-configured output targets.
 *
@@ -17915,8 +18269,8 @@ const getPackageJsonRecommendations = (config, compilerCtx) => {
 const validateBuildPackageJson = async (config, compilerCtx, buildCtx) => {
 	if (config.watch || config.devMode || buildCtx.packageJson == null) return;
 	validatePackageJson(config, compilerCtx, buildCtx);
-	const stencilCollectionOutputTargets = config.outputTargets.filter(isOutputTargetCollection);
-	await Promise.all(stencilCollectionOutputTargets.map((stencilCollectionOT) => validateCollectionFields(config, compilerCtx, buildCtx, stencilCollectionOT)));
+	await validateFilesField(config, compilerCtx, buildCtx);
+	config.outputTargets.filter(isOutputTargetCollection).forEach((stencilCollectionOT) => validateCollectionField(config, compilerCtx, buildCtx, stencilCollectionOT));
 };
 /**
 * Validates a project's package.json fields against recommended values
@@ -18034,40 +18388,49 @@ const validateTypeField = (config, compilerCtx, buildCtx, recommendations) => {
 	if (recommendations.moduleOptions.length > 0 && currentType !== "module") packageJsonWarn(config, compilerCtx, buildCtx, `package.json "type" property should be set to "module".`, "\"type\"");
 };
 /**
-* Validate package.json contents specific to the `collection` output target,
-* checking that the `files` array and `collection` field are set correctly.
-* @param config the Stencil configuration associated with the project being compiled
-* @param compilerCtx the current compiler context
-* @param buildCtx the context associated with the current build
-* @param outputTarget the collection output target to validate against
+* Check if a rootDir-relative directory is covered by a package.json `files` array,
+* either directly or via a parent directory entry (e.g. "dist/" covers "dist/types/").
+* @param files the package.json "files" array
+* @param dir the rootDir-relative directory to check for
+* @returns true if `dir` is covered by one of the `files` entries
 */
-const validateCollectionFields = async (config, compilerCtx, buildCtx, outputTarget) => {
-	await Promise.all([validatePackageFiles(config, compilerCtx, buildCtx, outputTarget), validateCollectionField(config, compilerCtx, buildCtx, outputTarget)]);
+const isDirCoveredByFiles = (files, dir) => {
+	const normalizedDir = dir.replace(/\/$/, "").replace(/^\.\//, "");
+	return files.some((userPath) => {
+		const normalizedUserPath = normalizePath(userPath).replace(/\/$/, "").replace(/^\.\//, "");
+		if (normalizedUserPath === normalizedDir) return true;
+		const userPathWithSlash = normalizedUserPath + "/";
+		return normalizedDir.startsWith(userPathWithSlash);
+	});
 };
 /**
-* Validate that the `files` field in `package.json` contains directories and
-* files that are necessary for the `collection` output target.
+* Validate that the `files` field in `package.json` covers every distributable output
+* directory (loader-bundle, standalone, types, collection) - not just one of them -
+* since `npm publish` needs all of them to produce a working package for consumers.
 * @param config the Stencil configuration associated with the project being compiled
 * @param compilerCtx the current compiler context
 * @param buildCtx the context associated with the current build
-* @param outputTarget the collection output target to validate against
 */
-const validatePackageFiles = async (config, compilerCtx, buildCtx, outputTarget) => {
-	if (!Array.isArray(buildCtx.packageJson.files)) return;
-	const actualDistDir = normalizePath(relative$1(config.rootDir, outputTarget.dir));
-	if (!buildCtx.packageJson.files.some((userPath) => {
-		const normalizedUserPath = normalizePath(userPath).replace(/\/$/, "").replace(/^\.\//, "");
-		const normalizedDistDir = actualDistDir.replace(/\/$/, "").replace(/^\.\//, "");
-		if (normalizedUserPath === normalizedDistDir) return true;
-		const userPathWithSlash = normalizedUserPath + "/";
-		if (normalizedDistDir.startsWith(userPathWithSlash)) return true;
-		return false;
-	})) {
-		const msg = `package.json "files" array must contain the distribution directory "${actualDistDir}/" when generating a distribution.`;
+const validateFilesField = async (config, compilerCtx, buildCtx) => {
+	const distDirs = getDistributableOutputDirs(config, buildCtx);
+	if (distDirs.length === 0) return;
+	const formatDirs = (dirs) => dirs.map((dir) => `"${dir}/"`).join(", ");
+	if (!Array.isArray(buildCtx.packageJson.files)) {
+		const npmignorePath = join$2(dirname$1(config.packageJsonFilePath), ".npmignore");
+		if (!await compilerCtx.fs.access(npmignorePath)) {
+			const msg = `package.json is missing a "files" array. Without one, "npm publish" falls back to ".gitignore" to decide what to include, which will likely exclude ${distDirs.length > 1 ? "the distribution directories" : "the distribution directory"} ${formatDirs(distDirs)}. Add a "files" array covering ${distDirs.length > 1 ? "them" : "it"} to package.json (or add a ".npmignore").`;
+			packageJsonWarn(config, compilerCtx, buildCtx, msg, `"files"`);
+		}
+		return;
+	}
+	const files = buildCtx.packageJson.files;
+	const uncoveredDirs = distDirs.filter((dir) => !isDirCoveredByFiles(files, dir));
+	if (uncoveredDirs.length > 0) {
+		const msg = `package.json "files" array must contain the distribution ${uncoveredDirs.length > 1 ? "directories" : "directory"} ${formatDirs(uncoveredDirs)} when generating a distribution.`;
 		packageJsonWarn(config, compilerCtx, buildCtx, msg, `"files"`);
 		return;
 	}
-	await Promise.all(buildCtx.packageJson.files.map(async (pkgFile) => {
+	await Promise.all(files.map(async (pkgFile) => {
 		if (!isGlob(pkgFile)) {
 			const packageJsonDir = dirname$1(config.packageJsonFilePath);
 			const absPath = join$2(packageJsonDir, pkgFile);
@@ -18182,6 +18545,24 @@ const validateBuildFiles = (config, compilerCtx, buildCtx) => {
 //#endregion
 //#region src/compiler/build/write-export-maps.ts
 /**
+* Create the shared {@link NpmPkgSet} used across a single `writeExportMaps` run.
+* @param buildCtx The build context to report a warning diagnostic on if `npm` can't be run
+* @returns A function that shells out to `npm pkg set`, swallowing failure after warning once
+*/
+const createNpmPkgSet = (buildCtx) => {
+	let npmAvailable = true;
+	return (cmd) => {
+		if (!npmAvailable) return;
+		try {
+			execSync(`npm pkg set ${cmd}`);
+		} catch (e) {
+			npmAvailable = false;
+			const warn = buildWarn(buildCtx.diagnostics);
+			warn.messageText = `Unable to generate "exports" map in package.json: the "npm" CLI could not be run (${e.message ?? e}). Set "generateExportMaps: false" in your Stencil config to silence this warning.`;
+		}
+	};
+};
+/**
 * Create export map entry point definitions for the `package.json` file using the npm CLI.
 *
 * In v5, this uses a "smart default" approach:
@@ -18192,15 +18573,17 @@ const validateBuildFiles = (config, compilerCtx, buildCtx) => {
 * - Generate per-component exports for standalone output
 *
 * @param config The validated Stencil config
+* @param compilerCtx The compiler context (used to detect a user-authored src/index.ts)
 * @param buildCtx The build context containing the components to generate export maps for
 */
-const writeExportMaps = (config, buildCtx) => {
+const writeExportMaps = (config, compilerCtx, buildCtx) => {
 	const loaderBundle = config.outputTargets.find(isOutputTargetLoaderBundle);
 	const standalone = config.outputTargets.find(isOutputTargetStandalone);
 	const types = config.outputTargets.find(isOutputTargetTypes);
-	generateRootExport(config, buildCtx, loaderBundle, standalone, types);
-	if (loaderBundle) generateLoaderExport(config, loaderBundle, types);
-	if (standalone) generateComponentExports(config, buildCtx, standalone);
+	const npmPkgSet = createNpmPkgSet(buildCtx);
+	generateRootExport(config, compilerCtx, buildCtx, loaderBundle, standalone, types, npmPkgSet);
+	if (loaderBundle) generateLoaderExport(config, loaderBundle, types, npmPkgSet);
+	if (standalone) generateComponentExports(config, buildCtx, standalone, npmPkgSet);
 };
 /**
 * Generate the root export `exports["."]`.
@@ -18210,28 +18593,32 @@ const writeExportMaps = (config, buildCtx) => {
 * - If valid, leave it alone
 * - If missing or invalid, set default (loader-bundle > standalone priority)
 * @param config The validated Stencil config
+* @param compilerCtx The compiler context (used to detect a user-authored src/index.ts)
 * @param buildCtx The build context containing the components to generate export maps for
 * @param loaderBundle The loader-bundle output target, if it exists
 * @param standalone The standalone output target, if it exists
 * @param types The types output target, if it exists
+* @param npmPkgSet Function used to run `npm pkg set`, tolerating an unavailable npm CLI
 */
-const generateRootExport = (config, buildCtx, loaderBundle, standalone, types) => {
+const generateRootExport = (config, compilerCtx, buildCtx, loaderBundle, standalone, types, npmPkgSet) => {
 	if (!loaderBundle && !standalone) return;
+	const hasSrcIndex = compilerCtx.fs.accessSync(join$2(config.srcDir, "index.ts"));
+	const rootUsesEmptyLoaderIndex = !!loaderBundle && !hasSrcIndex;
 	const currentImport = ((buildCtx.packageJson?.exports)?.["."])?.import;
 	if (!(currentImport && isValidRootExport(config, currentImport, loaderBundle, standalone))) {
 		const primaryDir = loaderBundle?.dir ?? standalone?.dir;
 		if (primaryDir) {
-			const importPath = normalizePath(relative$1(config.rootDir, join$2(primaryDir, "index.js")));
-			execSync(`npm pkg set "exports[.][import]"="${importPath}"`);
+			const entryFile = rootUsesEmptyLoaderIndex ? join$2("esm", "loader.js") : "index.js";
+			npmPkgSet(`"exports[.][import]"="${normalizePath(relative$1(config.rootDir, join$2(primaryDir, entryFile)))}"`);
 			if (loaderBundle?.cjs) {
-				const requirePath = normalizePath(relative$1(config.rootDir, join$2(loaderBundle.dir, "index.cjs")));
-				execSync(`npm pkg set "exports[.][require]"="${requirePath}"`);
+				const cjsEntryFile = rootUsesEmptyLoaderIndex ? join$2("cjs", "loader.cjs") : "index.cjs";
+				npmPkgSet(`"exports[.][require]"="${normalizePath(relative$1(config.rootDir, join$2(loaderBundle.dir, cjsEntryFile)))}"`);
 			}
 		}
 	}
 	if (types?.dir) {
-		const typesPath = normalizePath(relative$1(config.rootDir, join$2(types.dir, "index.d.ts")));
-		execSync(`npm pkg set "exports[.][types]"="${typesPath}"`);
+		const typesFile = rootUsesEmptyLoaderIndex ? "loader.d.ts" : "index.d.ts";
+		npmPkgSet(`"exports[.][types]"="${normalizePath(relative$1(config.rootDir, join$2(types.dir, typesFile)))}"`);
 	}
 };
 /**
@@ -18274,20 +18661,16 @@ const ensureRelativePrefix = (path) => {
 * @param config The validated Stencil config
 * @param loaderBundle The loader-bundle output target
 * @param types The types output target, if it exists
+* @param npmPkgSet Function used to run `npm pkg set`, tolerating an unavailable npm CLI
 */
-const generateLoaderExport = (config, loaderBundle, types) => {
+const generateLoaderExport = (config, loaderBundle, types, npmPkgSet) => {
 	const esmDir = join$2(loaderBundle.dir, "esm");
-	const esmLoaderPath = ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(esmDir, "loader.js"))));
-	execSync(`npm pkg set "exports[./loader][import]"="${esmLoaderPath}"`);
+	npmPkgSet(`"exports[./loader][import]"="${ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(esmDir, "loader.js"))))}"`);
 	if (loaderBundle.cjs) {
 		const cjsDir = join$2(loaderBundle.dir, "cjs");
-		const cjsLoaderPath = ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(cjsDir, "loader.cjs"))));
-		execSync(`npm pkg set "exports[./loader][require]"="${cjsLoaderPath}"`);
-	}
-	if (types?.dir) {
-		const typesPath = ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(types.dir, "loader.d.ts"))));
-		execSync(`npm pkg set "exports[./loader][types]"="${typesPath}"`);
+		npmPkgSet(`"exports[./loader][require]"="${ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(cjsDir, "loader.cjs"))))}"`);
 	}
+	if (types?.dir) npmPkgSet(`"exports[./loader][types]"="${ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(types.dir, "loader.d.ts"))))}"`);
 };
 /**
 * Generate per-component exports for standalone output.
@@ -18295,13 +18678,14 @@ const generateLoaderExport = (config, loaderBundle, types) => {
 * @param config The validated Stencil config
 * @param buildCtx The build context containing the components to generate export maps for
 * @param standalone The standalone output target
+* @param npmPkgSet Function used to run `npm pkg set`, tolerating an unavailable npm CLI
 */
-const generateComponentExports = (config, buildCtx, standalone) => {
+const generateComponentExports = (config, buildCtx, standalone, npmPkgSet) => {
 	let outDir = relative$1(config.rootDir, standalone.dir);
 	if (!outDir.startsWith(".")) outDir = "./" + outDir;
 	buildCtx.components.forEach((cmp) => {
-		execSync(`npm pkg set "exports[./${cmp.tagName}][import]"="${outDir}/${cmp.tagName}.js"`);
-		execSync(`npm pkg set "exports[./${cmp.tagName}][types]"="${outDir}/${cmp.tagName}.d.ts"`);
+		npmPkgSet(`"exports[./${cmp.tagName}][import]"="${outDir}/${cmp.tagName}.js"`);
+		npmPkgSet(`"exports[./${cmp.tagName}][types]"="${outDir}/${cmp.tagName}.d.ts"`);
 	});
 };
 //#endregion
@@ -18325,7 +18709,7 @@ const writeBuild = async (config, compilerCtx, buildCtx) => {
 		await compilerCtx.cache.commit();
 		buildCtx.debug(`in-memory-fs: ${compilerCtx.fs.getMemoryStats()}`);
 		buildCtx.debug(`cache: ${compilerCtx.cache.getMemoryStats()}`);
-		if (config.generateExportMaps) writeExportMaps(config, buildCtx);
+		if (config.generateExportMaps && !config.devMode) writeExportMaps(config, compilerCtx, buildCtx);
 		await outputServiceWorkers(config, buildCtx);
 		await validateBuildFiles(config, compilerCtx, buildCtx);
 	} catch (e) {
@@ -20360,10 +20744,11 @@ const validateConfig = (userConfig = {}, bootstrapConfig) => {
 	const devMode = isBoolean$1(config.devMode) ? config.devMode : false;
 	config._isTesting = !!(process.env.VITEST || process.env.PLAYWRIGHT_TEST || process.env.TEST_WORKER_INDEX || process.env.TEST_PARALLEL_INDEX || process.env.NODE_ENV === "test");
 	const sys = config.sys ?? bootstrapConfig.sys ?? createNodeSys({ logger });
+	const hasExplicitGlobalStyleWithInput = (config.outputTargets || []).some((o) => isOutputTargetGlobalStyle(o) && isString$1(o.input));
 	if ((!isString$1(config.globalStyle) || !isString$1(config.globalScript)) && typeof sys.accessSync === "function") {
 		const preRootDir = typeof config.rootDir !== "string" ? "/" : config.rootDir;
 		const srcDir = typeof config.srcDir === "string" ? isAbsolute$1(config.srcDir) ? config.srcDir : join$1(preRootDir, config.srcDir) : join$1(preRootDir, "src");
-		if (!isString$1(config.globalStyle)) for (const ext of STYLE_EXT) {
+		if (!isString$1(config.globalStyle) && !hasExplicitGlobalStyleWithInput) for (const ext of STYLE_EXT) {
 			const candidate = join$1(srcDir, `global.${ext}`);
 			if (sys.accessSync(candidate)) {
 				config.globalStyle = candidate;
@@ -20383,12 +20768,13 @@ const validateConfig = (userConfig = {}, bootstrapConfig) => {
 		...config,
 		devMode,
 		compat: config.compat || {},
-		generateExportMaps: isBoolean$1(config.generateExportMaps) ? config.generateExportMaps : false,
+		generateExportMaps: isBoolean$1(config.generateExportMaps) ? config.generateExportMaps : !isString$1(config.configPath),
 		hydratedFlag: validateHydrated(config),
 		logLevel,
 		logger,
 		minifyCss: config.minifyCss ?? !devMode,
 		minifyJs: config.minifyJs ?? !devMode,
+		jsMinifier: config.jsMinifier ?? "oxc",
 		outputTargets: config.outputTargets ?? [],
 		rolldownConfig: validateRolldownConfig(config),
 		sourceMap: config.sourceMap === true || devMode && (config.sourceMap === "dev" || typeof config.sourceMap === "undefined"),
@@ -22897,29 +23283,36 @@ const generateTransformCssToEsm = (input, results) => {
 	results.styleText = results.styleText.replace(/\\/g, "\\\\").replace(/\n/g, " ").replace(/\r/g, " ").replace(/\t/g, " ").replace(/\u000c/g, "\\\\f").replace(/\u0008/g, "\\\\b").replace(/\u000b/g, "\\\\v").replace(/\0/g, "\\\\0").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
 	if (input.addTagTransformers) results.styleText = addTagTransformToCssString(results.styleText, input.tags);
 	results.styleText = stripCssComments(results.styleText);
+	const isComponentStyle = isString$1(input.tag);
+	const defaultAssignment = `const ${results.defaultVarName} = ${isComponentStyle ? "() => " : ""}`;
 	if (input.module === "cjs") {
 		if (input.addTagTransformers) s.append(`const ${TRANSFORM_TAG} = require('${STENCIL_CORE_ID}').transformTag;\n`);
+		if (!isComponentStyle) s.append(`const ${INJECT_SIDE_EFFECT_STYLE} = require('${STENCIL_CORE_ID}').injectSideEffectStyle;\n`);
 		results.imports.forEach((cssImport) => {
 			s.append(`const ${cssImport.varName} = require('${cssImport.importPath}');\n`);
 		});
-		s.append(`const ${results.defaultVarName} = () => `);
+		s.append(defaultAssignment);
 		results.imports.forEach((cssImport) => {
 			s.append(`${cssImport.varName} + `);
 		});
 		s.append(`\`${results.styleText}\`;\n`);
+		if (!isComponentStyle) s.append(`${INJECT_SIDE_EFFECT_STYLE}(${results.defaultVarName});\n`);
 		s.append(`module.exports = ${results.defaultVarName};`);
 	} else {
 		if (input.addTagTransformers) s.append(`import { transformTag as ${TRANSFORM_TAG}  } from '${STENCIL_CORE_ID}';\n`);
+		if (!isComponentStyle) s.append(`import { injectSideEffectStyle as ${INJECT_SIDE_EFFECT_STYLE} } from '${STENCIL_CORE_ID}';\n`);
 		results.imports.forEach((cssImport) => {
 			s.append(`import ${cssImport.varName} from '${cssImport.importPath}';\n`);
 		});
-		s.append(`const ${results.defaultVarName} = () => `);
+		s.append(defaultAssignment);
 		results.imports.forEach((cssImport) => {
 			s.append(`${cssImport.varName} + `);
 		});
 		s.append(`\`${results.styleText}\`;\n`);
+		if (!isComponentStyle) s.append(`${INJECT_SIDE_EFFECT_STYLE}(${results.defaultVarName});\n`);
 		s.append(`export default ${results.defaultVarName};`);
 	}
+	results.moduleSideEffects = !isComponentStyle;
 	results.output = s.toString();
 	return results;
 };
@@ -22947,6 +23340,7 @@ const getCssToEsmImports = (varNames, cssText, filePath, modeName) => {
 			isNodeModule: false
 		};
 		if (!isLocalCssImport(cssImportData.srcImportText)) continue;
+		else if (cssImportData.url === "stencil-globals" || cssImportData.url === "stencil-hydrate") continue;
 		else if (isCssNodeModule(cssImportData.url)) {
 			cssImportData.filePath = cssImportData.url.substring(1);
 			cssImportData.isNodeModule = true;
@@ -24458,8 +24852,8 @@ const transpileModule = (config, input, transformOpts) => {
 		getDefaultLibFileName: () => `lib.d.ts`,
 		useCaseSensitiveFileNames: () => false,
 		getCanonicalFileName: (fileName) => fileName,
-		getCurrentDirectory: () => transformOpts.currentDirectory || process.cwd(),
-		getNewLine: () => ts.sys.newLine || "\n",
+		getCurrentDirectory: () => transformOpts.currentDirectory || (typeof process !== "undefined" ? process.cwd() : "/"),
+		getNewLine: () => ts.sys && ts.sys.newLine || "\n",
 		fileExists: (fileName) => normalizePath(fileName) === normalizePath(sourceFilePath),
 		readFile: () => "",
 		directoryExists: () => true,