@stencil/core 5.0.0-beta.1 → 5.0.0-beta.11

package/dist/{compiler-CJG6qvQt.mjs → compiler-2EypBn_Y.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-CdFmjaQa.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-HKfDhPR3.mjs";
 import ts, { default as ts$1 } from "typescript";
 import { readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
@@ -342,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
@@ -439,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");
@@ -462,9 +461,9 @@ const scopeCss = (cssText, scopeId, commentOriginalSelector) => {
 };
 //#endregion
 //#region src/version.ts
-const version = "5.0.0-beta.1";
-const buildId = "1788442714";
-const vermoji = "🚓";
+const version = "5.0.0-beta.11";
+const buildId = "1789429964";
+const vermoji = "🍦";
 /**
 * Get the installed version of a tool/dependency.
 * Handles packages with exports maps that point to subdirectories.
@@ -6025,7 +6024,8 @@ const addTagTransform$2 = (compilerCtx, buildCtx) => {
 					const expression = node.expression;
 					if (ts.isPropertyAccessExpression(expression) && ((expression.name.text === "get" || expression.name.text === "define" || expression.name.text === "whenDefined") && ts.isIdentifier(expression.expression) && expression.expression.text === "customElements" || expression.name.text === "createElement" && ts.isIdentifier(expression.expression) && expression.expression.text === "document")) {
 						const [firstArg, ...restArgs] = node.arguments;
-						if (firstArg) {
+						const alreadyTransformed = firstArg && ts.isCallExpression(firstArg) && ts.isIdentifier(firstArg.expression) && (firstArg.expression.text === "__stencil_transformTag" || firstArg.expression.text === "transformTag");
+						if (firstArg && !alreadyTransformed) {
 							const newFirstArg = ts.factory.createCallExpression(ts.factory.createIdentifier(TRANSFORM_TAG), void 0, [firstArg]);
 							newNode = ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [newFirstArg, ...restArgs]);
 						}
@@ -7373,7 +7373,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`);
@@ -9388,15 +9394,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.`,
@@ -9410,7 +9418,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");
 };
 /**
@@ -9900,7 +9919,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) => {
@@ -9917,8 +9936,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);
@@ -10355,8 +10378,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.
@@ -10364,8 +10388,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[];
@@ -10401,7 +10426,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);
 };
@@ -10411,8 +10446,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.
@@ -10445,7 +10481,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);
 };
@@ -11186,10 +11231,13 @@ const MODE_RESOLUTION_CHAIN_DECLARATION = `modeResolutionChain = [];`;
 const SSR_FACTORY_INTRO = `
 //! let ${MODE_RESOLUTION_CHAIN_DECLARATION}
 
-// Capture native setTimeout/clearTimeout at module scope (before globalThis can be shadowed inside the factory).
+// Capture native at module scope (before globalThis can be shadowed inside the factory).
+
 // Used for the hydrate timeout timer to avoid being affected by constrainTimeouts.
 var $nativeSetTimeout = (typeof globalThis !== 'undefined' ? globalThis : global).setTimeout;
 var $nativeClearTimeout = (typeof globalThis !== 'undefined' ? globalThis : global).clearTimeout;
+// Used to abort in-flight fetch() calls and to call any user defined AbortControllers when ssr times out.
+var $stencilNativeAbortController = AbortController;
 
 export function ssrFactory($stencilWindow, $stencilHydrateOpts, $stencilHydrateResults, $stencilAfterHydrate, $stencilHydrateResolve) {
   var globalThis = $stencilWindow;
@@ -11282,8 +11330,46 @@ export function ssrFactory($stencilWindow, $stencilHydrateOpts, $stencilHydrateR
 
   var fetch, FetchError, Headers, Request, Response;
 
+  // Aborted when the render times out or errors, so in-flight fetch() calls
+  // made by component code stop holding the render's window/results alive
+  // instead of running to completion against a torn-down window. See #6864.
+  var $stencilAbortController = new $stencilNativeAbortController();
+
+  // Any AbortController a component creates itself is transparently wired to
+  // cascade-abort when the render times out too, so component code using the
+  // standard AbortController convention for its own cancellable work (axios,
+  // aws-sdk v3, the mongodb driver, etc.) gets cancelled automatically. 
+  var AbortController = function () {
+    var controller = new $stencilNativeAbortController();
+    $stencilAbortController.signal.addEventListener(
+      'abort',
+      function () {
+        controller.abort();
+      },
+      { once: true },
+    );
+    return controller;
+  };
+
+  function $stencilFetchSignal(callerSignal) {
+    if (!callerSignal) {
+      return $stencilAbortController.signal;
+    }
+    if (callerSignal.aborted || $stencilAbortController.signal.aborted) {
+      return callerSignal.aborted ? callerSignal : $stencilAbortController.signal;
+    }
+    var merged = new $stencilNativeAbortController();
+    var onAbort = function () { merged.abort(); };
+    callerSignal.addEventListener('abort', onAbort, { once: true });
+    $stencilAbortController.signal.addEventListener('abort', onAbort, { once: true });
+    return merged.signal;
+  }
+
   if (typeof $stencilWindow.fetch === 'function') {
-    fetch = $stencilWindow.fetch;
+    var $stencilRawFetch = $stencilWindow.fetch;
+    fetch = $stencilWindow.fetch = function(input, init) {
+      return $stencilRawFetch(input, Object.assign({}, init, { signal: $stencilFetchSignal(init && init.signal) }));
+    };
   } else {
     fetch = $stencilWindow.fetch = function() { throw new Error('fetch() is not implemented'); };
   }
@@ -11319,7 +11405,7 @@ export function ssrFactory($stencilWindow, $stencilHydrateOpts, $stencilHydrateR
 `;
 const SSR_FACTORY_OUTRO = `
     /*hydrateAppClosure end*/
-    ssrApp(window, $stencilHydrateOpts, $stencilHydrateResults, $stencilAfterHydrate, $stencilHydrateResolve);
+    ssrApp(window, $stencilHydrateOpts, $stencilHydrateResults, $stencilAfterHydrate, $stencilHydrateResolve, $stencilAbortController);
   }
 
   hydrateAppClosure($stencilWindow);
@@ -11593,6 +11679,40 @@ if (typeof globalThis !== "undefined") {
   if (typeof globalThis.clearInterval !== "function") globalThis.clearInterval = function() {};
 }
 `;
+const SSR_WASM_ABORT_CONTROLLER_POLYFILL = `
+if (typeof globalThis !== "undefined" && typeof globalThis.AbortController !== "function") {
+  function StencilPolyfillAbortSignal() {
+    this.aborted = false;
+    this.reason = undefined;
+    this._listeners = [];
+  }
+  StencilPolyfillAbortSignal.prototype.addEventListener = function(type, listener, options) {
+    if (type !== "abort" || typeof listener !== "function") return;
+    this._listeners.push({ listener: listener, once: !!(options && options.once) });
+  };
+  StencilPolyfillAbortSignal.prototype.removeEventListener = function(type, listener) {
+    if (type !== "abort") return;
+    this._listeners = this._listeners.filter(function(entry) { return entry.listener !== listener; });
+  };
+  StencilPolyfillAbortSignal.prototype.dispatchEvent = function(event) {
+    var signal = this;
+    signal._listeners.slice().forEach(function(entry) { entry.listener.call(signal, event); });
+    signal._listeners = signal._listeners.filter(function(entry) { return !entry.once; });
+    return true;
+  };
+  function StencilPolyfillAbortController() {
+    this.signal = new StencilPolyfillAbortSignal();
+  }
+  StencilPolyfillAbortController.prototype.abort = function(reason) {
+    if (this.signal.aborted) return;
+    this.signal.aborted = true;
+    this.signal.reason = reason;
+    this.signal.dispatchEvent({ type: "abort" });
+  };
+  globalThis.AbortController = StencilPolyfillAbortController;
+  globalThis.AbortSignal = StencilPolyfillAbortSignal;
+}
+`;
 const SSR_WASM_INTERFACE = `declare module "main" {
   export function renderToString(): void;
   export function setTagTransformer(): void;
@@ -11607,6 +11727,12 @@ module.exports = {
         return;
       }
       var inp = JSON.parse(Host.inputString());
+      // QuickJS-ng has no timers, so if hydration never settles on its own (a Promise
+      // nothing will ever resolve), the call doesn't hang - it just runs out of scheduled
+      // work and returns whatever was last written here. Write a diagnostic up front so
+      // that's a real error instead of silence, then overwrite it once renderToString()
+      // actually resolves.
+      Host.outputString(JSON.stringify({ __error: 'renderToString did not complete - a component may be waiting on work that never resolves' }));
       var result = await renderToString(inp.html, inp.options);
       Host.outputString(JSON.stringify(result));
     } catch(e) {
@@ -11663,7 +11789,7 @@ const generateSsrWasmApp = async (config, compilerCtx, buildCtx, outputTargets)
 			checks: { pluginTimings: config.logLevel === "debug" }
 		};
 		const rolldownOutput = await (await rolldown(rolldownOptions)).generate({
-			banner: generatePreamble(config) + SSR_WASM_TIMER_POLYFILL,
+			banner: generatePreamble(config) + SSR_WASM_TIMER_POLYFILL + SSR_WASM_ABORT_CONTROLLER_POLYFILL,
 			outro: SSR_WASM_OUTRO,
 			format: "iife",
 			name: "StencilSsrWasm",
@@ -12406,7 +12532,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}';
@@ -12767,12 +12893,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}';`);
@@ -12787,14 +12926,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";
@@ -12818,6 +12949,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) {
@@ -15225,14 +15357,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) => {
@@ -15242,10 +15376,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.
@@ -15254,7 +15388,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).
 *
@@ -15273,7 +15407,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"));
@@ -15289,7 +15423,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
@@ -15473,11 +15608,11 @@ const parseStaticWatchers = (staticMembers) => {
 //#endregion
 //#region src/compiler/transformers/static-to-meta/class-extension/shared.ts
 /**
-* Warns when an `extends`/`Mixin(...)` target resolved to *something* but no class declaration
-* could be found inside it - e.g. a mixin factory whose class isn't a named declaration
-* (`(Base) => class extends Base {}` rather than `(Base) => { class Foo extends Base {} return
-* Foo; }`). 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.
+* 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
@@ -15485,27 +15620,32 @@ const parseStaticWatchers = (staticMembers) => {
 function warnMixinFactoryClassNotFound(buildCtx, targetName, anchor) {
 	if (!buildCtx) return;
 	const err = buildWarn(buildCtx.diagnostics);
-	err.messageText = `Found "${targetName}", but couldn't find a class declaration inside it. If it's meant to be a mixin factory, make sure it declares and returns a named class, e.g. \`(Base) => { class ${targetName}Class extends Base {} return ${targetName}Class; }\` - a factory that returns a class expression directly (\`(Base) => class extends Base {}\`) isn't recognized, and any \`@Prop\`/\`@State\`/etc. it declares won't be applied.`;
+	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, 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 {}`).
+* 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;
 	}
@@ -15518,6 +15658,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`).
@@ -15639,7 +15795,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);
 }
@@ -15726,6 +15882,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);
@@ -15742,9 +15899,11 @@ 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);
@@ -15753,7 +15912,7 @@ function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeC
 				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,
@@ -15774,20 +15933,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,
@@ -16072,7 +16235,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);
@@ -16247,7 +16410,8 @@ function resolveAncestors(classNode, sf, path, resolveImport, visited, ancestors
 		ancestors.push({
 			classNode: foundClass,
 			sourceFile: foundSf,
-			path: foundPath
+			path: foundPath,
+			factoryName: parentName
 		});
 		if (keepLooking) resolveAncestors(foundClass, foundSf, foundPath, resolveImport, visited, ancestors, rootClassDeclaration, buildCtx);
 	}
@@ -16264,8 +16428,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;
@@ -18121,13 +18285,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"))));
@@ -18145,6 +18313,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.
 *
@@ -18158,8 +18351,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
@@ -18277,40 +18470,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);
@@ -18425,6 +18627,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:
@@ -18435,15 +18655,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["."]`.
@@ -18453,28 +18675,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)))}"`);
 	}
 };
 /**
@@ -18517,20 +18743,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.
@@ -18538,13 +18760,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
@@ -18568,7 +18791,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) {
@@ -20603,10 +20826,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;
@@ -20626,7 +20850,7 @@ 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,