@stencil/core 5.0.0-alpha.27 → 5.0.0-alpha.29

package/dist/{compiler-D43Ied7R.mjs → compiler-BbS9TDF_.mjs}

@@ -1,14 +1,15 @@
-import { n as __require } from "./chunk-z9aeyW2b.mjs";
-import { O as HYDRATED_CSS, f as scopeCss } from "./client-CvcvHKz4.mjs";
-import { $ as VALID_CONFIG_OUTPUT_TARGETS, C as ASSETS, D as COLLECTION_MANIFEST_FILE_NAME, E as COLLECTION_APP_DATA_FILE_NAME, F as DOCS_README, J as STANDALONE, L as EVENT_FLAGS, O as COPY, P as DOCS_JSON, Q as TYPES, R as GENERATED_DTS, T as COLLECTION, U as LOADER_BUNDLE, X as STYLE_EXT, Y as STATS, _ as sortBy, a as fromEntries, b as toTitleCase, d as isNumber$1, et as WATCH_FLAGS, f as isObject, h as noop, i as flatOne, j as DIST_LAZY, l as isFunction, m as mergeIntoWith, n as dashToPascalCase, o as isBoolean$1, p as isString$1, u as isIterable, x as unique, y as toDashCase, z as GLOBAL_STYLE } from "./regular-expression-CFVJOTUh.mjs";
-import { $ as loadTypeScriptDiagnostics, A as isOutputTargetCollection, B as isOutputTargetGlobalStyle, Ct as formatComponentRuntimeMeta, E as getComponentsDtsSrcFilePath, Et as byteSize, F as isOutputTargetDocsCustom, G as isOutputTargetStats, H as isOutputTargetSsr, I as isOutputTargetDocsCustomElementsManifest, J as isValidConfigOutputTarget, K as isOutputTargetTypes, L as isOutputTargetDocsJson, M as isOutputTargetCustom, N as isOutputTargetDistLazy, O as getComponentsFromModules, P as isOutputTargetDocs, Q as loadTypeScriptDiagnostic, R as isOutputTargetDocsReadme, S as ok, St as isGlob, T as filterExcludedComponents, Tt as stringifyRuntimeData, U as isOutputTargetSsrWasm, V as isOutputTargetLoaderBundle, W as isOutputTargetStandalone, Y as relativeImport, Z as augmentDiagnosticWithNode, _ as getSourceMappingUrlForEndOfFile, _t as catchError, a as getTextDocs, at as relative$1, b as err, ct as isRolldownError, d as isTsxFile, dt as normalizeDiagnostics, et as join$2, f as parsePackageJson, ft as splitLineBreaks, g as getInlineSourceMappingUrlLinker, gt as buildWarn, h as isRemoteUrl, ht as buildJsonFileError, i as generatePreamble, it as normalizePath, j as isOutputTargetCopy, k as isOutputTargetAssets, lt as loadRolldownDiagnostics, m as readPackageJson, mt as buildError, n as addDocBlock, nt as normalizeFsPath, o as hasDependency, ot as resolve$2, p as readOnlyArrayHasStringMember, q as isOutputTargetWww, r as createJsVarName, rt as normalizeFsPathQuery, s as isDtsFile, st as createOnWarnFn, t as validateComponentTag, u as isTsFile, vt as hasError, w as filterActiveTargets, x as map, xt as isRootPath, y as rolldownToStencilSourceMap, yt as hasWarning, z as isOutputTargetDocsVscode } from "./validation-ByxKj8bC.mjs";
-import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-DKVq_Ud0.mjs";
+import { n as __require } from "./rolldown-runtime-BhDjJH2R.mjs";
+import { O as HYDRATED_CSS, f as scopeCss } from "./client-D1MsT-Rp.mjs";
+import { $ as TYPES, B as GLOBAL_STYLE, C as ASSETS, D as COLLECTION_MANIFEST_FILE_NAME, E as COLLECTION_APP_DATA_FILE_NAME, F as DOCS_JSON, I as DOCS_README, O as COPY, R as EVENT_FLAGS, T as COLLECTION, W as LOADER_BUNDLE, X as STATS, Y as STANDALONE, Z as STYLE_EXT, _ as sortBy, a as fromEntries, b as toTitleCase, d as isNumber$1, et as VALID_CONFIG_OUTPUT_TARGETS, f as isObject, h as noop, i as flatOne, j as DIST_LAZY, l as isFunction, m as mergeIntoWith, n as dashToPascalCase, o as isBoolean$1, p as isString$1, tt as WATCH_FLAGS, u as isIterable, x as unique, y as toDashCase, z as GENERATED_DTS } from "./regular-expression-XqU5zmPp.mjs";
+import { 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-Dd3g77T5.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-BIa-iHnt.mjs";
+import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-BQR4L-TG.mjs";
 import ts, { default as ts$1 } from "typescript";
 import { readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import picomatch from "picomatch";
-import path$1, { basename as basename$1, dirname as dirname$1, extname, isAbsolute as isAbsolute$1, join as join$1 } from "path";
+import path, { basename as basename$1, dirname as dirname$1, extname, isAbsolute as isAbsolute$1, join as join$1 } from "path";
 import { cloneDocument, createDocument, serializeNodeToHtml } from "@stencil/mock-doc";
 import postcss from "postcss";
 import postcssSafeParser from "postcss-safe-parser";
@@ -28,9 +29,9 @@ import { createJiti } from "jiti";
 import * as process$1 from "process";
 import { dataToEsm } from "@rollup/pluginutils";
 //#region src/version.ts
-const version = "5.0.0-alpha.27";
-const buildId = "1783983631";
-const vermoji = "🏎";
+const version = "5.0.0-alpha.29";
+const buildId = "1786998516";
+const vermoji = "👾";
 /**
 * Get the installed version of a tool/dependency.
 * Handles packages with exports maps that point to subdirectories.
@@ -41,7 +42,9 @@ const vermoji = "🏎";
 */
 function getToolVersion(name) {
 	try {
-		let dir = dirname(fileURLToPath(import.meta.resolve(name)));
+		const entryUrl = import.meta.resolve(name);
+		const entryPath = fileURLToPath(entryUrl);
+		let dir = dirname(entryPath);
 		while (dir !== dirname(dir)) {
 			const pkgPath = join(dir, "package.json");
 			try {
@@ -161,7 +164,8 @@ const getModuleLegacy = (compilerCtx, sourceFilePath) => {
 	else {
 		const sourceFileDir = dirname$1(sourceFilePath);
 		const sourceFileExt = extname(sourceFilePath);
-		const jsFilePath = join$2(sourceFileDir, basename$1(sourceFilePath, sourceFileExt) + ".js");
+		const sourceFileName = basename$1(sourceFilePath, sourceFileExt);
+		const jsFilePath = join$2(sourceFileDir, sourceFileName + ".js");
 		const moduleFile = {
 			sourceFilePath,
 			jsFilePath,
@@ -190,6 +194,7 @@ const getModuleLegacy = (compilerCtx, sourceFilePath) => {
 			htmlAttrNames: [],
 			htmlTagNames: [],
 			htmlParts: [],
+			htmlSlots: [],
 			isCollectionDependency: false,
 			isLegacy: false,
 			localImports: [],
@@ -256,7 +261,7 @@ const resetModuleLegacy = (moduleFile) => {
 */
 const getTsOptionsToExtend = (config) => {
 	const cacheDir = config.cacheDir || config.sys.tmpDirSync();
-	return {
+	const tsOptions = {
 		experimentalDecorators: true,
 		declaration: config.outputTargets.some(isOutputTargetTypes),
 		module: config.tsCompilerOptions?.module || ts.ModuleKind.ESNext,
@@ -269,6 +274,8 @@ const getTsOptionsToExtend = (config) => {
 		incremental: config.enableCache !== false,
 		tsBuildInfoFile: config.enableCache !== false ? join$2(cacheDir, ".tsbuildinfo") : void 0
 	};
+	if (config.tsCompilerOptions?.skipLibCheck === void 0) tsOptions.skipLibCheck = true;
+	return tsOptions;
 };
 //#endregion
 //#region src/compiler/transpile/create-build-program.ts
@@ -489,7 +496,7 @@ const getModuleImports = (moduleMap, filePath, importedModules) => {
 * build - everything else is a component-derived flag that the consumer recomputes itself
 * by scanning all components (including those from the collection).
 */
-const COLLECTION_CONFIG_FLAGS = new Set([
+const COLLECTION_CONFIG_FLAGS = /* @__PURE__ */ new Set([
 	"lightDomPatches",
 	"slotChildNodes",
 	"slotCloneNode",
@@ -753,11 +760,12 @@ function hostRefElementInternalsPropAccess() {
 */
 const updateLazyComponentConstructor = (classMembers, classNode, moduleFile, cmp) => {
 	const cstrMethodArgs = [ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier(HOST_REF_ARG))];
-	updateConstructor(classNode, classMembers, [
+	const cstrStatements = [
 		registerInstanceStatement(moduleFile),
 		...addCreateEvents(moduleFile, cmp),
 		...createLazyAttachInternalsBinding(cmp)
-	], cstrMethodArgs);
+	];
+	updateConstructor(classNode, classMembers, cstrStatements, cstrMethodArgs);
 };
 /**
 * Create a statement containing an expression calling the `registerInstance`
@@ -951,19 +959,7 @@ function findTypeWithName(module, typeName) {
 function getOriginalTypeName(identifier, checker) {
 	const possiblyAliasedSymbol = checker.getSymbolAtLocation(identifier);
 	if (!possiblyAliasedSymbol) return;
-	return unalias(possiblyAliasedSymbol, checker).getName();
-}
-/**
-* Check if a symbol is an alias of another symbol and, if so, use the
-* {@link ts.TypeChecker} to resolve the original. If not, just return the same
-* symbol.
-*
-* @param symbol the symbol of interest
-* @param checker a {@link ts.TypeChecker}
-* @returns a de-aliased symbol
-*/
-function unalias(symbol, checker) {
-	return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+	return resolveAliasedSymbol(checker, possiblyAliasedSymbol).getName();
 }
 /**
 * Check that a {@link ts.Node} is a type-declaration-like node. For our
@@ -1264,38 +1260,41 @@ const objectLiteralToObjectMap = (objectLiteral, typeChecker, diagnostics, error
 		const propName = getTextOfPropertyName(propAssignment.name);
 		let val;
 		if (ts.isShorthandPropertyAssignment(propAssignment)) val = getIdentifierValue(propName);
-		else if (ts.isPropertyAssignment(propAssignment)) if (ts.isCallExpression(propAssignment.initializer) && typeChecker && (ts.isIdentifier(propAssignment.initializer.expression) && propAssignment.initializer.expression.text === "resolveVar" || ts.isPropertyAccessExpression(propAssignment.initializer.expression) && ts.isIdentifier(propAssignment.initializer.expression.name) && propAssignment.initializer.expression.name.text === "resolveVar")) if (propAssignment.initializer.arguments.length === 1) val = resolveVarInObjectLiteral(propAssignment.initializer.arguments[0], typeChecker, diagnostics, propAssignment.initializer);
-		else val = propAssignment.initializer;
-		else switch (propAssignment.initializer.kind) {
-			case ts.SyntaxKind.ArrayLiteralExpression:
-				val = arrayLiteralToArray(propAssignment.initializer);
-				break;
-			case ts.SyntaxKind.ObjectLiteralExpression:
-				val = objectLiteralToObjectMap(propAssignment.initializer, typeChecker, diagnostics, errorNode);
-				break;
-			case ts.SyntaxKind.StringLiteral:
-				val = propAssignment.initializer.text;
-				break;
-			case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
-				val = propAssignment.initializer.text;
-				break;
-			case ts.SyntaxKind.TrueKeyword:
-				val = true;
-				break;
-			case ts.SyntaxKind.FalseKeyword:
-				val = false;
-				break;
-			case ts.SyntaxKind.Identifier:
-				const escapedText = propAssignment.initializer.escapedText;
-				if (escapedText === "String") val = String;
-				else if (escapedText === "Number") val = Number;
-				else if (escapedText === "Boolean") val = Boolean;
-				else if (escapedText === "undefined") val = void 0;
-				else if (escapedText === "null") val = null;
-				else val = getIdentifierValue(propAssignment.initializer.escapedText);
-				break;
-			case ts.SyntaxKind.PropertyAccessExpression:
-			default: val = propAssignment.initializer;
+		else if (ts.isPropertyAssignment(propAssignment)) {
+			if (ts.isCallExpression(propAssignment.initializer) && typeChecker && (ts.isIdentifier(propAssignment.initializer.expression) && propAssignment.initializer.expression.text === "resolveVar" || ts.isPropertyAccessExpression(propAssignment.initializer.expression) && ts.isIdentifier(propAssignment.initializer.expression.name) && propAssignment.initializer.expression.name.text === "resolveVar")) {
+				if (propAssignment.initializer.arguments.length === 1) val = resolveVarInObjectLiteral(propAssignment.initializer.arguments[0], typeChecker, diagnostics, propAssignment.initializer);
+				else val = propAssignment.initializer;
+			} else switch (propAssignment.initializer.kind) {
+				case ts.SyntaxKind.ArrayLiteralExpression:
+					val = arrayLiteralToArray(propAssignment.initializer);
+					break;
+				case ts.SyntaxKind.ObjectLiteralExpression:
+					val = objectLiteralToObjectMap(propAssignment.initializer, typeChecker, diagnostics, errorNode);
+					break;
+				case ts.SyntaxKind.StringLiteral:
+					val = propAssignment.initializer.text;
+					break;
+				case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+					val = propAssignment.initializer.text;
+					break;
+				case ts.SyntaxKind.TrueKeyword:
+					val = true;
+					break;
+				case ts.SyntaxKind.FalseKeyword:
+					val = false;
+					break;
+				case ts.SyntaxKind.Identifier:
+					const escapedText = propAssignment.initializer.escapedText;
+					if (escapedText === "String") val = String;
+					else if (escapedText === "Number") val = Number;
+					else if (escapedText === "Boolean") val = Boolean;
+					else if (escapedText === "undefined") val = void 0;
+					else if (escapedText === "null") val = null;
+					else val = getIdentifierValue(propAssignment.initializer.escapedText);
+					break;
+				case ts.SyntaxKind.PropertyAccessExpression:
+				default: val = propAssignment.initializer;
+			}
 		}
 		final[propName] = val;
 	}
@@ -1313,7 +1312,8 @@ const objectLiteralToObjectMap = (objectLiteral, typeChecker, diagnostics, error
 */
 const resolveVarInObjectLiteral = (node, typeChecker, _diagnostics, _errorNode) => {
 	if (ts.isIdentifier(node)) {
-		const symbol = typeChecker.getSymbolAtLocation(node);
+		let symbol = typeChecker.getSymbolAtLocation(node);
+		if (symbol && symbol.flags & ts.SymbolFlags.Alias) symbol = typeChecker.getAliasedSymbol(symbol);
 		if (!symbol || !symbol.valueDeclaration) throw new Error(`resolveVar() cannot resolve the value of "${node.text}" at compile time. Only const variables and object properties with string literal values are supported.`);
 		const declaration = symbol.valueDeclaration;
 		if (ts.isVariableDeclaration(declaration)) {
@@ -1403,6 +1403,14 @@ const getEntityName = (entity) => {
 	else return getEntityName(entity.left);
 };
 /**
+* Resolve a TypeScript alias to its original symbol.
+*
+* @param checker a TypeScript type checker
+* @param symbol the symbol to resolve, if one was found
+* @returns the original symbol for an alias, the provided symbol otherwise, or `undefined`
+*/
+const resolveAliasedSymbol = (checker, symbol) => symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
+/**
 * Recursively walks the provided AST to collect all TypeScript type references that are found
 *
 * @param checker a {@link ts.TypeChecker} instance
@@ -1429,6 +1437,11 @@ const getAllTypeReferences = (checker, node) => {
 					type: checker.getTypeFromTypeNode(typeRef)
 				});
 			});
+		} else if (ts.isTypeQueryNode(currentNode) && ts.isIdentifier(currentNode.exprName)) {
+			if (resolveAliasedSymbol(checker, checker.getSymbolAtLocation(currentNode.exprName))?.declarations?.some((declaration) => ts.isEnumDeclaration(declaration) || ts.isClassDeclaration(declaration))) referencedTypes.push({
+				name: getEntityName(currentNode.exprName),
+				type: checker.getTypeAtLocation(currentNode.exprName)
+			});
 		}
 		return ts.forEachChild(currentNode, visit);
 	};
@@ -1469,30 +1482,50 @@ const getTypeReferenceLocation = (typeName, type, sourceFile, checker, program)
 			const importName = importElement.name;
 			const originalTypeName = getOriginalTypeName(importName, checker);
 			const importedAs = importElement.propertyName ? importElement.propertyName.getText() : typeName;
-			const typeDecl = findTypeWithName(importHomeModule, originalTypeName);
-			type = checker.getTypeAtLocation(typeDecl);
+			const importedSymbol = resolveAliasedSymbol(checker, checker.getSymbolAtLocation(importName));
+			const declaration = importedSymbol?.valueDeclaration ?? importedSymbol?.declarations?.[0];
+			const enumOrClassDeclaration = declaration && (ts.isClassDeclaration(declaration) || ts.isEnumDeclaration(declaration)) ? declaration : void 0;
+			if (importedSymbol && enumOrClassDeclaration) type = checker.getTypeOfSymbolAtLocation(importedSymbol, enumOrClassDeclaration);
+			else {
+				const typeDecl = findTypeWithName(importHomeModule, originalTypeName);
+				if (typeDecl) type = checker.getTypeAtLocation(typeDecl);
+			}
+			const typeSourceFile = enumOrClassDeclaration?.getSourceFile() ?? importHomeModule;
 			return {
 				location: "import",
 				path: localImportPath,
-				id: addToLibrary(type, originalTypeName, checker, normalizePath(importHomeModule.fileName, false)),
+				id: addToLibrary(type, originalTypeName, checker, normalizePath(typeSourceFile.fileName, false)),
 				referenceLocation: importedAs
 			};
 		}
 	}
-	if (sourceFile.statements.some((st) => {
+	const localExport = sourceFile.statements.reduce((exportInfo, st) => {
+		if (exportInfo) return exportInfo;
+		if (ts.isExportAssignment(st) && !st.isExportEquals && ts.isIdentifier(st.expression) && st.expression.getText() === typeName) return { isDefault: true };
+		if (ts.isExportDeclaration(st) && !st.moduleSpecifier && ts.isNamedExports(st.exportClause)) {
+			const exportSpecifier = st.exportClause.elements.find((element) => (element.propertyName ?? element.name).getText() === typeName);
+			if (exportSpecifier) {
+				const exportedName = exportSpecifier.name.getText();
+				return exportedName === "default" ? { isDefault: true } : { referenceLocation: exportedName === typeName ? void 0 : exportedName };
+			}
+		}
 		const statementModifiers = retrieveTsModifiers(st);
-		const isDeclarationExported = (statement) => statement.name.getText() === typeName && Array.isArray(statementModifiers) && statementModifiers.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword);
+		const isDeclarationExported = (statement) => statement.name?.getText() === typeName && Array.isArray(statementModifiers) && statementModifiers.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword);
 		const isInterfaceDeclarationExported = ts.isInterfaceDeclaration(st) && isDeclarationExported(st);
 		const isTypeAliasDeclarationExported = ts.isTypeAliasDeclaration(st) && isDeclarationExported(st);
 		const isEnumDeclarationExported = ts.isEnumDeclaration(st) && isDeclarationExported(st);
-		const isTypeInExportDeclaration = ts.isExportDeclaration(st) && ts.isNamedExports(st.exportClause) && st.exportClause.elements.some((nee) => nee.name.getText() === typeName);
-		return isInterfaceDeclarationExported || isTypeAliasDeclarationExported || isEnumDeclarationExported || isTypeInExportDeclaration;
-	})) {
+		const isClassDeclarationExported = ts.isClassDeclaration(st) && isDeclarationExported(st);
+		if (!(isInterfaceDeclarationExported || isTypeAliasDeclarationExported || isEnumDeclarationExported || isClassDeclarationExported)) return;
+		return statementModifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) ? { isDefault: true } : {};
+	}, void 0);
+	if (localExport) {
 		const id = addToLibrary(type, typeName, checker, sourceFile.fileName);
 		return {
 			location: "local",
 			path: sourceFile.fileName,
-			id
+			id,
+			...localExport.isDefault ? { isDefault: true } : {},
+			...localExport.referenceLocation ? { referenceLocation: localExport.referenceLocation } : {}
 		};
 	}
 	const defaultImportDeclaration = sourceFile.statements.find((st) => {
@@ -1502,19 +1535,19 @@ const getTypeReferenceLocation = (typeName, type, sourceFile, checker, program)
 	});
 	if (defaultImportDeclaration) {
 		const localImportPath = defaultImportDeclaration.moduleSpecifier.text;
-		const options = program.getCompilerOptions();
-		const importHomeModule = getHomeModule(sourceFile, localImportPath, options, ts.createCompilerHost(options), program);
-		if (importHomeModule) {
-			if (importHomeModule.statements.find((st) => ts.isExportAssignment(st) && !st.isExportEquals && ts.isIdentifier(st.expression) && st.expression.getText() === typeName)) {
-				const typeDecl = findTypeWithName(importHomeModule, typeName);
-				type = checker.getTypeAtLocation(typeDecl);
-				return {
-					location: "import",
-					path: localImportPath,
-					id: addToLibrary(type, typeName, checker, normalizePath(importHomeModule.fileName, false)),
-					isDefault: true
-				};
-			}
+		const defaultImportName = defaultImportDeclaration.importClause.name;
+		const importedSymbol = resolveAliasedSymbol(checker, checker.getSymbolAtLocation(defaultImportName));
+		const declaration = importedSymbol?.valueDeclaration ?? importedSymbol?.declarations?.[0];
+		if (importedSymbol && declaration) {
+			if (ts.isClassDeclaration(declaration) || ts.isEnumDeclaration(declaration)) type = checker.getTypeOfSymbolAtLocation(importedSymbol, declaration);
+			const declarationNodeName = declaration.name;
+			const declarationName = declarationNodeName && ts.isIdentifier(declarationNodeName) ? declarationNodeName.getText() : importedSymbol.getName();
+			return {
+				location: "import",
+				path: localImportPath,
+				id: addToLibrary(type, declarationName === "default" ? typeName : declarationName, checker, normalizePath(declaration.getSourceFile().fileName, false)),
+				isDefault: true
+			};
 		}
 	}
 	return {
@@ -1559,7 +1592,8 @@ const getTypeReferenceLocation = (typeName, type, sourceFile, checker, program)
 */
 const resolveType = (checker, type, typeNode) => {
 	if (typeNode && ts.isArrayTypeNode(typeNode)) {
-		const elementResolved = resolveType(checker, checker.getTypeFromTypeNode(typeNode.elementType), typeNode.elementType);
+		const elementType = checker.getTypeFromTypeNode(typeNode.elementType);
+		const elementResolved = resolveType(checker, elementType, typeNode.elementType);
 		return elementResolved.includes(" | ") ? `(${elementResolved})[]` : `${elementResolved}[]`;
 	}
 	const set = /* @__PURE__ */ new Set();
@@ -1613,13 +1647,18 @@ const parseDocsType = (checker, type, parts) => {
 			const elemStr = sortedParts.join(" | ");
 			parts.add(sortedParts.length > 1 ? `(${elemStr})[]` : `${elemStr}[]`);
 		} else parts.add(typeToString(checker, type));
-	} else if (type.aliasSymbol) if (type.aliasTypeArguments && type.aliasTypeArguments.length > 0) type.aliasTypeArguments.forEach((argType) => {
-		parseDocsType(checker, argType, parts);
-	});
-	else if (type.aliasSymbol.declarations && type.aliasSymbol.declarations.length > 0) {
-		const aliasedType = checker.getTypeAtLocation(type.aliasSymbol.declarations[0]);
-		if (aliasedType && aliasedType !== type) parseDocsType(checker, aliasedType, parts);
-		else {
+	} else if (type.aliasSymbol) {
+		if (type.aliasTypeArguments && type.aliasTypeArguments.length > 0) type.aliasTypeArguments.forEach((argType) => {
+			parseDocsType(checker, argType, parts);
+		});
+		else if (type.aliasSymbol.declarations && type.aliasSymbol.declarations.length > 0) {
+			const aliasedType = checker.getTypeAtLocation(type.aliasSymbol.declarations[0]);
+			if (aliasedType && aliasedType !== type) parseDocsType(checker, aliasedType, parts);
+			else {
+				const text = typeToString(checker, type);
+				parts.add(text);
+			}
+		} else {
 			const text = typeToString(checker, type);
 			parts.add(text);
 		}
@@ -1627,10 +1666,6 @@ const parseDocsType = (checker, type, parts) => {
 		const text = typeToString(checker, type);
 		parts.add(text);
 	}
-	else {
-		const text = typeToString(checker, type);
-		parts.add(text);
-	}
 };
 /**
 * Retrieves a Stencil `Module` entity from the compiler context for a given TypeScript `SourceFile`
@@ -1658,7 +1693,8 @@ const getComponentMeta = (compilerCtx, tsSourceFile, node) => {
 	if (meta) return meta;
 	const moduleFile = getModuleFromSourceFile(compilerCtx, tsSourceFile);
 	if (moduleFile != null && node.members != null) {
-		const tagName = getComponentTagName(node.members.filter(isStaticGetter));
+		const staticMembers = node.members.filter(isStaticGetter);
+		const tagName = getComponentTagName(staticMembers);
 		if (typeof tagName === "string") return moduleFile.cmps.find((cmp) => cmp.tagName === tagName);
 	}
 };
@@ -2100,7 +2136,8 @@ const generateAppDataModule = (build, config) => {
 	return `export const BUILD = ${JSON.stringify(build, null, 2)};\nexport const Env = ${JSON.stringify(config.env ?? {})};\nexport const NAMESPACE = ${JSON.stringify(config.fsNamespace)};\n`;
 };
 const serializeCollectionManifest = (config, compilerCtx, buildCtx) => {
-	const buildFlags = getBuildFeatures(buildCtx.moduleFiles.filter((mod) => !mod.isCollectionDependency).flatMap((mod) => mod.cmps));
+	const localCmps = buildCtx.moduleFiles.filter((mod) => !mod.isCollectionDependency).flatMap((mod) => mod.cmps);
+	const buildFlags = getBuildFeatures(localCmps);
 	buildFlags.hydrateClientSide = config.outputTargets.some(isOutputTargetSsr);
 	const ldp = config.compat?.lightDomPatches ?? true;
 	if (buildFlags.slotRelocation && ldp !== false) {
@@ -2146,10 +2183,11 @@ const serializeCollectionManifest = (config, compilerCtx, buildCtx) => {
 	return collectionManifest;
 };
 const serializeCollectionDependencies = (compilerCtx) => {
-	return sortBy(compilerCtx.collections.map((c) => ({
+	const collectionDeps = compilerCtx.collections.map((c) => ({
 		name: c.collectionName,
 		tags: flatOne(c.moduleFiles.map((m) => m.cmps)).map((cmp) => cmp.tagName).sort()
-	})), (item) => item.name);
+	}));
+	return sortBy(collectionDeps, (item) => item.name);
 };
 //#endregion
 //#region src/compiler/output-targets/copy/local-copy-tasks.ts
@@ -2158,8 +2196,10 @@ const getSrcAbsPath = (config, src) => {
 	return join$2(config.srcDir, src);
 };
 const getDestAbsPath = (src, destAbsPath, destRelPath) => {
-	if (destRelPath) if (isAbsolute$1(destRelPath)) return destRelPath;
-	else return join$2(destAbsPath, destRelPath);
+	if (destRelPath) {
+		if (isAbsolute$1(destRelPath)) return destRelPath;
+		else return join$2(destAbsPath, destRelPath);
+	}
 	if (isAbsolute$1(src)) throw new Error(`copy task, "dest" property must exist if "src" property is an absolute path: ${src}`);
 	return destAbsPath;
 };
@@ -2353,6 +2393,7 @@ const setPackageVersionByContent = (pkgVersions, pkgContent) => {
 		if (pkg.name && pkg.version) setPackageVersion(pkgVersions, pkg.name, pkg.version);
 	} catch {}
 };
+const isNodeModulePath = (p) => normalizePath(p).split("/").includes("node_modules");
 const getModuleId = (orgImport) => {
 	if (orgImport.startsWith("~")) orgImport = orgImport.substring(1);
 	const splt = orgImport.split("/");
@@ -2444,6 +2485,54 @@ const createCustomResolverAsync = (sys, inMemoryFs, exts) => {
 //#endregion
 //#region src/compiler/style/style-utils.ts
 /**
+* Wrap CSS content according to the modifiers trailing an `@import` specifier
+* (`layer(name)`, `supports(condition)`, and/or a media query), mirroring what
+* `@import url(...) layer(name) supports(condition) (media);` would do natively.
+*
+* @param cssText the CSS content to wrap
+* @param modifiers the raw modifier string following the import specifier, if any
+* @returns cssText wrapped in @layer/@media/@supports blocks as needed
+*/
+const wrapCssWithImportModifiers = (cssText, modifiers) => {
+	if (!modifiers?.trim()) return cssText;
+	let remaining = modifiers.trim();
+	let replacement = cssText;
+	let layerName = "";
+	let supportsCondition = "";
+	const layerMatch = remaining.match(/layer\(([^)]+)\)/);
+	if (layerMatch) {
+		layerName = layerMatch[1].trim();
+		remaining = remaining.replace(/layer\([^)]+\)/, "").trim();
+	}
+	let depth = 0;
+	let startIdx = -1;
+	let endIdx = -1;
+	const supportsIdx = remaining.indexOf("supports(");
+	if (supportsIdx !== -1) {
+		startIdx = supportsIdx + 9;
+		for (let i = startIdx; i < remaining.length; i++) {
+			if (remaining[i] === "(") depth++;
+			if (remaining[i] === ")") {
+				if (depth === 0) {
+					endIdx = i;
+					break;
+				}
+				depth--;
+			}
+		}
+		if (endIdx !== -1) {
+			supportsCondition = remaining.substring(startIdx, endIdx).trim();
+			remaining = remaining.substring(0, supportsIdx) + remaining.substring(endIdx + 1);
+			remaining = remaining.trim();
+		}
+	}
+	const mediaQuery = remaining.trim();
+	if (layerName) replacement = `@layer ${layerName} {\n${replacement}\n}`;
+	if (mediaQuery) replacement = `@media ${mediaQuery} {\n${replacement}\n}`;
+	if (supportsCondition) replacement = `@supports (${supportsCondition}) {\n${replacement}\n}`;
+	return replacement;
+};
+/**
 * Strip out comments from some CSS
 *
 * @param input the string we'd like to de-comment
@@ -2583,7 +2672,8 @@ const getCssImports = async (config, compilerCtx, buildCtx, filePath, styleText)
 			cssImportData.filePath += `.${importeeExt}`;
 			if (importeeExt === "scss") {
 				const fileName = "_" + basename$1(cssImportData.filePath);
-				cssImportData.altFilePath = normalizePath(join$2(dirname$1(cssImportData.filePath), fileName));
+				const dirPath = dirname$1(cssImportData.filePath);
+				cssImportData.altFilePath = normalizePath(join$2(dirPath, fileName));
 			}
 		}
 		if (cssImportData.filePath !== "") imports.push(cssImportData);
@@ -2634,44 +2724,7 @@ const isLocalCssImport$1 = (srcImport) => {
 const replaceImportDeclarations = (styleText, cssImports, isCssEntry) => {
 	for (const cssImport of cssImports) if (isCssEntry) {
 		if (typeof cssImport.styleText === "string") {
-			let replacement = cssImport.styleText;
-			if (cssImport.modifiers) {
-				let modifiers = cssImport.modifiers;
-				let layerName = "";
-				let supportsCondition = "";
-				let mediaQuery = "";
-				const layerMatch = modifiers.match(/layer\(([^)]+)\)/);
-				if (layerMatch) {
-					layerName = layerMatch[1].trim();
-					modifiers = modifiers.replace(/layer\([^)]+\)/, "").trim();
-				}
-				let depth = 0;
-				let startIdx = -1;
-				let endIdx = -1;
-				const supportsIdx = modifiers.indexOf("supports(");
-				if (supportsIdx !== -1) {
-					startIdx = supportsIdx + 9;
-					for (let i = startIdx; i < modifiers.length; i++) {
-						if (modifiers[i] === "(") depth++;
-						if (modifiers[i] === ")") {
-							if (depth === 0) {
-								endIdx = i;
-								break;
-							}
-							depth--;
-						}
-					}
-					if (endIdx !== -1) {
-						supportsCondition = modifiers.substring(startIdx, endIdx).trim();
-						modifiers = modifiers.substring(0, supportsIdx) + modifiers.substring(endIdx + 1);
-						modifiers = modifiers.trim();
-					}
-				}
-				mediaQuery = modifiers.trim();
-				if (layerName) replacement = `@layer ${layerName} {\n${replacement}\n}`;
-				if (mediaQuery) replacement = `@media ${mediaQuery} {\n${replacement}\n}`;
-				if (supportsCondition) replacement = `@supports (${supportsCondition}) {\n${replacement}\n}`;
-			}
+			const replacement = wrapCssWithImportModifiers(cssImport.styleText, cssImport.modifiers);
 			styleText = styleText.replace(cssImport.srcImport, replacement);
 		}
 	} else if (typeof cssImport.updatedImport === "string") styleText = styleText.replace(cssImport.srcImport, cssImport.updatedImport);
@@ -2725,7 +2778,8 @@ const runPluginTransforms = async (config, compilerCtx, buildCtx, id, cmp) => {
 		cache: compilerCtx.cache,
 		diagnostics: []
 	};
-	const sourceText = await runPluginLoad(pluginCtx, await runPluginResolveId(pluginCtx, id));
+	const resolvedId = await runPluginResolveId(pluginCtx, id);
+	const sourceText = await runPluginLoad(pluginCtx, resolvedId);
 	if (!isString$1(sourceText)) {
 		const diagnostic = buildError(buildCtx.diagnostics);
 		diagnostic.header = `Unable to find "${basename$1(id)}"`;
@@ -2739,15 +2793,17 @@ const runPluginTransforms = async (config, compilerCtx, buildCtx, id, cmp) => {
 	};
 	const isRawCssFile = transformResults.id.toLowerCase().endsWith(".css");
 	const shouldParseCssDocs = cmp != null && config.outputTargets.some(isOutputTargetDocs);
-	if (isRawCssFile) if (shouldParseCssDocs && cmp != null) {
-		cmp.styleDocs = cmp.styleDocs || [];
-		const cssParseResults = await parseCssImports(config, compilerCtx, buildCtx, id, id, transformResults.code, cmp.styleDocs);
-		transformResults.code = cssParseResults.styleText;
-		transformResults.dependencies = cssParseResults.imports;
-	} else {
-		const cssParseResults = await parseCssImports(config, compilerCtx, buildCtx, id, id, transformResults.code);
-		transformResults.code = cssParseResults.styleText;
-		transformResults.dependencies = cssParseResults.imports;
+	if (isRawCssFile) {
+		if (shouldParseCssDocs && cmp != null) {
+			cmp.styleDocs = cmp.styleDocs || [];
+			const cssParseResults = await parseCssImports(config, compilerCtx, buildCtx, id, id, transformResults.code, cmp.styleDocs);
+			transformResults.code = cssParseResults.styleText;
+			transformResults.dependencies = cssParseResults.imports;
+		} else {
+			const cssParseResults = await parseCssImports(config, compilerCtx, buildCtx, id, id, transformResults.code);
+			transformResults.code = cssParseResults.styleText;
+			transformResults.dependencies = cssParseResults.imports;
+		}
 	}
 	for (const plugin of pluginCtx.config?.plugins ?? []) if (isFunction(plugin.transform)) try {
 		let pluginTransformResults;
@@ -2755,29 +2811,33 @@ const runPluginTransforms = async (config, compilerCtx, buildCtx, id, cmp) => {
 		if (results != null) {
 			if (isFunction(results.then)) pluginTransformResults = await results;
 			else pluginTransformResults = results;
-			if (pluginTransformResults != null) if (isString$1(pluginTransformResults)) transformResults.code = pluginTransformResults;
-			else {
-				if (isString$1(pluginTransformResults.code)) transformResults.code = pluginTransformResults.code;
-				if (isString$1(pluginTransformResults.id)) transformResults.id = pluginTransformResults.id;
-				/**
-				* add dependencies from plugin transform results, e.g. transformed sass files
-				*/
-				transformResults.dependencies.push(...getDependencySubset(pluginTransformResults.dependencies, transformResults.dependencies));
+			if (pluginTransformResults != null) {
+				if (isString$1(pluginTransformResults)) transformResults.code = pluginTransformResults;
+				else {
+					if (isString$1(pluginTransformResults.code)) transformResults.code = pluginTransformResults.code;
+					if (isString$1(pluginTransformResults.id)) transformResults.id = pluginTransformResults.id;
+					/**
+					* add dependencies from plugin transform results, e.g. transformed sass files
+					*/
+					transformResults.dependencies.push(...getDependencySubset(pluginTransformResults.dependencies, transformResults.dependencies));
+				}
 			}
 		}
 	} catch (e) {
 		catchError(buildCtx.diagnostics, e);
 	}
 	buildCtx.diagnostics.push(...pluginCtx.diagnostics);
-	if (!isRawCssFile) if (shouldParseCssDocs && cmp != null) {
-		cmp.styleDocs = cmp.styleDocs || [];
-		const cssParseResults = await parseCssImports(config, compilerCtx, buildCtx, id, transformResults.id, transformResults.code, cmp.styleDocs);
-		transformResults.code = cssParseResults.styleText;
-		transformResults.dependencies.push(...getDependencySubset(cssParseResults.imports, transformResults.dependencies));
-	} else {
-		const cssParseResults = await parseCssImports(config, compilerCtx, buildCtx, id, transformResults.id, transformResults.code);
-		transformResults.code = cssParseResults.styleText;
-		transformResults.dependencies.push(...getDependencySubset(cssParseResults.imports, transformResults.dependencies));
+	if (!isRawCssFile) {
+		if (shouldParseCssDocs && cmp != null) {
+			cmp.styleDocs = cmp.styleDocs || [];
+			const cssParseResults = await parseCssImports(config, compilerCtx, buildCtx, id, transformResults.id, transformResults.code, cmp.styleDocs);
+			transformResults.code = cssParseResults.styleText;
+			transformResults.dependencies.push(...getDependencySubset(cssParseResults.imports, transformResults.dependencies));
+		} else {
+			const cssParseResults = await parseCssImports(config, compilerCtx, buildCtx, id, transformResults.id, transformResults.code);
+			transformResults.code = cssParseResults.styleText;
+			transformResults.dependencies.push(...getDependencySubset(cssParseResults.imports, transformResults.dependencies));
+		}
 	}
 	return transformResults;
 };
@@ -2808,13 +2868,15 @@ const runPluginTransformsEsmImports = async (config, compilerCtx, buildCtx, code
 		if (results != null) {
 			if (isFunction(results.then)) pluginTransformResults = await results;
 			else pluginTransformResults = results;
-			if (pluginTransformResults != null) if (isString$1(pluginTransformResults)) transformResults.code = pluginTransformResults;
-			else {
-				if (isString$1(pluginTransformResults.code)) transformResults.code = pluginTransformResults.code;
-				if (isString$1(pluginTransformResults.id)) transformResults.id = pluginTransformResults.id;
-				if (Array.isArray(pluginTransformResults.dependencies)) {
-					const imports = pluginTransformResults.dependencies.filter((f) => !transformResults.dependencies.includes(f));
-					transformResults.dependencies.push(...imports);
+			if (pluginTransformResults != null) {
+				if (isString$1(pluginTransformResults)) transformResults.code = pluginTransformResults;
+				else {
+					if (isString$1(pluginTransformResults.code)) transformResults.code = pluginTransformResults.code;
+					if (isString$1(pluginTransformResults.id)) transformResults.id = pluginTransformResults.id;
+					if (Array.isArray(pluginTransformResults.dependencies)) {
+						const imports = pluginTransformResults.dependencies.filter((f) => !transformResults.dependencies.includes(f));
+						transformResults.dependencies.push(...imports);
+					}
 				}
 			}
 		}
@@ -2860,8 +2922,8 @@ const optimizeCss$1 = async (config, compilerCtx, diagnostics, styleText, filePa
 };
 //#endregion
 //#region src/compiler/style/component-global-styles.ts
-const STENCIL_GLOBALS_RE = /@import\s+(?:url\()?\s*['"]stencil-globals['"]\s*\)?\s*;?/g;
-const STENCIL_HYDRATE_RE = /@import\s+(?:url\()?\s*['"]stencil-hydrate['"]\s*\)?\s*;?/g;
+const STENCIL_GLOBALS_RE = /@import\s+(?:url\()?\s*['"]stencil-globals['"]\s*\)?([^;]*);?/g;
+const STENCIL_HYDRATE_RE = /@import\s+(?:url\()?\s*['"]stencil-hydrate['"]\s*\)?([^;]*);?/g;
 const hasStencilGlobalsImport = (css) => css.includes("stencil-globals");
 const hasStencilHydrateImport = (css) => css.includes("stencil-hydrate");
 /**
@@ -2884,12 +2946,16 @@ const generateHydrateCss = (config, buildCtx) => {
 };
 /**
 * Replace `@import "stencil-hydrate"` in CSS with the generated FOUC-prevention styles.
+* Supports trailing `layer()`/`supports()`/media modifiers, e.g. `@import "stencil-hydrate" layer(init);`.
 * @param css the CSS string to process
 * @param config the Stencil configuration
 * @param buildCtx the current build context, used to get the list of components in the build
 * @returns the CSS string with `@import "stencil-hydrate"` replaced by generated styles
 */
-const resolveStencilHydrateImport = (css, config, buildCtx) => css.replace(STENCIL_HYDRATE_RE, generateHydrateCss(config, buildCtx));
+const resolveStencilHydrateImport = (css, config, buildCtx) => {
+	const hydrateCss = generateHydrateCss(config, buildCtx);
+	return css.replace(STENCIL_HYDRATE_RE, (_match, modifiers) => wrapCssWithImportModifiers(hydrateCss, modifiers));
+};
 /**
 * Collect and build all component-level globalStyle/globalStyleUrl CSS from the current build.
 * Results are cached per file path via the existing globalStyleCache.
@@ -2927,6 +2993,7 @@ const collectAndBuildComponentGlobalStyles = async (config, compilerCtx, buildCt
 * Replace `@import "stencil-globals"` in CSS with the collected component global styles.
 * Also registers component global style files as cssModuleImports of the global stylesheet
 * so the build cache is properly invalidated when those files change.
+* Supports trailing `layer()`/`supports()`/media modifiers, e.g. `@import "stencil-globals" layer(init);`.
 *
 * @param css the CSS string to process
 * @param config the Stencil configuration
@@ -2943,7 +3010,7 @@ const resolveStencilGlobalsImport = async (css, config, compilerCtx, buildCtx, g
 		for (const p of filePaths) if (!existing.includes(p)) existing.push(p);
 		compilerCtx.cssModuleImports.set(globalStyleInputPath, existing);
 	}
-	return css.replace(STENCIL_GLOBALS_RE, collectedCss);
+	return css.replace(STENCIL_GLOBALS_RE, (_match, modifiers) => wrapCssWithImportModifiers(collectedCss, modifiers));
 };
 //#endregion
 //#region src/compiler/style/global-styles.ts
@@ -3464,7 +3531,8 @@ const getStencilInternalModule = (config, compilerExe, internalModule) => {
 		moduleId: "@stencil/core",
 		path: "runtime/" + internalModule
 	}));
-	return normalizePath(join$2(dirname$1(compilerExe), "..", "runtime", internalModule));
+	const compilerExeDir = dirname$1(compilerExe);
+	return normalizePath(join$2(compilerExeDir, "..", "runtime", internalModule));
 };
 const getHydratedFlagHead = (h) => {
 	let initial;
@@ -3516,7 +3584,8 @@ const getPackageJsonPath = (resolvedPath, importee) => {
 	for (let i = 0; i < 10; i++) {
 		currentPath = dirname$1(currentPath);
 		const aBasename = basename$1(currentPath);
-		const bBasename = basename$1(dirname$1(currentPath));
+		const upDir = dirname$1(currentPath);
+		const bBasename = basename$1(upDir);
 		if (aBasename === importee && bBasename === "node_modules") return join$2(currentPath, "package.json");
 	}
 	return null;
@@ -3565,7 +3634,7 @@ const FORMAT_TEXT_EXTS = [
 	"vert"
 ];
 const FORMAT_URL_MIME = { svg: "image/svg+xml" };
-const DATAURL_MAX_IMAGE_SIZE = 4 * 1024;
+const DATAURL_MAX_IMAGE_SIZE = 4096;
 const formatText = (code, filePath) => {
 	const varName = createJsVarName(basename$1(filePath));
 	return `const ${varName} = ${JSON.stringify(code)};export default ${varName};`;
@@ -3663,6 +3732,7 @@ const parseImportPath = (importPath) => {
 				encapsulation: urlParams.get("encapsulation") || "none",
 				mode: urlParams.get("mode") || "$"
 			};
+			else if (urlParams.has("stencil") && parsedPath.basename.endsWith(".css")) parsedPath.data = { encapsulation: "none" };
 		} else if (parsedPath.basename.endsWith(".css")) parsedPath.data = { encapsulation: "none" };
 	}
 	return parsedPath;
@@ -3902,7 +3972,7 @@ const loaderPlugin = (entries = {}) => {
 };
 //#endregion
 //#region src/compiler/bundle/plugin-helper.ts
-const builtIns = new Set([
+const builtIns = /* @__PURE__ */ new Set([
 	"child_process",
 	"cluster",
 	"dgram",
@@ -4059,6 +4129,7 @@ const createModule = (staticSourceFile, staticSourceFileText, emitFilepath) => (
 	hasSignalsImport: false,
 	htmlAttrNames: [],
 	htmlParts: [],
+	htmlSlots: [],
 	htmlTagNames: [],
 	isCollectionDependency: false,
 	isLegacy: false,
@@ -4096,7 +4167,8 @@ const typescriptPlugin = (compilerCtx, bundleOpts, config) => {
 		*/
 		load(id) {
 			if (isAbsolute$1(id)) {
-				const module = getModule(compilerCtx, normalizeFsPath(id));
+				const fsFilePath = normalizeFsPath(id);
+				const module = getModule(compilerCtx, fsFilePath);
 				if (module) {
 					if (!module.sourceMapFileText) return {
 						code: module.staticSourceFileText,
@@ -4278,7 +4350,7 @@ const loadMinifyJsDiagnostics = (sourceText, diagnostics, error) => {
 	}
 	diagnostics.push(d);
 };
-const MINIFY_CHAR_BREAK = new Set([
+const MINIFY_CHAR_BREAK = /* @__PURE__ */ new Set([
 	" ",
 	"=",
 	".",
@@ -4500,16 +4572,18 @@ const workerPlugin = (config, compilerCtx, buildCtx, platform, inlineWorkers) =>
 				const workerEntryPath = getWorkerEntryPath(id);
 				if (workerEntryPath != null) {
 					const worker = await getWorker(config, compilerCtx, buildCtx, this, workersMap, workerEntryPath);
-					if (worker) if (inlineWorkers) return {
-						code: getInlineWorkerProxy(workerEntryPath, worker.workerMsgId, worker.exports),
-						map: { mappings: "" },
-						moduleSideEffects: false
-					};
-					else return {
-						code: getWorkerProxy(workerEntryPath, worker.exports),
-						map: { mappings: "" },
-						moduleSideEffects: false
-					};
+					if (worker) {
+						if (inlineWorkers) return {
+							code: getInlineWorkerProxy(workerEntryPath, worker.workerMsgId, worker.exports),
+							map: { mappings: "" },
+							moduleSideEffects: false
+						};
+						else return {
+							code: getWorkerProxy(workerEntryPath, worker.exports),
+							map: { mappings: "" },
+							moduleSideEffects: false
+						};
+					}
 				}
 				return null;
 			}
@@ -4808,7 +4882,8 @@ ${exportedMethods.map((exportedMethod) => {
 //#region src/compiler/bundle/bundle-output.ts
 const bundleOutput = async (config, compilerCtx, buildCtx, bundleOpts) => {
 	try {
-		return await rolldown(getRolldownOptions(config, compilerCtx, buildCtx, bundleOpts));
+		const rolldownOptions = getRolldownOptions(config, compilerCtx, buildCtx, bundleOpts);
+		return await rolldown(rolldownOptions);
 	} catch (e) {
 		if (!buildCtx.hasError && isRolldownError(e)) loadRolldownDiagnostics(config, compilerCtx, buildCtx, e);
 	}
@@ -5433,13 +5508,14 @@ const updateCjsStyleRequires = (transformOpts, tsSourceFile, moduleFile) => {
 	return tsSourceFile;
 };
 const getStyleImportPath = (transformOpts, tsSourceFile, cmp, style, importPath) => {
-	return serializeImportPath({
+	const importData = {
 		importeePath: importPath,
 		importerPath: tsSourceFile.fileName,
 		tag: cmp.tagName,
 		encapsulation: cmp.encapsulation,
 		mode: style.modeName
-	}, transformOpts.styleImportData);
+	};
+	return serializeImportPath(importData, transformOpts.styleImportData);
 };
 //#endregion
 //#region src/compiler/transformers/add-static-style.ts
@@ -5479,8 +5555,10 @@ const addStaticStylePropertyToClass = (styleStatements, cmp, buildCtx) => {
 	}
 };
 const getStyleLiteral = (cmp, buildCtx) => {
-	if (Array.isArray(cmp.styles) && cmp.styles.length > 0) if (cmp.styles.length > 1 || cmp.styles.length === 1 && cmp.styles[0].modeName !== "$") return getMultipleModeStyle(cmp, cmp.styles, buildCtx);
-	else return getSingleStyle(cmp, cmp.styles[0], buildCtx);
+	if (Array.isArray(cmp.styles) && cmp.styles.length > 0) {
+		if (cmp.styles.length > 1 || cmp.styles.length === 1 && cmp.styles[0].modeName !== "$") return getMultipleModeStyle(cmp, cmp.styles, buildCtx);
+		else return getSingleStyle(cmp, cmp.styles[0], buildCtx);
+	}
 	return null;
 };
 const getMultipleModeStyle = (cmp, styles, buildCtx) => {
@@ -5902,30 +5980,31 @@ const updateStencilCoreImports = (updatedCoreImportPath) => {
 /**
 * A set of imports which we don't want to remove from an output file
 */
-const KEEP_IMPORTS = new Set([
-	"h",
-	"setMode",
-	"getMode",
-	"setPlatformHelpers",
+const KEEP_IMPORTS = /* @__PURE__ */ new Set([
 	"Build",
 	"Env",
-	"Host",
 	"Fragment",
+	"Host",
+	"Mixin",
+	"ReactiveControllerHost",
+	"forceUpdate",
+	"forceModeUpdate",
 	"getAssetPath",
-	"writeTask",
-	"readTask",
 	"getElement",
-	"getShadowRoot",
-	"forceUpdate",
+	"getMode",
 	"getRenderingRef",
-	"forceModeUpdate",
+	"getShadowRoot",
+	"h",
+	"jsx",
+	"jsxs",
+	"readTask",
+	"render",
 	"setErrorHandler",
+	"setMode",
+	"setPlatformHelpers",
 	"setTagTransformer",
 	"transformTag",
-	"Mixin",
-	"jsx",
-	"jsxs",
-	"render"
+	"writeTask"
 ]);
 //#endregion
 //#region src/compiler/app-core/bundle-app-core.ts
@@ -6109,7 +6188,8 @@ const writeLazyChunk = async (config, compilerCtx, buildCtx, rolldownResult, out
 };
 const writeLazyEntry = async (config, compilerCtx, buildCtx, rolldownResult, outputTargetType, destinations, lazyRuntimeData, sourceTarget, shouldMinify, isBrowserBuild) => {
 	if (isBrowserBuild && ["loader"].includes(rolldownResult.entryKey)) return;
-	const { code, sourceMap } = await convertChunk(config, compilerCtx, buildCtx, sourceTarget, shouldMinify, false, isBrowserBuild, rolldownResult.code.replace(`["__STENCIL_LAZY_DATA__"]`, `${lazyRuntimeData}`), rolldownResult.map);
+	const inputCode = rolldownResult.code.replace(`["__STENCIL_LAZY_DATA__"]`, `${lazyRuntimeData}`);
+	const { code, sourceMap } = await convertChunk(config, compilerCtx, buildCtx, sourceTarget, shouldMinify, false, isBrowserBuild, inputCode, rolldownResult.map);
 	await Promise.all(destinations.map((dst) => {
 		const filePath = join$2(dst, rolldownResult.fileName);
 		let fileCode = code;
@@ -6129,7 +6209,8 @@ const writeLazyEntry = async (config, compilerCtx, buildCtx, rolldownResult, out
 * @returns A stringified representation of the lazy bundles.
 */
 const formatLazyBundlesRuntimeMeta = (bundleModules) => {
-	return stringifyRuntimeData(bundleModules.slice().sort(sortBundleModules).map(formatLazyRuntimeBundle));
+	const lazyBundles = bundleModules.slice().sort(sortBundleModules).map(formatLazyRuntimeBundle);
+	return stringifyRuntimeData(lazyBundles);
 };
 /**
 * Formats a bundle module into a tuple of bundle ID and component metadata for use at runtime.
@@ -6305,7 +6386,8 @@ const generateCjs = async (config, compilerCtx, buildCtx, rolldownBuild, outputT
 		if (config.compat.enableImportInjection) esmOpts.dynamicImportInCjs = false;
 		const results = await generateRolldownOutput(rolldownBuild, esmOpts, config, buildCtx.entryModules);
 		if (results != null) {
-			buildCtx.commonJsComponentBundle = await generateLazyModules(config, compilerCtx, buildCtx, outputTargetType, cjsOutputs.map((o) => o.cjsDir).filter((cjsDir) => typeof cjsDir === "string"), results, "es2017", false);
+			const destinations = cjsOutputs.map((o) => o.cjsDir).filter((cjsDir) => typeof cjsDir === "string");
+			buildCtx.commonJsComponentBundle = await generateLazyModules(config, compilerCtx, buildCtx, outputTargetType, destinations, results, "es2017", false);
 			await generateShortcuts$1(compilerCtx, results, cjsOutputs);
 		}
 	}
@@ -6340,7 +6422,8 @@ const generateEsm = async (config, compilerCtx, buildCtx, rolldownBuild, outputT
 		const outputTargetType = esmOutputs[0].type;
 		const output = await generateRolldownOutput(rolldownBuild, esmOpts, config, buildCtx.entryModules);
 		if (output != null) {
-			buildCtx.esmComponentBundle = await generateLazyModules(config, compilerCtx, buildCtx, outputTargetType, esmOutputs.map((o) => o.esmDir).filter((esmDir) => typeof esmDir === "string"), output, "es2017", false);
+			const es2017destinations = esmOutputs.map((o) => o.esmDir).filter((esmDir) => typeof esmDir === "string");
+			buildCtx.esmComponentBundle = await generateLazyModules(config, compilerCtx, buildCtx, outputTargetType, es2017destinations, output, "es2017", false);
 			await generateShortcuts(compilerCtx, outputTargets, output);
 		}
 	}
@@ -6365,7 +6448,7 @@ const generateEsmBrowser = async (config, compilerCtx, buildCtx, rolldownBuild,
 	const esmOutputs = outputTargets.filter((o) => !!o.esmDir && !!o.isBrowserBuild);
 	if (esmOutputs.length) {
 		const outputTargetType = esmOutputs[0].type;
-		const output = await generateRolldownOutput(rolldownBuild, {
+		const esmOpts = {
 			banner: generatePreamble(config),
 			format: "es",
 			entryFileNames: "[name].js",
@@ -6373,7 +6456,8 @@ const generateEsmBrowser = async (config, compilerCtx, buildCtx, rolldownBuild,
 			assetFileNames: esmOutputs[0].hashFileNames ? "p-[hash][extname]" : "[name]-[hash][extname]",
 			sourcemap: config.sourceMap,
 			plugins: [lazyBundleIdPlugin(buildCtx, config, esmOutputs[0].hashFileNames ?? true, esmOutputs[0].hashedFileNameLength ?? 8, "", true)]
-		}, config, buildCtx.entryModules);
+		};
+		const output = await generateRolldownOutput(rolldownBuild, esmOpts, config, buildCtx.entryModules);
 		if (output != null) {
 			const es2017destinations = esmOutputs.map((o) => o.esmDir).filter((esmDir) => typeof esmDir === "string");
 			buildCtx.esmBrowserComponentBundle = await generateLazyModules(config, compilerCtx, buildCtx, outputTargetType, es2017destinations, output, "es2017", true);
@@ -6416,15 +6500,18 @@ const generateLoader = async (compilerCtx, outputTargets) => {
 	await Promise.all(outputTargets.map(async (o) => {
 		if (!o.loaderDir || !o.esmDir || !o.typesDir) return;
 		const loaderIndexJs = join$2(o.loaderDir, "index.js");
-		const relativeEsmLoader = relativeImport(loaderIndexJs, join$2(o.esmDir, "loader.js"));
+		const esmLoaderPath = join$2(o.esmDir, "loader.js");
+		const relativeEsmLoader = relativeImport(loaderIndexJs, esmLoaderPath);
 		await compilerCtx.fs.writeFile(loaderIndexJs, `export * from '${relativeEsmLoader}';\n`, { outputTargetType: o.type });
 		if (o.cjsDir) {
 			const loaderIndexCjs = join$2(o.loaderDir, "index.cjs");
-			const relativeCjsLoader = relativeImport(loaderIndexCjs, join$2(o.cjsDir, "loader.cjs"));
+			const cjsLoaderPath = join$2(o.cjsDir, "loader.cjs");
+			const relativeCjsLoader = relativeImport(loaderIndexCjs, cjsLoaderPath);
 			await compilerCtx.fs.writeFile(loaderIndexCjs, `module.exports = require('${relativeCjsLoader}');\n`, { outputTargetType: o.type });
 		}
 		const loaderIndexDts = join$2(o.loaderDir, "index.d.ts");
-		const relativeDtsPath = relativeImport(loaderIndexDts, join$2(o.typesDir, "loader.d.ts"));
+		const loaderDtsPath = join$2(o.typesDir, "loader.d.ts");
+		const relativeDtsPath = relativeImport(loaderIndexDts, loaderDtsPath);
 		await compilerCtx.fs.writeFile(loaderIndexDts, `export * from '${relativeDtsPath}';\n`, { outputTargetType: o.type });
 	}));
 };
@@ -6647,7 +6734,8 @@ const canSkipAssetsCopy = (compilerCtx, entryModules, filesChanged) => {
 		entryModules.forEach((entryModule) => {
 			entryModule.cmps.forEach((cmp) => {
 				if (cmp.assetsDirs != null) cmp.assetsDirs.forEach((assetsDir) => {
-					if (changedFileDirPath === normalizePath(assetsDir.absolutePath)) {
+					const assetDirPath = normalizePath(assetsDir.absolutePath);
+					if (changedFileDirPath === assetDirPath) {
 						shouldSkipAssetsCopy = false;
 						return;
 					}
@@ -6683,7 +6771,8 @@ const outputAssets = async (config, compilerCtx, buildCtx) => {
 		allCopyTasks.push(...copyTasks);
 	}
 	for (const wwwTarget of wwwTargets) {
-		const copyTasks = getComponentAssetsCopyTasks(config, buildCtx, join$2(wwwTarget.buildDir, "assets"), false);
+		const wwwAssetsDir = join$2(wwwTarget.buildDir, "assets");
+		const copyTasks = getComponentAssetsCopyTasks(config, buildCtx, wwwAssetsDir, false);
 		allCopyTasks.push(...copyTasks);
 	}
 	if (allCopyTasks.length > 0) {
@@ -6912,6 +7001,7 @@ const generateDocData = async (config, compilerCtx, buildCtx) => {
 			typescriptVersion: versions.typescript
 		},
 		components: await getDocsComponents(config, compilerCtx, buildCtx),
+		usage: await generateUsages(compilerCtx, normalizePath(join$2(config.srcDir, "usage"))),
 		typeLibrary
 	};
 };
@@ -6934,7 +7024,7 @@ function findSupplementalPublicTypes(outputTargets) {
 * @returns the derived metadata
 */
 const getDocsComponents = async (config, compilerCtx, buildCtx) => {
-	return sortBy(flatOne(await Promise.all(buildCtx.moduleFiles.map(async (moduleFile) => {
+	const results = await Promise.all(buildCtx.moduleFiles.map(async (moduleFile) => {
 		const filePath = moduleFile.sourceFilePath;
 		const dirPath = normalizePath(dirname$1(filePath));
 		const readmePath = normalizePath(join$2(dirPath, "readme.md"));
@@ -6962,12 +7052,13 @@ const getDocsComponents = async (config, compilerCtx, buildCtx) => {
 			methods: getDocsMethods(cmp.methods),
 			events: getDocsEvents(cmp.events),
 			styles: getDocsStyles(cmp),
-			slots: getDocsSlots(cmp.docs.tags),
+			slots: getDocsSlots(cmp.htmlSlots, cmp.docs.tags),
 			parts: getDocsParts(cmp.htmlParts, cmp.docs.tags),
 			customStates: getDocsCustomStates(cmp),
 			listeners: getDocsListeners(cmp.listeners)
 		}));
-	}))), (cmp) => cmp.tag);
+	}));
+	return sortBy(flatOne(results), (cmp) => cmp.tag);
 };
 const buildDocsDepGraph = (cmp, cmps) => {
 	const dependencies = {};
@@ -7154,11 +7245,17 @@ const getDocsDeprecationText = (tags) => {
 	const deprecation = tags.find((t) => t.name === "deprecated");
 	if (deprecation) return deprecation.text || "";
 };
-const getDocsSlots = (tags) => {
-	return sortBy(getNameText("slot", tags).map(([name, docs]) => ({
+const DEFAULT_SLOT_DOCS = "The default slot";
+const getDocsSlots = (vdom, tags) => {
+	const docsSlots = getNameText("slot", tags).map(([name, docs]) => ({
 		name,
 		docs
-	})), (a) => a.name);
+	}));
+	const vdomSlots = vdom.map((name) => ({
+		name,
+		docs: name === "" ? DEFAULT_SLOT_DOCS : ""
+	}));
+	return sortBy(unique([...docsSlots, ...vdomSlots], (s) => s.name), (a) => a.name);
 };
 const getDocsParts = (vdom, tags) => {
 	const docsParts = getNameText("part", tags).map(([name, docs]) => ({
@@ -7224,7 +7321,7 @@ const cmpMetaToDocsComponent = (cmp, filePath, rootDir = process.cwd()) => {
 		methods: getDocsMethods(cmp.methods ?? []),
 		events: getDocsEvents(cmp.events ?? []),
 		styles: getDocsStyles(cmp),
-		slots: getDocsSlots(docs.tags),
+		slots: getDocsSlots(cmp.htmlSlots ?? [], docs.tags),
 		parts: getDocsParts(cmp.htmlParts ?? [], docs.tags),
 		customStates: getDocsCustomStates(cmp),
 		listeners: getDocsListeners(cmp.listeners ?? [])
@@ -7333,63 +7430,552 @@ const outputCustom = async (config, compilerCtx, buildCtx) => {
 	}));
 };
 //#endregion
-//#region src/compiler/docs/cem/index.ts
-/**
-* Generate Custom Elements Manifest (custom-elements.json) output
-* conforming to the Custom Elements Manifest specification.
-* @see https://github.com/webcomponents/custom-elements-manifest
-*
-* @param compilerCtx the current compiler context
-* @param docsData the generated docs data from Stencil components
-* @param outputTargets the output targets configured for the build
-*/
-const generateCustomElementsManifestDocs = async (compilerCtx, docsData, outputTargets) => {
-	const cemOutputTargets = outputTargets.filter(isOutputTargetDocsCustomElementsManifest);
-	if (cemOutputTargets.length === 0) return;
-	const manifest = generateManifest(docsData);
-	const jsonContent = JSON.stringify(manifest, null, 2);
-	await Promise.all(cemOutputTargets.map((outputTarget) => compilerCtx.fs.writeFile(outputTarget.file, jsonContent)));
+//#region src/compiler/docs/readme/markdown-usage.ts
+const usageToMarkdown = (usages) => {
+	const content = [];
+	const merged = mergeUsages(usages);
+	if (merged.length === 0) return content;
+	content.push(`## Usage`);
+	merged.forEach(({ name, text }) => {
+		content.push("");
+		content.push(`### ${toTitleCase(name)}`);
+		content.push("");
+		content.push(text);
+		content.push("");
+	});
+	content.push("");
+	content.push("");
+	return content;
 };
-/**
-* Generate the Custom Elements Manifest from Stencil docs data
-* @param docsData the generated docs data
-* @returns the Custom Elements Manifest object
-*/
-const generateManifest = (docsData) => {
-	const componentsByFile = /* @__PURE__ */ new Map();
-	for (const component of docsData.components) {
-		const filePath = component.filePath;
-		if (!componentsByFile.has(filePath)) componentsByFile.set(filePath, []);
-		componentsByFile.get(filePath).push(component);
+const mergeUsages = (usages) => {
+	const keys = Object.keys(usages);
+	const map = /* @__PURE__ */ new Map();
+	keys.forEach((key) => {
+		const usage = usages[key].trim();
+		const array = map.get(usage) || [];
+		array.push(key);
+		map.set(usage, array);
+	});
+	const merged = [];
+	map.forEach((value, key) => {
+		merged.push({
+			name: value.join(" / "),
+			text: key
+		});
+	});
+	return merged;
+};
+//#endregion
+//#region src/compiler/docs/agent-skill/frontmatter.ts
+/**
+* Truncate a string to a max length, replacing any trailing content with an ellipsis.
+* @param text the text to truncate
+* @param maxLen the max length of the returned string
+* @returns the truncated string
+*/
+const truncate = (text, maxLen) => text.length > maxLen ? `${text.slice(0, maxLen - 1).trimEnd()}…` : text;
+/**
+* Extract the first sentence from a block of text, for use as a short summary.
+* Bounded to the first paragraph (text up to a blank line) so a heading or
+* short first line doesn't get glued to unrelated content further down.
+* Falls back to the full (truncated) first paragraph if no sentence-ending
+* punctuation is found within it.
+* @param text the text to extract a summary from
+* @param maxLen the max length of the returned string
+* @returns the first sentence, or an empty string if `text` is empty
+*/
+const firstSentence = (text, maxLen = 200) => {
+	if (!text) return "";
+	const trimmed = text.trim();
+	if (trimmed === "") return "";
+	const firstParagraph = trimmed.split(/\r?\n\s*\r?\n/)[0];
+	const match = firstParagraph.match(/^[\s\S]*?[.!?](?=\s|$)/);
+	const sentence = (match ? match[0] : firstParagraph).trim();
+	return truncate(sentence, maxLen);
+};
+/**
+* Strip a single leading markdown ATX heading (e.g. `# Getting Started`), if
+* present, so summary extraction starts from the first real paragraph of prose.
+* @param text the text to strip a leading heading from
+* @returns the text with any leading heading removed
+*/
+const stripLeadingHeading = (text) => text.replace(/^\s*#{1,6}[^\n]*\n+/, "");
+/**
+* Sanitize a string into a valid Agent Skill `name` (lowercase, alphanumeric + hyphens).
+* @param raw the raw string to sanitize, e.g. a project namespace
+* @returns the kebab-cased name, or 'skill' if `raw` sanitizes to an empty string
+*/
+const toSkillName = (raw) => {
+	return raw.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "skill";
+};
+/**
+* Auto-generate the skill's `description` when the user doesn't supply one -
+* prefers real project-level usage content (see `<srcDir>/usage/*.md`) over a
+* generic sentence built from the component tag list.
+* @param components the project's documented components
+* @param name the skill's (already-sanitized) name
+* @param projectUsage project-level usage content, from `JsonDocs.usage`
+* @returns the generated description
+*/
+const buildSkillDescription = (components, name, projectUsage) => {
+	if (projectUsage) {
+		const firstEntry = Object.values(projectUsage)[0];
+		const fromProjectUsage = firstEntry ? firstSentence(stripLeadingHeading(firstEntry), 400) : "";
+		if (fromProjectUsage) return fromProjectUsage;
+	}
+	const tags = components.map((cmp) => cmp.tag);
+	const description = `Use when building UI with the ${name} component library. Provides API reference and usage examples for its ${tags.length} component${tags.length === 1 ? "" : "s"}: ${tags.join(", ")}.`;
+	return truncate(description, 800);
+};
+/**
+* Minimal YAML string serializer for the two flat frontmatter fields
+* (`name`/`description`). Quotes and escapes only when necessary - not a
+* general-purpose YAML writer.
+* @param value the string to serialize
+* @returns the value, quoted/escaped if it contains YAML-significant characters
+*/
+const escapeYamlString = (value) => {
+	if (!(value === "" || /[:#"'\n]/.test(value) || /^\s|\s$/.test(value) || /^[-?*&!|>%@`[\]{},]/.test(value))) return value;
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\r\n|\r|\n/g, "\\n")}"`;
+};
+/**
+* Assemble the top-level `SKILL.md` content: frontmatter, project-level intro
+* (from `JsonDocs.usage`, if any), and an index of components linking to
+* their `components/<tag>.md` reference file.
+* @param docsData the project's generated docs data
+* @param outputTarget the (already-validated) docs-agent-skill output target
+* @returns the `SKILL.md` content
+*/
+const generateSkillMarkdown = (docsData, outputTarget) => {
+	const name = outputTarget.name;
+	const description = outputTarget.description ?? buildSkillDescription(docsData.components, name, docsData.usage);
+	const lines = [
+		"---",
+		`name: ${escapeYamlString(name)}`,
+		`description: ${escapeYamlString(description)}`,
+		"---",
+		"",
+		`# ${name}`,
+		""
+	];
+	if (docsData.usage) lines.push(...usageToMarkdown(docsData.usage));
+	lines.push("## Components", "");
+	[...docsData.components].sort((a, b) => a.tag.localeCompare(b.tag)).forEach((cmp) => {
+		const summary = firstSentence(cmp.overview);
+		lines.push(`- [${cmp.tag}](components/${cmp.tag}.md)${summary ? ` — ${summary}` : ""}`);
+	});
+	lines.push("");
+	return lines.join("\n");
+};
+//#endregion
+//#region src/compiler/docs/readme/docs-util.ts
+var MarkdownTable = class {
+	rows = [];
+	addHeader(data) {
+		this.addRow(data, true);
 	}
-	const modules = [];
-	for (const [filePath, components] of componentsByFile) {
-		const declarations = components.map((component) => componentToDeclaration(component));
-		const exports = components.flatMap((component) => {
-			const className = dashToPascalCase(component.tag);
-			return [{
-				kind: "js",
-				name: className,
-				declaration: { name: className }
-			}, {
-				kind: "custom-element-definition",
-				name: component.tag,
-				declaration: { name: className }
-			}];
+	addRow(data, isHeader = false) {
+		const colData = [];
+		data.forEach((text) => {
+			const col = {
+				text: escapeMarkdownTableColumn(text),
+				width: text.length
+			};
+			colData.push(col);
 		});
-		modules.push({
-			kind: "javascript-module",
-			path: filePath,
-			declarations,
-			exports
+		this.rows.push({
+			columns: colData,
+			isHeader
 		});
 	}
-	return {
-		schemaVersion: "2.1.0",
-		modules
-	};
+	toMarkdown() {
+		return createTable(this.rows);
+	}
 };
-/**
+const escapeMarkdownTableColumn = (text) => {
+	text = text.replace(/\r?\n/g, " ");
+	text = text.replace(/\|/g, "\\|");
+	return text;
+};
+const createTable = (rows) => {
+	const content = [];
+	if (rows.length === 0) return content;
+	normalizeColumCount(rows);
+	normalizeColumnWidth(rows);
+	const th = rows.find((r) => r.isHeader);
+	if (th) {
+		const headerRow = createRow(th);
+		content.push(headerRow);
+		content.push(createBorder(th));
+	}
+	rows.filter((r) => !r.isHeader).forEach((td) => {
+		content.push(createRow(td));
+	});
+	return content;
+};
+const createBorder = (th) => {
+	const border = {
+		columns: [],
+		isHeader: false
+	};
+	th.columns.forEach((c) => {
+		const borderCol = {
+			text: "",
+			width: c.width
+		};
+		while (borderCol.text.length < borderCol.width) borderCol.text += "-";
+		border.columns.push(borderCol);
+	});
+	return createRow(border);
+};
+const createRow = (row) => {
+	const content = ["| "];
+	row.columns.forEach((c) => {
+		content.push(c.text);
+		content.push(" | ");
+	});
+	return content.join("").trim();
+};
+const normalizeColumCount = (rows) => {
+	let columnCount = 0;
+	rows.forEach((r) => {
+		if (r.columns.length > columnCount) columnCount = r.columns.length;
+	});
+	rows.forEach((r) => {
+		while (r.columns.length < columnCount) r.columns.push({
+			text: ``,
+			width: 0
+		});
+	});
+};
+const normalizeColumnWidth = (rows) => {
+	const columnCount = rows[0].columns.length;
+	for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+		let longestText = 0;
+		rows.forEach((r) => {
+			const col = r.columns[columnIndex];
+			if (col.text.length > longestText) longestText = col.text.length;
+		});
+		rows.forEach((r) => {
+			const col = r.columns[columnIndex];
+			col.width = longestText;
+			while (col.text.length < longestText) col.text += " ";
+		});
+	}
+};
+/**
+* Checks if a given string is a valid hexadecimal color representation.
+*
+* @param str - The string to be checked.
+* @returns `true` if the string is a valid hex color (e.g., '#FF00AA', '#f0f'), `false` otherwise.
+*
+* @example
+* isHexColor('#FF00AA'); // true
+* isHexColor('#f0f');    // true
+* isHexColor('#abcde');  // false (too many characters)
+* isHexColor('FF00AA');  // false (missing #)
+*/
+const isHexColor = (str) => {
+	return /^#([0-9A-Fa-f]{3}){1,2}$/.test(str);
+};
+//#endregion
+//#region src/compiler/docs/readme/markdown-css-props.ts
+const stylesToMarkdown = (styles) => {
+	const content = [];
+	if (styles.length === 0) return content;
+	content.push(`## CSS Custom Properties`);
+	content.push(``);
+	const table = new MarkdownTable();
+	table.addHeader(["Name", "Description"]);
+	styles.forEach((style) => {
+		table.addRow([`\`${style.name}\``, style.docs]);
+	});
+	content.push(...table.toMarkdown());
+	content.push(``);
+	content.push(``);
+	return content;
+};
+//#endregion
+//#region src/compiler/docs/readme/markdown-events.ts
+const eventsToMarkdown = (events, cmp, customColumns = []) => {
+	const content = [];
+	if (events.length === 0) return content;
+	content.push(`## Events`);
+	content.push(``);
+	const table = new MarkdownTable();
+	table.addHeader([
+		"Event",
+		"Description",
+		"Type",
+		...customColumns.map((c) => c.header)
+	]);
+	events.forEach((ev) => {
+		table.addRow([
+			`\`${ev.event}\``,
+			getDocsField$2(ev),
+			`\`CustomEvent<${ev.detail}>\``,
+			...customColumns.map((c) => c.content(ev, cmp))
+		]);
+	});
+	content.push(...table.toMarkdown());
+	content.push(``);
+	content.push(``);
+	return content;
+};
+const getDocsField$2 = (prop) => {
+	return `${prop.deprecation !== void 0 ? `<span style="color:red">**[DEPRECATED]**</span> ${prop.deprecation}<br/><br/>` : ""}${prop.docs}`;
+};
+//#endregion
+//#region src/compiler/docs/readme/markdown-methods.ts
+const methodsToMarkdown = (methods) => {
+	const content = [];
+	if (methods.length === 0) return content;
+	content.push(`## Methods`);
+	content.push(``);
+	methods.forEach((method) => {
+		content.push(`### \`${method.signature}\``);
+		content.push(``);
+		content.push(getDocsField$1(method));
+		content.push(``);
+		if (method.parameters.length > 0) {
+			const parmsTable = new MarkdownTable();
+			parmsTable.addHeader([
+				"Name",
+				"Type",
+				"Description"
+			]);
+			method.parameters.forEach(({ name, type, docs }) => {
+				parmsTable.addRow([
+					"`" + name + "`",
+					"`" + type + "`",
+					docs
+				]);
+			});
+			content.push(`#### Parameters`);
+			content.push(``);
+			content.push(...parmsTable.toMarkdown());
+			content.push(``);
+		}
+		if (method.returns) {
+			content.push(`#### Returns`);
+			content.push(``);
+			content.push(`Type: \`${method.returns.type}\``);
+			content.push(``);
+			content.push(method.returns.docs);
+			content.push(``);
+		}
+	});
+	content.push(``);
+	return content;
+};
+const getDocsField$1 = (prop) => {
+	return `${prop.deprecation !== void 0 ? `<span style="color:red">**[DEPRECATED]**</span> ${prop.deprecation}<br/><br/>` : ""}${prop.docs}`;
+};
+//#endregion
+//#region src/compiler/docs/readme/markdown-overview.ts
+/**
+* Generate an 'Overview' section for a markdown file
+* @param overview a component-level comment string to place in a markdown file
+* @returns The generated Overview section. If the provided overview is empty, return an empty list
+*/
+const overviewToMarkdown = (overview) => {
+	if (!overview) return [];
+	const content = [];
+	content.push(`## Overview`);
+	content.push("");
+	content.push(`${overview.trim()}`);
+	content.push("");
+	return content;
+};
+//#endregion
+//#region src/compiler/docs/readme/markdown-parts.ts
+/**
+* Converts a list of Shadow Parts metadata to a table written in Markdown
+* @param parts the Shadow parts metadata to convert
+* @returns a list of strings that make up the Markdown table
+*/
+const partsToMarkdown = (parts) => {
+	const content = [];
+	if (parts.length === 0) return content;
+	content.push(`## Shadow Parts`);
+	content.push(``);
+	const table = new MarkdownTable();
+	table.addHeader(["Part", "Description"]);
+	parts.forEach((style) => {
+		table.addRow([style.name === "" ? "" : `\`"${style.name}"\``, style.docs]);
+	});
+	content.push(...table.toMarkdown());
+	content.push(``);
+	content.push(``);
+	return content;
+};
+//#endregion
+//#region src/compiler/docs/readme/markdown-props.ts
+const propsToMarkdown = (props, cmp, customColumns = []) => {
+	const content = [];
+	if (props.length === 0) return content;
+	content.push(`## Properties`);
+	content.push(``);
+	const table = new MarkdownTable();
+	table.addHeader([
+		"Property",
+		"Attribute",
+		"Description",
+		"Type",
+		"Default",
+		...customColumns.map((c) => c.header)
+	]);
+	props.forEach((prop) => {
+		table.addRow([
+			getPropertyField(prop),
+			getAttributeField(prop),
+			getDocsField(prop),
+			getTypeField(prop),
+			getDefaultValueField(prop),
+			...customColumns.map((c) => c.content(prop, cmp))
+		]);
+	});
+	content.push(...table.toMarkdown());
+	content.push(``);
+	content.push(``);
+	return content;
+};
+const getPropertyField = (prop) => {
+	return `\`${prop.name}\`${prop.required ? " _(required)_" : ""}`;
+};
+const getAttributeField = (prop) => {
+	return prop.attr ? `\`${prop.attr}\`` : "--";
+};
+const getDocsField = (prop) => {
+	return `${prop.deprecation !== void 0 ? `<span style="color:red">**[DEPRECATED]**</span> ${prop.deprecation}<br/><br/>` : ""}${prop.docs}`;
+};
+const getTypeField = (prop) => {
+	return prop.type.includes("`") ? `\`\` ${prop.type} \`\`` : `\`${prop.type}\``;
+};
+const getDefaultValueField = (prop) => {
+	return prop.default?.includes("`") ? `\`\` ${prop.default} \`\`` : `\`${prop.default}\``;
+};
+//#endregion
+//#region src/compiler/docs/readme/markdown-slots.ts
+/**
+* Converts a list of Slots metadata to a table written in Markdown
+* @param slots the Slots metadata to convert
+* @returns a list of strings that make up the Markdown table
+*/
+const slotsToMarkdown = (slots) => {
+	const content = [];
+	if (slots.length === 0) return content;
+	content.push(`## Slots`);
+	content.push(``);
+	const table = new MarkdownTable();
+	table.addHeader(["Slot", "Description"]);
+	slots.forEach((style) => {
+		table.addRow([style.name === "" ? "" : `\`"${style.name}"\``, style.docs]);
+	});
+	content.push(...table.toMarkdown());
+	content.push(``);
+	content.push(``);
+	return content;
+};
+//#endregion
+//#region src/compiler/docs/agent-skill/markdown-component.ts
+/**
+* Generate a single component's skill reference file (`components/<tag>.md`),
+* reusing the same pure markdown-formatting functions the `docs-readme`
+* output target uses.
+* @param cmp the component's docs metadata
+* @returns the component's markdown content
+*/
+const generateComponentSkillMarkdown = (cmp) => {
+	return [
+		`# ${cmp.tag}`,
+		"",
+		...overviewToMarkdown(cmp.overview),
+		...propsToMarkdown(cmp.props),
+		...eventsToMarkdown(cmp.events),
+		...methodsToMarkdown(cmp.methods),
+		...slotsToMarkdown(cmp.slots),
+		...stylesToMarkdown(cmp.styles),
+		...partsToMarkdown(cmp.parts),
+		...usageToMarkdown(cmp.usage)
+	].join("\n");
+};
+//#endregion
+//#region src/compiler/docs/agent-skill/index.ts
+/**
+* Generate an Agent Skill (`SKILL.md` + `components/*.md`) describing the project's
+* component library.
+* @param compilerCtx the current compiler context
+* @param docsData the generated docs data
+* @param outputTargets the output targets configured for the build
+*/
+const generateAgentSkillDocs = async (compilerCtx, docsData, outputTargets) => {
+	const skillOutputs = outputTargets.filter(isOutputTargetDocsAgentSkill);
+	if (skillOutputs.length === 0) return;
+	await Promise.all(skillOutputs.map(async (outputTarget) => {
+		const dir = outputTarget.dir;
+		const skillMd = generateSkillMarkdown(docsData, outputTarget);
+		await Promise.all([compilerCtx.fs.writeFile(join$2(dir, "SKILL.md"), skillMd), ...docsData.components.map((cmp) => compilerCtx.fs.writeFile(join$2(dir, "components", `${cmp.tag}.md`), generateComponentSkillMarkdown(cmp)))]);
+	}));
+};
+//#endregion
+//#region src/compiler/docs/cem/index.ts
+/**
+* Generate Custom Elements Manifest (custom-elements.json) output
+* conforming to the Custom Elements Manifest specification.
+* @see https://github.com/webcomponents/custom-elements-manifest
+*
+* @param compilerCtx the current compiler context
+* @param docsData the generated docs data from Stencil components
+* @param outputTargets the output targets configured for the build
+*/
+const generateCustomElementsManifestDocs = async (compilerCtx, docsData, outputTargets) => {
+	const cemOutputTargets = outputTargets.filter(isOutputTargetDocsCustomElementsManifest);
+	if (cemOutputTargets.length === 0) return;
+	const manifest = generateManifest(docsData);
+	const jsonContent = JSON.stringify(manifest, null, 2);
+	await Promise.all(cemOutputTargets.map((outputTarget) => compilerCtx.fs.writeFile(outputTarget.file, jsonContent)));
+};
+/**
+* Generate the Custom Elements Manifest from Stencil docs data
+* @param docsData the generated docs data
+* @returns the Custom Elements Manifest object
+*/
+const generateManifest = (docsData) => {
+	const componentsByFile = /* @__PURE__ */ new Map();
+	for (const component of docsData.components) {
+		const filePath = component.filePath;
+		if (!componentsByFile.has(filePath)) componentsByFile.set(filePath, []);
+		componentsByFile.get(filePath).push(component);
+	}
+	const modules = [];
+	for (const [filePath, components] of componentsByFile) {
+		const declarations = components.map((component) => componentToDeclaration(component));
+		const exports = components.flatMap((component) => {
+			const className = dashToPascalCase(component.tag);
+			return [{
+				kind: "js",
+				name: className,
+				declaration: { name: className }
+			}, {
+				kind: "custom-element-definition",
+				name: component.tag,
+				declaration: { name: className }
+			}];
+		});
+		modules.push({
+			kind: "javascript-module",
+			path: filePath,
+			declarations,
+			exports
+		});
+	}
+	return {
+		schemaVersion: "2.1.0",
+		modules
+	};
+};
+/**
 * Convert Stencil's ComponentCompilerTypeReferences to CEM TypeReference array
 * @param references Stencil's type references map
 * @returns CEM TypeReference array
@@ -7570,141 +8156,13 @@ export default _default;
 			deprecation: cmp.deprecation
 		}))
 	};
-	const jsonContent = JSON.stringify(json, null, 2);
-	await Promise.all(jsonOutputTargets.map((jsonOutput) => {
-		return writeDocsOutput(compilerCtx, jsonOutput, jsonContent, typesContent);
-	}));
-};
-const writeDocsOutput = async (compilerCtx, jsonOutput, jsonContent, typesContent) => {
-	return Promise.all([compilerCtx.fs.writeFile(jsonOutput.file, jsonContent), jsonOutput.typesFile ? compilerCtx.fs.writeFile(jsonOutput.typesFile, typesContent) : Promise.resolve()]);
-};
-//#endregion
-//#region src/compiler/docs/readme/docs-util.ts
-var MarkdownTable = class {
-	rows = [];
-	addHeader(data) {
-		this.addRow(data, true);
-	}
-	addRow(data, isHeader = false) {
-		const colData = [];
-		data.forEach((text) => {
-			const col = {
-				text: escapeMarkdownTableColumn(text),
-				width: text.length
-			};
-			colData.push(col);
-		});
-		this.rows.push({
-			columns: colData,
-			isHeader
-		});
-	}
-	toMarkdown() {
-		return createTable(this.rows);
-	}
-};
-const escapeMarkdownTableColumn = (text) => {
-	text = text.replace(/\r?\n/g, " ");
-	text = text.replace(/\|/g, "\\|");
-	return text;
-};
-const createTable = (rows) => {
-	const content = [];
-	if (rows.length === 0) return content;
-	normalizeColumCount(rows);
-	normalizeColumnWidth(rows);
-	const th = rows.find((r) => r.isHeader);
-	if (th) {
-		const headerRow = createRow(th);
-		content.push(headerRow);
-		content.push(createBorder(th));
-	}
-	rows.filter((r) => !r.isHeader).forEach((td) => {
-		content.push(createRow(td));
-	});
-	return content;
-};
-const createBorder = (th) => {
-	const border = {
-		columns: [],
-		isHeader: false
-	};
-	th.columns.forEach((c) => {
-		const borderCol = {
-			text: "",
-			width: c.width
-		};
-		while (borderCol.text.length < borderCol.width) borderCol.text += "-";
-		border.columns.push(borderCol);
-	});
-	return createRow(border);
-};
-const createRow = (row) => {
-	const content = ["| "];
-	row.columns.forEach((c) => {
-		content.push(c.text);
-		content.push(" | ");
-	});
-	return content.join("").trim();
-};
-const normalizeColumCount = (rows) => {
-	let columnCount = 0;
-	rows.forEach((r) => {
-		if (r.columns.length > columnCount) columnCount = r.columns.length;
-	});
-	rows.forEach((r) => {
-		while (r.columns.length < columnCount) r.columns.push({
-			text: ``,
-			width: 0
-		});
-	});
-};
-const normalizeColumnWidth = (rows) => {
-	const columnCount = rows[0].columns.length;
-	for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-		let longestText = 0;
-		rows.forEach((r) => {
-			const col = r.columns[columnIndex];
-			if (col.text.length > longestText) longestText = col.text.length;
-		});
-		rows.forEach((r) => {
-			const col = r.columns[columnIndex];
-			col.width = longestText;
-			while (col.text.length < longestText) col.text += " ";
-		});
-	}
-};
-/**
-* Checks if a given string is a valid hexadecimal color representation.
-*
-* @param str - The string to be checked.
-* @returns `true` if the string is a valid hex color (e.g., '#FF00AA', '#f0f'), `false` otherwise.
-*
-* @example
-* isHexColor('#FF00AA'); // true
-* isHexColor('#f0f');    // true
-* isHexColor('#abcde');  // false (too many characters)
-* isHexColor('FF00AA');  // false (missing #)
-*/
-const isHexColor = (str) => {
-	return /^#([0-9A-Fa-f]{3}){1,2}$/.test(str);
-};
-//#endregion
-//#region src/compiler/docs/readme/markdown-css-props.ts
-const stylesToMarkdown = (styles) => {
-	const content = [];
-	if (styles.length === 0) return content;
-	content.push(`## CSS Custom Properties`);
-	content.push(``);
-	const table = new MarkdownTable();
-	table.addHeader(["Name", "Description"]);
-	styles.forEach((style) => {
-		table.addRow([`\`${style.name}\``, style.docs]);
-	});
-	content.push(...table.toMarkdown());
-	content.push(``);
-	content.push(``);
-	return content;
+	const jsonContent = JSON.stringify(json, null, 2);
+	await Promise.all(jsonOutputTargets.map((jsonOutput) => {
+		return writeDocsOutput(compilerCtx, jsonOutput, jsonContent, typesContent);
+	}));
+};
+const writeDocsOutput = async (compilerCtx, jsonOutput, jsonContent, typesContent) => {
+	return Promise.all([compilerCtx.fs.writeFile(jsonOutput.file, jsonContent), jsonOutput.typesFile ? compilerCtx.fs.writeFile(jsonOutput.typesFile, typesContent) : Promise.resolve()]);
 };
 //#endregion
 //#region src/compiler/docs/readme/markdown-custom-states.ts
@@ -7778,220 +8236,6 @@ const getCmpLink = (from, to, cmps) => {
 	return to;
 };
 //#endregion
-//#region src/compiler/docs/readme/markdown-events.ts
-const eventsToMarkdown = (events) => {
-	const content = [];
-	if (events.length === 0) return content;
-	content.push(`## Events`);
-	content.push(``);
-	const table = new MarkdownTable();
-	table.addHeader([
-		"Event",
-		"Description",
-		"Type"
-	]);
-	events.forEach((ev) => {
-		table.addRow([
-			`\`${ev.event}\``,
-			getDocsField$2(ev),
-			`\`CustomEvent<${ev.detail}>\``
-		]);
-	});
-	content.push(...table.toMarkdown());
-	content.push(``);
-	content.push(``);
-	return content;
-};
-const getDocsField$2 = (prop) => {
-	return `${prop.deprecation !== void 0 ? `<span style="color:red">**[DEPRECATED]**</span> ${prop.deprecation}<br/><br/>` : ""}${prop.docs}`;
-};
-//#endregion
-//#region src/compiler/docs/readme/markdown-methods.ts
-const methodsToMarkdown = (methods) => {
-	const content = [];
-	if (methods.length === 0) return content;
-	content.push(`## Methods`);
-	content.push(``);
-	methods.forEach((method) => {
-		content.push(`### \`${method.signature}\``);
-		content.push(``);
-		content.push(getDocsField$1(method));
-		content.push(``);
-		if (method.parameters.length > 0) {
-			const parmsTable = new MarkdownTable();
-			parmsTable.addHeader([
-				"Name",
-				"Type",
-				"Description"
-			]);
-			method.parameters.forEach(({ name, type, docs }) => {
-				parmsTable.addRow([
-					"`" + name + "`",
-					"`" + type + "`",
-					docs
-				]);
-			});
-			content.push(`#### Parameters`);
-			content.push(``);
-			content.push(...parmsTable.toMarkdown());
-			content.push(``);
-		}
-		if (method.returns) {
-			content.push(`#### Returns`);
-			content.push(``);
-			content.push(`Type: \`${method.returns.type}\``);
-			content.push(``);
-			content.push(method.returns.docs);
-			content.push(``);
-		}
-	});
-	content.push(``);
-	return content;
-};
-const getDocsField$1 = (prop) => {
-	return `${prop.deprecation !== void 0 ? `<span style="color:red">**[DEPRECATED]**</span> ${prop.deprecation}<br/><br/>` : ""}${prop.docs}`;
-};
-//#endregion
-//#region src/compiler/docs/readme/markdown-overview.ts
-/**
-* Generate an 'Overview' section for a markdown file
-* @param overview a component-level comment string to place in a markdown file
-* @returns The generated Overview section. If the provided overview is empty, return an empty list
-*/
-const overviewToMarkdown = (overview) => {
-	if (!overview) return [];
-	const content = [];
-	content.push(`## Overview`);
-	content.push("");
-	content.push(`${overview.trim()}`);
-	content.push("");
-	return content;
-};
-//#endregion
-//#region src/compiler/docs/readme/markdown-parts.ts
-/**
-* Converts a list of Shadow Parts metadata to a table written in Markdown
-* @param parts the Shadow parts metadata to convert
-* @returns a list of strings that make up the Markdown table
-*/
-const partsToMarkdown = (parts) => {
-	const content = [];
-	if (parts.length === 0) return content;
-	content.push(`## Shadow Parts`);
-	content.push(``);
-	const table = new MarkdownTable();
-	table.addHeader(["Part", "Description"]);
-	parts.forEach((style) => {
-		table.addRow([style.name === "" ? "" : `\`"${style.name}"\``, style.docs]);
-	});
-	content.push(...table.toMarkdown());
-	content.push(``);
-	content.push(``);
-	return content;
-};
-//#endregion
-//#region src/compiler/docs/readme/markdown-props.ts
-const propsToMarkdown = (props) => {
-	const content = [];
-	if (props.length === 0) return content;
-	content.push(`## Properties`);
-	content.push(``);
-	const table = new MarkdownTable();
-	table.addHeader([
-		"Property",
-		"Attribute",
-		"Description",
-		"Type",
-		"Default"
-	]);
-	props.forEach((prop) => {
-		table.addRow([
-			getPropertyField(prop),
-			getAttributeField(prop),
-			getDocsField(prop),
-			getTypeField(prop),
-			getDefaultValueField(prop)
-		]);
-	});
-	content.push(...table.toMarkdown());
-	content.push(``);
-	content.push(``);
-	return content;
-};
-const getPropertyField = (prop) => {
-	return `\`${prop.name}\`${prop.required ? " _(required)_" : ""}`;
-};
-const getAttributeField = (prop) => {
-	return prop.attr ? `\`${prop.attr}\`` : "--";
-};
-const getDocsField = (prop) => {
-	return `${prop.deprecation !== void 0 ? `<span style="color:red">**[DEPRECATED]**</span> ${prop.deprecation}<br/><br/>` : ""}${prop.docs}`;
-};
-const getTypeField = (prop) => {
-	return prop.type.includes("`") ? `\`\` ${prop.type} \`\`` : `\`${prop.type}\``;
-};
-const getDefaultValueField = (prop) => {
-	return prop.default?.includes("`") ? `\`\` ${prop.default} \`\`` : `\`${prop.default}\``;
-};
-//#endregion
-//#region src/compiler/docs/readme/markdown-slots.ts
-/**
-* Converts a list of Slots metadata to a table written in Markdown
-* @param slots the Slots metadata to convert
-* @returns a list of strings that make up the Markdown table
-*/
-const slotsToMarkdown = (slots) => {
-	const content = [];
-	if (slots.length === 0) return content;
-	content.push(`## Slots`);
-	content.push(``);
-	const table = new MarkdownTable();
-	table.addHeader(["Slot", "Description"]);
-	slots.forEach((style) => {
-		table.addRow([style.name === "" ? "" : `\`"${style.name}"\``, style.docs]);
-	});
-	content.push(...table.toMarkdown());
-	content.push(``);
-	content.push(``);
-	return content;
-};
-//#endregion
-//#region src/compiler/docs/readme/markdown-usage.ts
-const usageToMarkdown = (usages) => {
-	const content = [];
-	const merged = mergeUsages(usages);
-	if (merged.length === 0) return content;
-	content.push(`## Usage`);
-	merged.forEach(({ name, text }) => {
-		content.push("");
-		content.push(`### ${toTitleCase(name)}`);
-		content.push("");
-		content.push(text);
-		content.push("");
-	});
-	content.push("");
-	content.push("");
-	return content;
-};
-const mergeUsages = (usages) => {
-	const keys = Object.keys(usages);
-	const map = /* @__PURE__ */ new Map();
-	keys.forEach((key) => {
-		const usage = usages[key].trim();
-		const array = map.get(usage) || [];
-		array.push(key);
-		map.set(usage, array);
-	});
-	const merged = [];
-	map.forEach((value, key) => {
-		merged.push({
-			name: value.join(" / "),
-			text: key
-		});
-	});
-	return merged;
-};
-//#endregion
 //#region src/compiler/docs/readme/output-docs.ts
 /**
 * Generate a README for a given component and write it to disk.
@@ -8017,7 +8261,8 @@ const generateReadme = async (config, compilerCtx, readmeOutputs, docsData, cmps
 		if (readmeOutput.dir) {
 			const relativeReadmePath = relative$1(config.srcDir, docsData.readmePath);
 			const readmeOutputPath = join$2(readmeOutput.dir, relativeReadmePath);
-			const readmeContent = generateMarkdown(await resolveUserContent(compilerCtx, readmeOutput, readmeOutputPath, config, userContent), docsData, cmps, readmeOutput, config);
+			const currentReadmeContent = await resolveUserContent(compilerCtx, readmeOutput, readmeOutputPath, config, userContent);
+			const readmeContent = generateMarkdown(currentReadmeContent, docsData, cmps, readmeOutput, config);
 			if ((await compilerCtx.fs.readFile(readmeOutputPath))?.replace(/\r/g, "") === readmeContent.replace(/\r/g, "")) return;
 			await compilerCtx.fs.writeFile(readmeOutputPath, readmeContent);
 			if (isUpdate) config.logger.info(`updated readme docs: ${docsData.tag}`);
@@ -8046,7 +8291,8 @@ const generateMergedReadme = async (config, compilerCtx, readmeOutputs, cmps, al
 		if (readmeOutput.dir) {
 			const relativeReadmePath = relative$1(config.srcDir, primaryCmp.readmePath);
 			const readmeOutputPath = join$2(readmeOutput.dir, relativeReadmePath);
-			const readmeContent = generateMergedMarkdown(await resolveUserContent(compilerCtx, readmeOutput, readmeOutputPath, config, userContent), cmps, allCmps, readmeOutput, config);
+			const currentReadmeContent = await resolveUserContent(compilerCtx, readmeOutput, readmeOutputPath, config, userContent);
+			const readmeContent = generateMergedMarkdown(currentReadmeContent, cmps, allCmps, readmeOutput, config);
 			if ((await compilerCtx.fs.readFile(readmeOutputPath))?.replace(/\r/g, "") === readmeContent.replace(/\r/g, "")) return;
 			await compilerCtx.fs.writeFile(readmeOutputPath, readmeContent);
 			const tags = cmps.map((c) => c.tag).join(", ");
@@ -8102,8 +8348,8 @@ const generateComponentBody = (cmp, cmps, readmeOutput, config) => {
 		...getDocsDeprecation(cmp),
 		...overviewToMarkdown(cmp.overview),
 		...usageToMarkdown(cmp.usage),
-		...propsToMarkdown(cmp.props),
-		...eventsToMarkdown(cmp.events),
+		...propsToMarkdown(cmp.props, cmp, readmeOutput.customColumns?.props),
+		...eventsToMarkdown(cmp.events, cmp, readmeOutput.customColumns?.events),
 		...methodsToMarkdown(cmp.methods),
 		...slotsToMarkdown(cmp.slots),
 		...partsToMarkdown(cmp.parts),
@@ -8303,14 +8549,15 @@ const serializeAttribute = (prop) => {
 * @param buildCtx the build context for the current Stencil task run
 */
 const outputDocs = async (config, compilerCtx, buildCtx) => {
-	const docsOutputTargets = filterActiveTargets(config.outputTargets.filter((o) => isOutputTargetDocsReadme(o) || isOutputTargetDocsJson(o) || isOutputTargetDocsCustom(o) || isOutputTargetDocsVscode(o) || isOutputTargetDocsCustomElementsManifest(o)), config.devMode);
+	const docsOutputTargets = filterActiveTargets(config.outputTargets.filter((o) => isOutputTargetDocsReadme(o) || isOutputTargetDocsJson(o) || isOutputTargetDocsCustom(o) || isOutputTargetDocsVscode(o) || isOutputTargetDocsCustomElementsManifest(o) || isOutputTargetDocsAgentSkill(o)), config.devMode);
 	if (docsOutputTargets.length === 0) return;
 	await buildCtx.stylesPromise;
 	const docsData = await generateDocData(config, compilerCtx, buildCtx);
-	if (config.outputTargets.every((target) => target.type === "docs-readme" || target.type === "docs-json" || target.type === "docs-custom" || target.type === "docs-vscode" || target.type === "docs-custom-elements-manifest")) await Promise.all(docsData.components.map(async (component) => {
+	if (config.outputTargets.every((target) => target.type === "docs-readme" || target.type === "docs-json" || target.type === "docs-custom" || target.type === "docs-vscode" || target.type === "docs-custom-elements-manifest" || target.type === "docs-agent-skill")) await Promise.all(docsData.components.map(async (component) => {
 		if (component.styles.length === 0) {
 			const readmeDir = docsOutputTargets.find(isOutputTargetDocsReadme)?.dir || config.srcDir;
-			const existingCssProps = await extractExistingCssProps(compilerCtx, normalizePath(readmeDir) === normalizePath(config.srcDir) ? component.readmePath : join$2(readmeDir, component.readmePath.replace(config.srcDir, "")));
+			const readmePath = normalizePath(readmeDir) === normalizePath(config.srcDir) ? component.readmePath : join$2(readmeDir, component.readmePath.replace(config.srcDir, ""));
+			const existingCssProps = await extractExistingCssProps(compilerCtx, readmePath);
 			if (existingCssProps) component.styles = existingCssProps;
 		}
 	}));
@@ -8319,7 +8566,8 @@ const outputDocs = async (config, compilerCtx, buildCtx) => {
 		generateJsonDocs(config, compilerCtx, docsData, docsOutputTargets),
 		generateVscodeDocs(compilerCtx, docsData, docsOutputTargets),
 		generateCustomDocs(config, docsData, docsOutputTargets),
-		generateCustomElementsManifestDocs(compilerCtx, docsData, docsOutputTargets)
+		generateCustomElementsManifestDocs(compilerCtx, docsData, docsOutputTargets),
+		generateAgentSkillDocs(compilerCtx, docsData, docsOutputTargets)
 	]);
 };
 //#endregion
@@ -8353,7 +8601,8 @@ const outputGlobalStyle = async (config, compilerCtx, buildCtx) => {
 		const primaryPath = join$2(outputTarget.dir, outputTarget.fileName);
 		writePromises.push(compilerCtx.fs.writeFile(primaryPath, css, { outputTargetType: outputTarget.type }));
 		if (outputTarget.copyToLoaderBrowser && loaderBundleTargets.length > 0) for (const loaderTarget of loaderBundleTargets) {
-			const compatPath = join$2(join$2(loaderTarget.buildDir, namespace), outputTarget.fileName);
+			const browserDir = join$2(loaderTarget.buildDir, namespace);
+			const compatPath = join$2(browserDir, outputTarget.fileName);
 			writePromises.push(compilerCtx.fs.writeFile(compatPath, css));
 		}
 		for (const wwwTarget of wwwTargets) {
@@ -8403,7 +8652,8 @@ const generateStandaloneTypesOutput = async (config, compilerCtx, buildCtx, type
 			...components.map((component) => {
 				const exportName = dashToPascalCase(component.tagName);
 				const importName = component.componentClassName;
-				const componentDTSPath = join$2(componentsTypeDirectoryRelPath, relative$1(config.srcDir, component.sourceFilePath).replace(/\.tsx$/, ""));
+				const componentSourceRelPath = relative$1(config.srcDir, component.sourceFilePath).replace(/\.tsx$/, "");
+				const componentDTSPath = join$2(componentsTypeDirectoryRelPath, componentSourceRelPath);
 				const defineFunctionExportName = `defineCustomElement${exportName}`;
 				const localComponentTypeDefFilePath = `./${component.tagName}`;
 				return [`export { ${importName} as ${exportName} } from '${componentDTSPath.startsWith(".") ? componentDTSPath : "./" + componentDTSPath}';`, `export { defineCustomElement as ${defineFunctionExportName} } from '${localComponentTypeDefFilePath}';`].join("\n");
@@ -8474,8 +8724,9 @@ const generateCustomElementType = (componentsDtsRelPath, cmp) => {
 	const tagNameAsPascal = dashToPascalCase(cmp.tagName);
 	return [
 		`import type { Components, JSX } from "${componentsDtsRelPath}";`,
+		`import type { HTMLStencilElement } from "@stencil/core/runtime";`,
 		``,
-		`interface ${tagNameAsPascal} extends Components.${tagNameAsPascal}, HTMLElement {}`,
+		`interface ${tagNameAsPascal} extends Components.${tagNameAsPascal}, HTMLStencilElement {}`,
 		`export const ${tagNameAsPascal}: {`,
 		`    prototype: ${tagNameAsPascal};`,
 		`    new (): ${tagNameAsPascal};`,
@@ -8500,7 +8751,7 @@ const relDts = (fromPath, dtsPath) => {
 };
 //#endregion
 //#region src/compiler/types/constants.ts
-const HTML_ELEMENT_METHODS = new Set([
+const HTML_ELEMENT_METHODS = /* @__PURE__ */ new Set([
 	"attachInternals",
 	"blur",
 	"click",
@@ -8593,7 +8844,9 @@ const HTML_ELEMENT_METHODS = new Set([
 * @returns the updated type declaration file contents
 */
 const updateStencilTypesImports = (typesDir, dtsFilePath, dtsContent) => {
-	let coreDtsPath = join$2(relative$1(dirname$1(dtsFilePath), typesDir), CORE_FILENAME);
+	const dir = dirname$1(dtsFilePath);
+	const relPath = relative$1(dir, typesDir);
+	let coreDtsPath = join$2(relPath, CORE_FILENAME);
 	if (!coreDtsPath.startsWith(".")) coreDtsPath = `./${coreDtsPath}`;
 	coreDtsPath = normalizePath(coreDtsPath);
 	if (dtsContent.includes("@stencil/core")) {
@@ -8731,7 +8984,8 @@ const CORE_DTS = `${CORE_FILENAME}.d.ts`;
 * @returns additional types information to add event listener method overloads for component's html element type
 */
 const generateEventListenerTypes = (cmp, typeImportData) => {
-	const tagNameAsPascal = dashToPascalCase(cmp.tagName.toLowerCase());
+	const tagName = cmp.tagName.toLowerCase();
+	const tagNameAsPascal = dashToPascalCase(tagName);
 	const htmlElementName = `HTML${tagNameAsPascal}Element`;
 	const cmpEventInterface = `${tagNameAsPascal}CustomEvent`;
 	const htmlElementEventMapName = `${htmlElementName}EventMap`;
@@ -8797,9 +9051,11 @@ const getEventGenericType = (cmpEvent, typeImportData, componentSourcePath) => {
 */
 const generateEventTypes = (cmpMeta, typeImportData, cmpClassName) => {
 	return cmpMeta.events.map((cmpEvent) => {
+		const name = `on${toTitleCase(cmpEvent.name)}`;
+		const cmpEventDetailInterface = `${cmpClassName}CustomEvent`;
 		return {
-			name: `on${toTitleCase(cmpEvent.name)}`,
-			type: getEventType$1(cmpEvent, `${cmpClassName}CustomEvent`, typeImportData, cmpMeta.sourceFilePath),
+			name,
+			type: getEventType$1(cmpEvent, cmpEventDetailInterface, typeImportData, cmpMeta.sourceFilePath),
 			optional: false,
 			required: false,
 			internal: cmpEvent.internal,
@@ -9210,6 +9466,12 @@ const updateImportReferenceFactory = (typeCounts, filePath, config) => {
 //#endregion
 //#region src/compiler/types/generate-app-types.ts
 /**
+* Above this many required props on a single component, the generated `OneOf<>` required-prop
+* check is skipped entirely (falling back to unchecked optional `attr:`/`prop:` variants) rather
+* than risking exponential failure in the TS checker - see the comment at its usage site.
+*/
+const MAX_ONE_OF_REQUIRED_PROPS = 8;
+/**
 * Generates and writes a `components.d.ts` file to disk. This file may be written to the `src` directory of a project,
 * or be written to a directory that is meant to be distributed.
 * @param config the Stencil configuration associated with the project being compiled
@@ -9273,20 +9535,26 @@ const generateComponentTypesFile = (config, buildCtx, areTypesInternal) => {
 		const typeData = typeImportData[filePath];
 		let importFilePath = filePath;
 		if (isAbsolute$1(filePath)) importFilePath = normalizePath("./" + relative$1(config.srcDir, filePath)).replace(/\.(tsx|ts)$/, "");
-		const hasDefaultImport = typeData.some((td) => td.isDefault);
-		if (hasDefaultImport && typeData.length === 1) {
-			const td = typeData[0];
-			imports.push(`import ${td.importName} from "${importFilePath}";`);
-			exports.push(`export { default as ${td.importName} } from "${importFilePath}";`);
-		} else if (hasDefaultImport) {
-			const defaultImport = typeData.find((td) => td.isDefault);
-			const namedPart = typeData.filter((td) => !td.isDefault).sort(sortImportNames).map((td) => {
+		const defaultImports = typeData.filter((td) => td.isDefault);
+		if (defaultImports.length > 0) {
+			const [defaultImport, ...additionalDefaultImports] = defaultImports;
+			const namedImports = typeData.filter((td) => !td.isDefault);
+			const namedPart = namedImports.sort(sortImportNames).map((td) => {
 				if (td.originalName === "") return `${td.localName}`;
 				else if (td.originalName === td.importName) return `${td.originalName}`;
 				else return `${td.originalName} as ${td.importName}`;
 			}).join(`, `);
-			imports.push(`import ${defaultImport.importName}, { ${namedPart} } from "${importFilePath}";`);
-			exports.push(`export { default as ${defaultImport.importName}, ${namedPart} } from "${importFilePath}";`);
+			if (namedImports.length > 0) {
+				imports.push(`import ${defaultImport.importName}, { ${namedPart} } from "${importFilePath}";`);
+				exports.push(`export { default as ${defaultImport.importName}, ${namedPart} } from "${importFilePath}";`);
+			} else {
+				imports.push(`import ${defaultImport.importName} from "${importFilePath}";`);
+				exports.push(`export { default as ${defaultImport.importName} } from "${importFilePath}";`);
+			}
+			additionalDefaultImports.forEach((td) => {
+				imports.push(`import ${td.importName} from "${importFilePath}";`);
+				exports.push(`export { default as ${td.importName} } from "${importFilePath}";`);
+			});
 		} else {
 			const namedPart = typeData.sort(sortImportNames).map((td) => {
 				if (td.originalName === "") return `${td.localName}`;
@@ -9309,8 +9577,8 @@ const generateComponentTypesFile = (config, buildCtx, areTypesInternal) => {
 	c.push(`    }`);
 	c.push(`}`);
 	c.push(`declare namespace LocalJSX {`);
-	if (modules.some((m) => m.requiredProps)) {
-		c.push(`    type OneOf<K extends string, PropT, AttrT = PropT> = { [P in K]: PropT } & { [P in \`attr:\${K}\` | \`prop:\${K}\`]?: never } | { [P in \`attr:\${K}\`]: AttrT } & { [P in K | \`prop:\${K}\`]?: never } | { [P in \`prop:\${K}\`]: PropT } & { [P in K | \`attr:\${K}\`]?: never };`);
+	if (modules.some((m) => m.requiredProps && m.requiredProps.length > 0 && m.requiredProps.length <= MAX_ONE_OF_REQUIRED_PROPS)) {
+		c.push(`    type OneOf<K extends string, PropT, AttrT = PropT> = { [P in K]: PropT } & { [P in \`attr:\${K}\`]?: never } | { [P in \`attr:\${K}\`]: AttrT } & { [P in K]?: never };`);
 		c.push(``);
 	}
 	c.push(...modules.map((m) => {
@@ -9327,7 +9595,7 @@ const generateComponentTypesFile = (config, buildCtx, areTypesInternal) => {
 	c.push(...modules.map((m) => {
 		if (m.explicitAttributes) {
 			const baseOptional = `Omit<${m.tagNameAsPascal}, keyof ${m.tagNameAsPascal}Attributes> & { [K in keyof ${m.tagNameAsPascal} & keyof ${m.tagNameAsPascal}Attributes]?: ${m.tagNameAsPascal}[K] } & { [K in keyof ${m.tagNameAsPascal} & keyof ${m.tagNameAsPascal}Attributes as \`attr:\${K}\`]?: ${m.tagNameAsPascal}Attributes[K] } & { [K in keyof ${m.tagNameAsPascal} & keyof ${m.tagNameAsPascal}Attributes as \`prop:\${K}\`]?: ${m.tagNameAsPascal}[K] }`;
-			if (m.requiredProps && m.requiredProps.length > 0) {
+			if (m.requiredProps && m.requiredProps.length > 0 && m.requiredProps.length <= MAX_ONE_OF_REQUIRED_PROPS) {
 				const requiredUnions = m.requiredProps.map((prop) => {
 					return `OneOf<"${prop.name}", ${m.tagNameAsPascal}["${prop.name}"], ${m.tagNameAsPascal}Attributes["${prop.name}"]>`;
 				}).join(" & ");
@@ -9506,7 +9774,8 @@ const outputTypes = async (config, compilerCtx, buildCtx) => {
 * @returns a path to the build directory for that output target
 */
 const getAbsoluteBuildDir = (outputTarget) => {
-	return join$2("/", relative$1(outputTarget.dir, outputTarget.buildDir)) + "/";
+	const relativeBuildDir = relative$1(outputTarget.dir, outputTarget.buildDir);
+	return join$2("/", relativeBuildDir) + "/";
 };
 //#endregion
 //#region src/compiler/html/add-script-attr.ts
@@ -9526,7 +9795,8 @@ const addScriptDataAttribute = (config, doc, outputTarget) => {
 //#region src/compiler/html/inject-module-preloads.ts
 const optimizeCriticalPath = (doc, criticalBundlers, outputTarget) => {
 	const buildDir = getAbsoluteBuildDir(outputTarget);
-	injectModulePreloads(doc, criticalBundlers.map((path) => join$2(buildDir, path)));
+	const paths = criticalBundlers.map((path) => join$2(buildDir, path));
+	injectModulePreloads(doc, paths);
 };
 const injectModulePreloads = (doc, paths) => {
 	const existingLinks = Array.from(doc.querySelectorAll("link[rel=modulepreload]")).map((link) => link.getAttribute("href"));
@@ -9656,7 +9926,8 @@ const updateIndexHtmlServiceWorker = async (config, buildCtx, doc, outputTarget)
 	else if (serviceWorker) await injectRegisterServiceWorker(buildCtx, outputTarget, doc);
 };
 const injectRegisterServiceWorker = async (buildCtx, outputTarget, doc) => {
-	const serviceWorker = getRegisterSwScript(doc, buildCtx, generateServiceWorkerUrl(outputTarget, outputTarget.serviceWorker));
+	const swUrl = generateServiceWorkerUrl(outputTarget, outputTarget.serviceWorker);
+	const serviceWorker = getRegisterSwScript(doc, buildCtx, swUrl);
 	doc.body.appendChild(serviceWorker);
 };
 const injectUnregisterServiceWorker = (doc) => {
@@ -9826,7 +10097,7 @@ function readModulePaths(code) {
 function isImportOrExportDecl(stmt) {
 	return ts.isExportDeclaration(stmt) || ts.isImportDeclaration(stmt);
 }
-const MAX_JS_INLINE_SIZE = 1 * 1024;
+const MAX_JS_INLINE_SIZE = 1024;
 //#endregion
 //#region src/compiler/html/inline-style-sheets.ts
 const inlineStyleSheets = (compilerCtx, doc, maxSize, outputTarget) => {
@@ -9928,7 +10199,10 @@ const generateWww = async (config, compilerCtx, buildCtx, criticalPath, outputTa
 	}
 	if (!skipHtml) {
 		if (buildCtx.indexDoc && outputTarget.indexHtml) await generateIndexHtml(config, compilerCtx, buildCtx, criticalPath, outputTarget, globalStylesMap);
-		for (const [relPath, doc] of buildCtx.htmlDocs) await generateHtmlFile(config, compilerCtx, buildCtx, doc, join$2(outputTarget.appDir, relPath), outputTarget, globalStylesMap);
+		for (const [relPath, doc] of buildCtx.htmlDocs) {
+			const destPath = join$2(outputTarget.appDir, relPath);
+			await generateHtmlFile(config, compilerCtx, buildCtx, doc, destPath, outputTarget, globalStylesMap);
+		}
 	}
 	await generateHostConfig(compilerCtx, outputTarget);
 };
@@ -10013,24 +10287,26 @@ const generateIndexHtml = async (config, compilerCtx, buildCtx, criticalPath, ou
 */
 const generateHtmlFile = async (config, compilerCtx, buildCtx, doc, destPath, outputTarget, globalStylesMap) => {
 	try {
-		await processHtmlDoc(config, compilerCtx, buildCtx, cloneDocument(doc), destPath, outputTarget, globalStylesMap);
+		const cloned = cloneDocument(doc);
+		await processHtmlDoc(config, compilerCtx, buildCtx, cloned, destPath, outputTarget, globalStylesMap);
 	} catch (e) {
 		catchError(buildCtx.diagnostics, e);
 	}
 };
-const MAX_CSS_INLINE_SIZE = 3 * 1024;
+const MAX_CSS_INLINE_SIZE = 3072;
 //#endregion
 //#region src/compiler/transformers/component-ssr/ssr-runtime-cmp-meta.ts
 const addHydrateRuntimeCmpMeta = (classMembers, cmp, buildCtx) => {
 	const compactMeta = formatComponentRuntimeMeta(cmp, true);
-	const staticMember = createStaticGetter("cmpMeta", convertValueToLiteral({
+	const cmpMeta = {
 		$flags$: compactMeta[0],
 		$tagName$: compactMeta[1],
 		$members$: compactMeta[2],
 		$listeners$: compactMeta[3],
 		$lazyBundleId$: fakeBundleIds(cmp),
 		$attrsToReflect$: getHydrateAttrsToReflect(cmp)
-	}));
+	};
+	const staticMember = createStaticGetter("cmpMeta", convertValueToLiteral(cmpMeta));
 	addStaticStyleGetterWithinClass(classMembers, cmp, buildCtx);
 	classMembers.push(staticMember);
 };
@@ -10156,7 +10432,7 @@ const getSsrBuildConditionals = (config, cmps) => {
 */
 const bundleSsrFactory = async (config, compilerCtx, buildCtx, appFactoryEntryCode) => {
 	try {
-		return await bundleOutput(config, compilerCtx, buildCtx, {
+		const bundleOpts = {
 			id: "ssr",
 			platform: "ssr",
 			conditionals: getSsrBuildConditionals(config, buildCtx.components),
@@ -10164,7 +10440,8 @@ const bundleSsrFactory = async (config, compilerCtx, buildCtx, appFactoryEntryCo
 			codeSplitting: false,
 			inputs: { "@stencil/core/runtime/server/ssr-factory": "@stencil/core/runtime/server/ssr-factory" },
 			loader: { "@stencil/core/runtime/server/ssr-factory": appFactoryEntryCode }
-		});
+		};
+		return await bundleOutput(config, compilerCtx, buildCtx, bundleOpts);
 	} catch (e) {
 		if (!buildCtx.hasError && isRolldownError(e)) loadRolldownDiagnostics(config, compilerCtx, buildCtx, e);
 	}
@@ -10358,7 +10635,8 @@ const SSR_FACTORY_OUTRO = `
 * @returns The updated component metadata array.
 */
 const updateSsrComponents = async (cmps) => {
-	return sortBy(await Promise.all(cmps.map(updateSsrComponent)), (c) => c.cmp.componentClassName);
+	const ssrCmps = await Promise.all(cmps.map(updateSsrComponent));
+	return sortBy(ssrCmps, (c) => c.cmp.componentClassName);
 };
 const updateSsrComponent = async (cmp) => {
 	const cmpData = {
@@ -10478,7 +10756,8 @@ const writeSsrOutput = async (config, compilerCtx, buildCtx, outputTarget, rolld
 	}));
 };
 const copySsrRunnerDts = async (config, compilerCtx, hydrateAppDirPath) => {
-	const srcSsrDir = join$2(join$2(config.sys.getCompilerExecutingPath(), "..", ".."), "runtime", "server", "runner.d.mts");
+	const packageDir = join$2(config.sys.getCompilerExecutingPath(), "..", "..");
+	const srcSsrDir = join$2(packageDir, "runtime", "server", "runner.d.mts");
 	const runnerDtsDestPath = join$2(hydrateAppDirPath, "index.d.ts");
 	await compilerCtx.fs.copyFile(srcSsrDir, runnerDtsDestPath);
 };
@@ -10495,11 +10774,12 @@ const copySsrRunnerDts = async (config, compilerCtx, hydrateAppDirPath) => {
 */
 const buildSsrAppFor = async (format, rolldownBuild, config, compilerCtx, buildCtx, outputTargets) => {
 	const file = format === "esm" ? "index.js" : "index.cjs";
-	await writeSsrOutputs(config, compilerCtx, buildCtx, outputTargets, await rolldownBuild.generate({
+	const rolldownOutput = await rolldownBuild.generate({
 		banner: generatePreamble(config),
 		format,
 		file
-	}));
+	});
+	await writeSsrOutputs(config, compilerCtx, buildCtx, outputTargets, rolldownOutput);
 };
 /**
 * Generate and build the SSR app and then write it to disk
@@ -10514,7 +10794,7 @@ const generateSsrApp = async (config, compilerCtx, buildCtx, outputTargets) => {
 		const packageDir = join$2(config.sys.getCompilerExecutingPath(), "..", "..");
 		const input = join$2(packageDir, "runtime", "server", "runner.mjs");
 		const appData = join$2(packageDir, "runtime", "app-data", "index.js");
-		const rolldownAppBuild = await rolldown({
+		const rolldownOptions = {
 			...config.rolldownConfig,
 			external: ["node:stream"],
 			input,
@@ -10549,7 +10829,8 @@ const generateSsrApp = async (config, compilerCtx, buildCtx, outputTargets) => {
 			treeshake: false,
 			onwarn: createOnWarnFn(buildCtx.diagnostics),
 			checks: { pluginTimings: config.logLevel === "debug" }
-		});
+		};
+		const rolldownAppBuild = await rolldown(rolldownOptions);
 		const buildPromises = [buildSsrAppFor("esm", rolldownAppBuild, config, compilerCtx, buildCtx, outputTargets)];
 		if (outputTargets.some((o) => o.cjs)) buildPromises.push(buildSsrAppFor("cjs", rolldownAppBuild, config, compilerCtx, buildCtx, outputTargets));
 		await Promise.all(buildPromises);
@@ -10559,7 +10840,8 @@ const generateSsrApp = async (config, compilerCtx, buildCtx, outputTargets) => {
 };
 const generateSsrFactory = async (config, compilerCtx, buildCtx) => {
 	if (!buildCtx.hasError) try {
-		const rolldownFactoryBuild = await bundleSsrFactory(config, compilerCtx, buildCtx, await generateSsrFactoryEntry(buildCtx));
+		const appFactoryEntryCode = await generateSsrFactoryEntry(buildCtx);
+		const rolldownFactoryBuild = await bundleSsrFactory(config, compilerCtx, buildCtx, appFactoryEntryCode);
 		if (rolldownFactoryBuild != null) {
 			const rolldownOutput = await rolldownFactoryBuild.generate({
 				format: "cjs",
@@ -10648,7 +10930,7 @@ const generateSsrWasmApp = async (config, compilerCtx, buildCtx, outputTargets)
 		const packageDir = join$2(config.sys.getCompilerExecutingPath(), "..", "..");
 		const input = join$2(packageDir, "runtime", "server", "runner.mjs");
 		const appData = join$2(packageDir, "runtime", "app-data", "index.js");
-		const rolldownOutput = await (await rolldown({
+		const rolldownOptions = {
 			...config.rolldownConfig,
 			external: [],
 			input,
@@ -10679,7 +10961,8 @@ const generateSsrWasmApp = async (config, compilerCtx, buildCtx, outputTargets)
 			transform: { target: "es2020" },
 			onwarn: createOnWarnFn(buildCtx.diagnostics),
 			checks: { pluginTimings: config.logLevel === "debug" }
-		})).generate({
+		};
+		const rolldownOutput = await (await rolldown(rolldownOptions)).generate({
 			banner: generatePreamble(config) + SSR_WASM_TIMER_POLYFILL,
 			outro: SSR_WASM_OUTRO,
 			format: "iife",
@@ -10912,7 +11195,8 @@ const createComponentMetadataProxy = (compilerMeta) => {
 * @returns the generated call expression
 */
 const createClassMetadataProxy = (compilerMeta, clazz) => {
-	const literalMeta = convertValueToLiteral(formatComponentRuntimeMeta(compilerMeta, true));
+	const compactMeta = formatComponentRuntimeMeta(compilerMeta, true);
+	const literalMeta = convertValueToLiteral(compactMeta);
 	return ts.factory.createCallExpression(ts.factory.createIdentifier(PROXY_CUSTOM_ELEMENT), [], [clazz, literalMeta]);
 };
 //#endregion
@@ -10947,7 +11231,8 @@ const proxyCustomElement = (compilerCtx, transformOpts) => {
 			for (const [stmtIndex, stmt] of tsSourceFile.statements.entries()) if (ts.isVariableStatement(stmt)) for (const [declarationIndex, declaration] of stmt.declarationList.declarations.entries()) {
 				if (declaration.name.getText() !== principalComponent.componentClassName) continue;
 				if (!ts.isClassExpression(declaration.initializer)) continue;
-				const proxyCreationCall = createClassMetadataProxy(principalComponent, ts.factory.updateClassExpression(declaration.initializer, ts.getModifiers(declaration.initializer), ts.factory.createIdentifier(principalComponent.componentClassName), declaration.initializer.typeParameters, declaration.initializer.heritageClauses, declaration.initializer.members));
+				const renamedClassExpression = ts.factory.updateClassExpression(declaration.initializer, ts.getModifiers(declaration.initializer), ts.factory.createIdentifier(principalComponent.componentClassName), declaration.initializer.typeParameters, declaration.initializer.heritageClauses, declaration.initializer.members);
+				const proxyCreationCall = createClassMetadataProxy(principalComponent, renamedClassExpression);
 				ts.addSyntheticLeadingComment(proxyCreationCall, ts.SyntaxKind.MultiLineCommentTrivia, "@__PURE__", false);
 				const proxiedComponentDeclaration = ts.factory.updateVariableDeclaration(declaration, declaration.name, declaration.exclamationToken, declaration.type, proxyCreationCall);
 				const updatedDeclarationList = ts.factory.updateVariableDeclarationList(stmt.declarationList, [
@@ -11111,11 +11396,12 @@ function createStatesAddCall(memberName, stateName) {
 const updateNativeConstructor = (classMembers, moduleFile, cmp, classNode) => {
 	if (cmp.isPlain) return;
 	const cstrMethodArgs = [ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier("registerHost"))];
-	updateConstructor(classNode, classMembers, [
+	const nativeCstrStatements = [
 		...nativeInit(cmp),
 		...addCreateEvents(moduleFile, cmp),
 		...createNativeAttachInternalsBinding(cmp)
-	], cstrMethodArgs, cmp.doesExtend);
+	];
+	updateConstructor(classNode, classMembers, nativeCstrStatements, cstrMethodArgs, cmp.doesExtend);
 };
 /**
 * Generates a series of expression statements used to help initialize a Stencil component
@@ -11169,8 +11455,10 @@ const addNativeComponentMeta = (classMembers, cmp) => {
 //#endregion
 //#region src/compiler/transformers/component-native/native-static-style.ts
 const addNativeStaticStyle = (classMembers, cmp, buildCtx) => {
-	if (Array.isArray(cmp.styles) && cmp.styles.length > 0) if (cmp.styles.length > 1 || cmp.styles.length === 1 && cmp.styles[0].modeName !== "$") addMultipleModeStyleGetter(classMembers, cmp, cmp.styles, buildCtx);
-	else addSingleStyleGetter(classMembers, cmp, cmp.styles[0], buildCtx);
+	if (Array.isArray(cmp.styles) && cmp.styles.length > 0) {
+		if (cmp.styles.length > 1 || cmp.styles.length === 1 && cmp.styles[0].modeName !== "$") addMultipleModeStyleGetter(classMembers, cmp, cmp.styles, buildCtx);
+		else addSingleStyleGetter(classMembers, cmp, cmp.styles[0], buildCtx);
+	}
 };
 const addMultipleModeStyleGetter = (classMembers, cmp, styles, buildCtx) => {
 	const styleModes = [];
@@ -11309,7 +11597,8 @@ const updateNativeHostComponentHeritageClauses = (classNode, moduleFile) => {
 */
 const updateNativeBaseClass = (node, moduleFile) => {
 	const withHeritageClauses = updateNativeHostComponentHeritageClauses(node, moduleFile);
-	const membersWithCtor = updateConstructor(withHeritageClauses, removeStaticMetaProperties(withHeritageClauses), [], void 0, false);
+	const members = removeStaticMetaProperties(withHeritageClauses);
+	const membersWithCtor = updateConstructor(withHeritageClauses, members, [], void 0, false);
 	return ts.factory.updateClassDeclaration(withHeritageClauses, withHeritageClauses.modifiers, withHeritageClauses.name, withHeritageClauses.typeParameters, withHeritageClauses.heritageClauses, membersWithCtor);
 };
 /**
@@ -11417,9 +11706,11 @@ 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 assetPathInit = relativeAssetPath ? `setAssetPath(new URL('${relativeAssetPath}', String(import.meta.url)).href);\n` : "";
 	return `
 import { transformTag, getRegistry } from '${STENCIL_INTERNAL_STANDALONE_CLIENT_PLATFORM_ID}';
-${relativeAssetPath ? `import { setAssetPath } from '${STENCIL_INTERNAL_STANDALONE_CLIENT_PLATFORM_ID}';\n` : ""}${relativeAssetPath ? `setAssetPath(new URL('${relativeAssetPath}', String(import.meta.url)).href);\n` : ""}
+${assetPathImport}${assetPathInit}
 
 /**
  * Tag names built at compile time.
@@ -11453,13 +11744,13 @@ let observer;
 /**
  * Scan a root element for undefined custom elements and load them.
  *
- * Before any modules are imported we do two things to guarantee the documented
- * Stencil lifecycle ordering (componentWillLoad top-down, componentDidLoad
- * bottom-up) regardless of module-load race conditions:
+ * Before any modules are imported we do 3 things to guarantee the documented
+ * Stencil lifecycle ordering (connectedCallback/componentWillLoad top-down,
+ * componentDidLoad bottom-up) regardless of which tag's chunk happens to resolve first:
  *
- * 1. Pre-mark every not-yet-upgraded Stencil element with empty \`s-p\`/\`s-rc\`
- *    arrays so the runtime's connectedCallback ancestor walk can always find a
- *    parent element even before it has been upgraded.
+ * 1. Pre-mark every not-yet-upgraded Stencil element with empty \`s-p\`/\`s-rc\`/\`s-pc\`
+ *    arrays so the runtime's connectedCallback ancestor walk can always find a parent
+ *    element even before it has been upgraded (see \`connected-callback.ts\`).
  *
  * 2. For every child Stencil element, push a Promise into its nearest Stencil
  *    ancestor's \`s-p\` array. That Promise resolves only after the child's full
@@ -11468,6 +11759,15 @@ let observer;
  *    descendants are ready - even when a descendant's module loads *after* the
  *    ancestor has already started rendering.
  *
+ * 3. Likewise, push a Promise into the ancestor's \`s-pc\` array that resolves once the
+ *    child's real \`connectedCallback\` has fired (\`s-fc\`). Without this, an ancestor
+ *    whose own module resolves before an unconnected child's would check \`s-pc\` (see
+ *    \`scheduleUpdate\` in \`update-component.ts\`) before that child ever got a chance to
+ *    register itself via \`attachToAncestor\` - since a not-yet-defined child doesn't
+ *    connect (and self-register) until its own module import resolves. Pre-registering
+ *    here means the ancestor's \`componentWillLoad\` always waits for it, however long
+ *    that import takes.
+ *
  * @param root - The root element to scan
  */
 async function load(root) {
@@ -11480,6 +11780,7 @@ async function load(root) {
     if (lookup[rootTag]) {
       if (!root['s-p']) root['s-p'] = [];
       if (!root['s-rc']) root['s-rc'] = [];
+      if (!root['s-pc']) root['s-pc'] = [];
       if (!defined.has(rootTag)) pending.add(rootTag);
       elements.push(root);
     }
@@ -11491,6 +11792,7 @@ async function load(root) {
     if (lookup[tag]) {
       if (!el['s-p']) el['s-p'] = [];
       if (!el['s-rc']) el['s-rc'] = [];
+      if (!el['s-pc']) el['s-pc'] = [];
       if (!defined.has(tag)) pending.add(tag);
       elements.push(el);
     }
@@ -11513,6 +11815,11 @@ async function load(root) {
         ancestor['s-p'].push(
           reg.whenDefined(tag).then(() => el['s-rp'])
         );
+        // Same idea, but resolving once the child's real connectedCallback has fired
+        // rather than once its full initial lifecycle has completed.
+        ancestor['s-pc'].push(
+          reg.whenDefined(tag).then(() => el['s-fc'])
+        );
         break;
       }
       ancestor = ancestor.parentElement;
@@ -12045,11 +12352,12 @@ const getTypescriptPathFromUrl = (config, tsExecutingUrl, url) => {
 	const tsBaseUrl = new URL("..", tsExecutingUrl).href;
 	if (url.startsWith(tsBaseUrl)) {
 		const tsFilePath = url.replace(tsBaseUrl, "/");
-		return normalizePath(config.sys.getLocalModulePath({
+		const tsNodePath = config.sys.getLocalModulePath({
 			rootDir: config.rootDir,
 			moduleId: "@stencil/core",
 			path: tsFilePath
-		}));
+		});
+		return normalizePath(tsNodePath);
 	}
 	return url;
 };
@@ -12092,9 +12400,25 @@ const tsResolveModuleNamePackageJsonPath = (config, compilerCtx, moduleName, con
 };
 //#endregion
 //#region src/compiler/transformers/static-to-meta/vdom.ts
-const gatherVdomMeta = (m, args) => {
+/**
+* Attempt to resolve an expression to a statically-known string value.
+* Handles plain string literals directly. For anything else, falls back to the type checker.
+*
+* @param expr the expression to resolve
+* @param typeChecker the type checker for the program being compiled, if available
+* @returns the statically-known string value, or `undefined` if it can't be determined
+*/
+const resolveStaticStringValue = (expr, typeChecker) => {
+	if (ts.isStringLiteralLike(expr)) return expr.text;
+	if (typeChecker) {
+		const type = typeChecker.getTypeAtLocation(expr);
+		if (type.isStringLiteral()) return type.value;
+	}
+};
+const gatherVdomMeta = (m, args, typeChecker) => {
 	m.hasVdomRender = true;
 	const hTag = args[0];
+	const isSlotTag = ts.isStringLiteral(hTag) && hTag.text === "slot";
 	if (!ts.isStringLiteral(hTag) && (!ts.isIdentifier(hTag) || hTag.text !== "Host")) m.hasVdomFunctional = true;
 	if (args.length > 1) {
 		const objectLiteral = args[1];
@@ -12107,32 +12431,46 @@ const gatherVdomMeta = (m, args) => {
 			m.hasVdomRef = true;
 			m.hasVdomStyle = true;
 			m.hasVdomXlink = true;
-		} else if (ts.isObjectLiteralExpression(objectLiteral)) objectLiteral.properties.forEach((prop) => {
-			m.hasVdomAttribute = true;
-			if (ts.isSpreadAssignment(prop) || ts.isComputedPropertyName(prop.name)) {
-				m.hasVdomClass = true;
-				m.hasVdomKey = true;
-				m.hasVdomListener = true;
-				m.hasVdomPropOrAttr = true;
-				m.hasVdomRef = true;
-				m.hasVdomStyle = true;
-				m.hasVdomXlink = true;
-			} else if (prop.name && prop.name.text && prop.name.text.length > 0) {
-				const attrName = prop.name.text;
-				if (attrName === "key") m.hasVdomKey = true;
-				else if (attrName === "ref") m.hasVdomRef = true;
-				else if (attrName === "class" || attrName === "className") m.hasVdomClass = true;
-				else if (attrName === "style") m.hasVdomStyle = true;
-				else if (/^on(-|[A-Z])/.test(attrName)) m.hasVdomListener = true;
-				else if (attrName.startsWith("xlink")) {
-					m.hasVdomXlink = true;
+		} else if (ts.isObjectLiteralExpression(objectLiteral)) {
+			let slotName;
+			let hasDynamicSlotName = false;
+			objectLiteral.properties.forEach((prop) => {
+				m.hasVdomAttribute = true;
+				if (ts.isSpreadAssignment(prop) || ts.isComputedPropertyName(prop.name)) {
+					m.hasVdomClass = true;
+					m.hasVdomKey = true;
+					m.hasVdomListener = true;
 					m.hasVdomPropOrAttr = true;
-				} else m.hasVdomPropOrAttr = true;
-				if (attrName === "part" && ts.isPropertyAssignment(prop) && ts.isStringLiteral(prop.initializer)) m.htmlParts.push(...prop.initializer.text.toLowerCase().split(" ").filter((part) => part.length > 0));
-				m.htmlAttrNames.push(attrName);
-			}
-		});
-	}
+					m.hasVdomRef = true;
+					m.hasVdomStyle = true;
+					m.hasVdomXlink = true;
+					hasDynamicSlotName = isSlotTag || hasDynamicSlotName;
+				} else if (prop.name && prop.name.text && prop.name.text.length > 0) {
+					const attrName = prop.name.text;
+					if (attrName === "key") m.hasVdomKey = true;
+					else if (attrName === "ref") m.hasVdomRef = true;
+					else if (attrName === "class" || attrName === "className") m.hasVdomClass = true;
+					else if (attrName === "style") m.hasVdomStyle = true;
+					else if (/^on(-|[A-Z])/.test(attrName)) m.hasVdomListener = true;
+					else if (attrName.startsWith("xlink")) {
+						m.hasVdomXlink = true;
+						m.hasVdomPropOrAttr = true;
+					} else m.hasVdomPropOrAttr = true;
+					if (attrName === "part" && ts.isPropertyAssignment(prop)) {
+						const partValue = resolveStaticStringValue(prop.initializer, typeChecker);
+						if (partValue !== void 0) m.htmlParts.push(...partValue.split(" ").filter((part) => part.length > 0));
+					}
+					if (isSlotTag && attrName === "name" && ts.isPropertyAssignment(prop)) {
+						const resolvedSlotName = resolveStaticStringValue(prop.initializer, typeChecker);
+						if (resolvedSlotName !== void 0) slotName = resolvedSlotName;
+						else hasDynamicSlotName = true;
+					}
+					m.htmlAttrNames.push(attrName);
+				}
+			});
+			if (isSlotTag && !hasDynamicSlotName) m.htmlSlots.push(slotName ?? "");
+		} else if (isSlotTag) m.htmlSlots.push("");
+	} else if (isSlotTag) m.htmlSlots.push("");
 	if (!m.hasVdomText) for (let i = 2; i < args.length; i++) {
 		const arg = args[i];
 		if (!ts.isCallExpression(arg) || !ts.isIdentifier(arg.expression) || arg.expression.text !== "h") {
@@ -12170,10 +12508,10 @@ const visitCallExpressionArgs = (m, callExpressionName, args, typeChecker) => {
 	const fnName = callExpressionName.escapedText;
 	if (fnName === "h" || fnName === "__stencil_h" || fnName === "createElement") {
 		visitCallExpressionArg(m, args[0], typeChecker);
-		if (fnName === "h" || fnName === "__stencil_h") gatherVdomMeta(m, args);
+		if (fnName === "h" || fnName === "__stencil_h") gatherVdomMeta(m, args, typeChecker);
 	} else if (fnName === "jsx" || fnName === "jsxs" || fnName === "_jsx" || fnName === "_jsxs") {
 		visitCallExpressionArg(m, args[0], typeChecker);
-		gatherVdomMeta(m, args);
+		gatherVdomMeta(m, args, typeChecker);
 		if (args.length > 2 && args[2]) m.hasVdomKey = true;
 	} else if (args.length > 1 && fnName === "createElementNS") visitCallExpressionArg(m, args[1], typeChecker);
 	else if (fnName === "require" && args.length > 0 && m.originalImports) {
@@ -12229,7 +12567,8 @@ const resolveFunctionalComponentDep = (m, identifier, typeChecker) => {
 * @returns the updated typescript class declaration
 */
 const addComponentMetaStatic = (cmpNode, cmpMeta) => {
-	const cmpMetaStaticProp = createStaticGetter("COMPILER_META", convertValueToLiteral(getPublicCompilerMeta(cmpMeta)));
+	const publicCompilerMeta = getPublicCompilerMeta(cmpMeta);
+	const cmpMetaStaticProp = createStaticGetter("COMPILER_META", convertValueToLiteral(publicCompilerMeta));
 	const classMembers = [...cmpNode.members, cmpMetaStaticProp];
 	return ts.factory.updateClassDeclaration(cmpNode, retrieveModifierLike(cmpNode), cmpNode.name, cmpNode.typeParameters, cmpNode.heritageClauses, classMembers);
 };
@@ -12277,7 +12616,7 @@ const setComponentBuildConditionals = (cmpMeta) => {
 		cmpMeta.hasStyle = true;
 		cmpMeta.hasMode = cmpMeta.styles.some((s) => s.modeName !== "$");
 	}
-	cmpMeta.hasLifecycle = cmpMeta.hasComponentWillLoadFn || cmpMeta.hasComponentDidLoadFn || cmpMeta.hasComponentShouldUpdateFn || cmpMeta.hasComponentWillUpdateFn || cmpMeta.hasComponentDidUpdateFn || cmpMeta.hasComponentWillRenderFn || cmpMeta.hasComponentDidRenderFn;
+	cmpMeta.hasLifecycle = cmpMeta.hasComponentWillLoadFn || cmpMeta.hasComponentDidLoadFn || cmpMeta.hasComponentShouldUpdateFn || cmpMeta.hasComponentWillUpdateFn || cmpMeta.hasComponentDidUpdateFn || cmpMeta.hasComponentWillRenderFn || cmpMeta.hasComponentDidRenderFn || cmpMeta.hasConnectedCallbackFn || cmpMeta.hasDisconnectedCallbackFn;
 	cmpMeta.isPlain = !cmpMeta.hasMember && !cmpMeta.hasStyle && !cmpMeta.hasLifecycle && !cmpMeta.hasListener && !cmpMeta.hasVdomRender;
 	if (cmpMeta.patches) {
 		cmpMeta.hasPatchAll = !!cmpMeta.patches.all;
@@ -12405,7 +12744,8 @@ const getDecoratorParameter = (arg, typeChecker, diagnostics, errorNode) => {
 */
 const resolveVariableValue = (node, typeChecker, diagnostics, errorNode) => {
 	if (ts.isIdentifier(node)) {
-		const symbol = typeChecker.getSymbolAtLocation(node);
+		let symbol = typeChecker.getSymbolAtLocation(node);
+		if (symbol && symbol.flags & ts.SymbolFlags.Alias) symbol = typeChecker.getAliasedSymbol(symbol);
 		if (!symbol || !symbol.valueDeclaration) {
 			const err = buildError(diagnostics);
 			err.messageText = `resolveVar() cannot resolve the value of "${node.text}" at compile time. Only const variables and object properties with string literal values are supported.`;
@@ -12605,8 +12945,10 @@ function parseCustomStatesFromDecorator(decorator, typeChecker) {
 //#region src/compiler/transformers/decorators-to-static/style-to-static.ts
 const styleToStatic = (newMembers, componentOptions) => {
 	const defaultModeStyles = [];
-	if (componentOptions.styleUrls) if (Array.isArray(componentOptions.styleUrls)) defaultModeStyles.push(...normalizeStyleUrl(componentOptions.styleUrls));
-	else defaultModeStyles.push(...normalizeStyleUrl(componentOptions.styleUrls["$"]));
+	if (componentOptions.styleUrls) {
+		if (Array.isArray(componentOptions.styleUrls)) defaultModeStyles.push(...normalizeStyleUrl(componentOptions.styleUrls));
+		else defaultModeStyles.push(...normalizeStyleUrl(componentOptions.styleUrls["$"]));
+	}
 	if (componentOptions.styleUrl) defaultModeStyles.push(...normalizeStyleUrl(componentOptions.styleUrl));
 	let styleUrls = {};
 	if (componentOptions.styleUrls && !Array.isArray(componentOptions.styleUrls)) styleUrls = normalizeStyleUrls(componentOptions.styleUrls);
@@ -12614,7 +12956,8 @@ const styleToStatic = (newMembers, componentOptions) => {
 	if (Object.keys(styleUrls).length > 0) {
 		const originalStyleUrls = convertValueToLiteral(styleUrls);
 		newMembers.push(createStaticGetter("originalStyleUrls", originalStyleUrls));
-		const normalizedStyleExp = convertValueToLiteral(normalizeExtension(styleUrls));
+		const norlizedStyleExt = normalizeExtension(styleUrls);
+		const normalizedStyleExp = convertValueToLiteral(norlizedStyleExt);
 		newMembers.push(createStaticGetter("styleUrls", normalizedStyleExp));
 	}
 	if (componentOptions.globalStyleUrl) newMembers.push(createStaticGetter("originalGlobalStyleUrl", convertValueToLiteral(componentOptions.globalStyleUrl)));
@@ -12643,7 +12986,10 @@ const normalizeExtension = (styleUrls) => {
 	return compilerStyleUrls;
 };
 const useCss = (stylePath) => {
-	return join$2(dirname$1(stylePath), basename$1(stylePath, extname(stylePath)) + ".css");
+	const sourceFileDir = dirname$1(stylePath);
+	const sourceFileExt = extname(stylePath);
+	const sourceFileName = basename$1(stylePath, sourceFileExt);
+	return join$2(sourceFileDir, sourceFileName + ".css");
 };
 const normalizeStyleUrls = (styleUrls) => {
 	const compilerStyleUrls = {};
@@ -12793,6 +13139,13 @@ const validateComponent = (config, diagnostics, typeChecker, componentOptions, c
 			}
 		}
 	}
+	const modeError = validateComponentModes(config.modes, componentOptions);
+	if (modeError) {
+		const err = buildError(diagnostics);
+		err.messageText = modeError.message;
+		augmentDiagnosticWithNode(err, findTagNode(modeError.propName, componentDecorator));
+		return false;
+	}
 	const constructor = cmpNode.members.find(ts.isConstructorDeclaration);
 	if (constructor && constructor.parameters.length > 0) {
 		const err = buildError(diagnostics);
@@ -12830,7 +13183,8 @@ const validateComponent = (config, diagnostics, typeChecker, componentOptions, c
 			err.messageText = `To allow efficient bundling, modules using @Component() can only have a single export which is the component class itself.
       Any other exports should be moved to a separate file.
       For further information check out: https://stenciljs.com/docs/module-bundling`;
-			augmentDiagnosticWithNode(err, symbol.valueDeclaration ? symbol.valueDeclaration : symbol.declarations[0]);
+			const errorNode = symbol.valueDeclaration ? symbol.valueDeclaration : symbol.declarations[0];
+			augmentDiagnosticWithNode(err, errorNode);
 		});
 		if (nonTypeExports.length > 0) return false;
 	}
@@ -13007,7 +13361,7 @@ const validateEventName = (config, diagnostics, node, eventName) => {
 		augmentDiagnosticWithNode(warn, node);
 		return;
 	}
-	if (!config.suppressReservedEventNameWarnings && DOM_EVENT_NAMES.has(eventName.toLowerCase())) {
+	if (!config.compat?.suppressEventNameWarnings && DOM_EVENT_NAMES.has(eventName.toLowerCase())) {
 		const diagnostic = buildWarn(diagnostics);
 		diagnostic.messageText = `The event name conflicts with the "${eventName}" native DOM event name.`;
 		augmentDiagnosticWithNode(diagnostic, node);
@@ -13306,7 +13660,8 @@ var ImportAliasMap = class extends Map {
 //#endregion
 //#region src/compiler/transformers/decorators-to-static/listen-decorator.ts
 const listenDecoratorsToStatic = (diagnostics, typeChecker, decoratedMembers, newMembers, decoratorName) => {
-	const flatListeners = flatOne(decoratedMembers.filter(ts.isMethodDeclaration).map((method) => parseListenDecorators(diagnostics, typeChecker, method, decoratorName)));
+	const listeners = decoratedMembers.filter(ts.isMethodDeclaration).map((method) => parseListenDecorators(diagnostics, typeChecker, method, decoratorName));
+	const flatListeners = flatOne(listeners);
 	if (flatListeners.length > 0) newMembers.push(createStaticGetter("listeners", convertValueToLiteral(flatListeners)));
 };
 const parseListenDecorators = (diagnostics, typeChecker, method, decoratorName) => {
@@ -13340,7 +13695,7 @@ const parseListener = (eventName, opts = {}, methodName) => {
 		passive: typeof opts.passive === "boolean" ? opts.passive : PASSIVE_TRUE_DEFAULTS.has(rawEventName.toLowerCase())
 	};
 };
-const PASSIVE_TRUE_DEFAULTS = new Set([
+const PASSIVE_TRUE_DEFAULTS = /* @__PURE__ */ new Set([
 	"dragstart",
 	"drag",
 	"dragend",
@@ -13389,7 +13744,7 @@ const PASSIVE_TRUE_DEFAULTS = new Set([
 * @param node the TypeScript AST node at which the class member is defined
 */
 const validatePublicName = (config, diagnostics, memberName, decorator, memberType, node) => {
-	if (config.suppressReservedPublicNameWarnings) return;
+	if (config.compat?.suppressPublicNameWarnings) return;
 	if (RESERVED_PUBLIC_MEMBERS.has(memberName.toLowerCase())) {
 		const warn = buildWarn(diagnostics);
 		warn.messageText = [
@@ -13800,7 +14155,8 @@ const parsePropDecorator = (config, diagnostics, typeChecker, program, prop, dec
 		const returnExpression = (prop.body?.statements.find((st) => ts.isReturnStatement(st))).expression;
 		if (returnExpression && ts.isLiteralExpression(returnExpression)) propMeta.defaultValue = returnExpression.getText();
 		else if (returnExpression && ts.isPropertyAccessExpression(returnExpression)) {
-			const foundProp = findGetProp(returnExpression.name.getText(), newMembers);
+			const nameToFind = returnExpression.name.getText();
+			const foundProp = findGetProp(nameToFind, newMembers);
 			if (foundProp && foundProp.initializer) {
 				propMeta.defaultValue = resolveInitializerText(foundProp.initializer, typeChecker);
 				if (propMeta.type === "unknown") {
@@ -14088,8 +14444,10 @@ const serializeDecoratorsToStatic = (typeChecker, decoratedProps, newMembers, de
 		return [];
 	});
 	const serializers = decoratedProps.filter(ts.isMethodDeclaration).flatMap((method) => parseSerializeDecorator(typeChecker, method, decoratorName, props));
-	if (serializers.length > 0) if (translateType === "PropSerialize") newMembers.push(createStaticGetter("serializers", convertValueToLiteral(serializers)));
-	else newMembers.push(createStaticGetter("deserializers", convertValueToLiteral(serializers)));
+	if (serializers.length > 0) {
+		if (translateType === "PropSerialize") newMembers.push(createStaticGetter("serializers", convertValueToLiteral(serializers)));
+		else newMembers.push(createStaticGetter("deserializers", convertValueToLiteral(serializers)));
+	}
 	return serializers;
 };
 const parseSerializeDecorator = (typeChecker, method, decoratorName, props) => {
@@ -14145,7 +14503,8 @@ const stateDecoratorToStatic = (prop, typeChecker, decoratorName) => {
 //#endregion
 //#region src/compiler/transformers/decorators-to-static/watch-decorator.ts
 const watchDecoratorsToStatic = (typeChecker, decoratedProps, newMembers, decoratorName) => {
-	const flatWatchers = flatOne(decoratedProps.filter(ts.isMethodDeclaration).map((method) => parseWatchDecorator(typeChecker, method, decoratorName)));
+	const watchers = decoratedProps.filter(ts.isMethodDeclaration).map((method) => parseWatchDecorator(typeChecker, method, decoratorName));
+	const flatWatchers = flatOne(watchers);
 	if (flatWatchers.length > 0) newMembers.push(createStaticGetter("watchers", convertValueToLiteral(flatWatchers)));
 };
 const parseWatchDecorator = (typeChecker, method, decoratorName) => {
@@ -14266,19 +14625,21 @@ const removeStencilMethodDecorators = (classMembers, diagnostics, importAliasMap
 	return classMembers.map((member) => {
 		const currentDecorators = retrieveTsDecorators(member);
 		const newDecorators = filterDecorators(currentDecorators, MEMBER_DECORATORS_TO_REMOVE.map((decorator) => importAliasMap.get(decorator)));
-		if (currentDecorators !== newDecorators) if (ts.isMethodDeclaration(member)) return ts.factory.updateMethodDeclaration(member, [...newDecorators ?? [], ...retrieveTsModifiers(member) ?? []], member.asteriskToken, member.name, member.questionToken, member.typeParameters, member.parameters, member.type, member.body);
-		else if (ts.isGetAccessor(member)) return ts.factory.updateGetAccessorDeclaration(member, [...newDecorators ?? [], ...retrieveTsModifiers(member) ?? []], member.name, member.parameters, member.type, member.body);
-		else if (ts.isSetAccessor(member)) {
-			const err = buildError(diagnostics);
-			err.messageText = "A get accessor should be decorated before a set accessor";
-			augmentDiagnosticWithNode(err, member);
-		} else if (ts.isPropertyDeclaration(member)) {
-			const modifiers = retrieveTsModifiers(member);
-			return ts.factory.updatePropertyDeclaration(member, [...newDecorators ?? [], ...modifiers ?? []], member.name, member.questionToken, member.type, member.initializer);
-		} else {
-			const err = buildError(diagnostics);
-			err.messageText = "Unknown class member encountered!";
-			augmentDiagnosticWithNode(err, member);
+		if (currentDecorators !== newDecorators) {
+			if (ts.isMethodDeclaration(member)) return ts.factory.updateMethodDeclaration(member, [...newDecorators ?? [], ...retrieveTsModifiers(member) ?? []], member.asteriskToken, member.name, member.questionToken, member.typeParameters, member.parameters, member.type, member.body);
+			else if (ts.isGetAccessor(member)) return ts.factory.updateGetAccessorDeclaration(member, [...newDecorators ?? [], ...retrieveTsModifiers(member) ?? []], member.name, member.parameters, member.type, member.body);
+			else if (ts.isSetAccessor(member)) {
+				const err = buildError(diagnostics);
+				err.messageText = "A get accessor should be decorated before a set accessor";
+				augmentDiagnosticWithNode(err, member);
+			} else if (ts.isPropertyDeclaration(member)) {
+				const modifiers = retrieveTsModifiers(member);
+				return ts.factory.updatePropertyDeclaration(member, [...newDecorators ?? [], ...modifiers ?? []], member.name, member.questionToken, member.type, member.initializer);
+			} else {
+				const err = buildError(diagnostics);
+				err.messageText = "Unknown class member encountered!";
+				augmentDiagnosticWithNode(err, member);
+			}
 		}
 		return member;
 	});
@@ -14423,15 +14784,80 @@ const parseStaticWatchers = (staticMembers) => {
 	});
 };
 //#endregion
-//#region src/compiler/transformers/static-to-meta/class-extension.ts
+//#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 {}`).
+* @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`
+*/
+function findClassWalk(node, name) {
+	if (!node) return void 0;
+	if (ts.isClassDeclaration(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)) {
+		let found;
+		ts.forEachChild(node.initializer.body, (child) => {
+			if (found) return;
+			if (ts.isClassDeclaration(child)) found = child;
+		});
+		return found;
+	}
+	let found;
+	ts.forEachChild(node, (child) => {
+		if (found) return;
+		const result = findClassWalk(child, name);
+		if (result) found = result;
+	});
+	return found;
+}
+/**
+* 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`).
+* @param name the declaration name to match
+* @returns a predicate usable with `Array.prototype.find` over a source file's statements
+*/
+function matchesNamedDeclaration(name) {
+	return function(stmt) {
+		if (ts.isClassDeclaration(stmt) && stmt.name?.text === name) return true;
+		if (ts.isFunctionDeclaration(stmt) && stmt.name?.text === name) return true;
+		if (ts.isVariableStatement(stmt)) {
+			for (const decl of stmt.declarationList.declarations) if (ts.isIdentifier(decl.name) && decl.name.text === name) return true;
+		}
+		return false;
+	};
+}
+/**
+* Finds a re-export of `className` in `sourceFile` - `export { X } from './y'` or
+* `export { X as Y } from './y'` - as used by barrel entry points (e.g. `@stencil/core`'s own
+* public `index.d.mts`, which re-exports its runtime API from `./declarations/stencil-public-runtime`
+* rather than declaring it directly).
+* @param sourceFile the (barrel) source file to scan
+* @param className the exported name to look for
+* @returns the module specifier and the name to look for in that module (the local name, before
+* any `as` aliasing), or `undefined` if no matching re-export is found
+*/
+function findReExport(sourceFile, className) {
+	for (const stmt of sourceFile.statements) {
+		if (!ts.isExportDeclaration(stmt) || !stmt.moduleSpecifier || !ts.isStringLiteral(stmt.moduleSpecifier) || !stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) continue;
+		for (const element of stmt.exportClause.elements) if (element.name.text === className) return {
+			moduleSpecifier: stmt.moduleSpecifier.text,
+			localName: element.propertyName?.text ?? element.name.text
+		};
+	}
+}
 /**
-* Given two arrays of static members, return a new array containing only the
-* members from the first array that are not present in the second array.
-* This is used to de-dupe static members that are inherited from a parent class.
+* Filters `dedupeMembers` down to entries not already present in `staticMembers`
+* (by name, or `methodName` for change handlers) - used so an extending
+* class's own members win over inherited ones.
 *
-* @param dedupeMembers the array of static members to de-dupe
-* @param staticMembers the array of static members to compare against
-* @returns an array of static members that are not present in the second array
+* @param dedupeMembers the members to filter
+* @param staticMembers the members to filter against
+* @returns the filtered `dedupeMembers` array
 */
 const deDupeMembers = (dedupeMembers, staticMembers) => {
 	return dedupeMembers.filter((s) => !staticMembers.some((d) => {
@@ -14439,22 +14865,62 @@ const deDupeMembers = (dedupeMembers, staticMembers) => {
 		return d.name === s.name;
 	}));
 };
+const ensureRelativeSpecifier = (specifier) => {
+	return specifier.startsWith(".") ? specifier : `./${specifier}`;
+};
+/**
+* Re-anchors inherited members' complex-type references - recorded relative
+* to the file declaring them - so they resolve from the extending
+* component's file instead. Consumers like `components.d.ts` generation
+* always resolve a reference against the component, not the declaring class,
+* so an inherited reference from a different directory would otherwise
+* produce a broken import.
+*
+* `import` refs get their relative path rewritten; `local` refs (a type
+* declared in the extended class's own file) become `import` refs pointing
+* at that file. Also applies to `node_modules`-published collections:
+* `dist/types/` mirrors `dist/collection/` 1:1, so the same math works after
+* swapping one for the other (type-only declarations don't survive
+* compilation to `.js`, so a reference has to point at the `.d.ts` tree).
+*
+* @param members inherited members whose type references should be re-anchored
+* @param extendedClassFileName absolute path of the file declaring the extended class
+* @param cmpSourceFilePath absolute path of the extending component's source file
+* @returns the same members, with their type references re-anchored
+*/
+const reanchorInheritedTypeReferences = (members, extendedClassFileName, cmpSourceFilePath) => {
+	const extendedClassDir = dirname$1(normalizePath(extendedClassFileName, false));
+	const cmpDir = dirname$1(normalizePath(cmpSourceFilePath, false));
+	if (extendedClassDir === cmpDir) return members;
+	const isCollectionModule = isNodeModulePath(extendedClassFileName);
+	const toDeclarationPath = (path) => isCollectionModule ? path.replace("/collection/", "/types/") : path;
+	members.forEach((member) => {
+		const references = member.complexType?.references;
+		if (!references) return;
+		Object.values(references).forEach((reference) => {
+			if (reference.location === "import" && reference.path?.startsWith(".")) {
+				const typeModulePath = toDeclarationPath(join$2(extendedClassDir, reference.path));
+				reference.path = ensureRelativeSpecifier(relative$1(cmpDir, typeModulePath));
+			} else if (reference.location === "local") {
+				const extendedClassModule = toDeclarationPath(normalizePath(extendedClassFileName, false).replace(/\.(tsx|ts|js)$/, ""));
+				reference.location = "import";
+				reference.path = ensureRelativeSpecifier(relative$1(cmpDir, extendedClassModule));
+			}
+		});
+	});
+	return members;
+};
+//#endregion
+//#region src/compiler/transformers/static-to-meta/class-extension/compiler-ctx-merge.ts
 /**
-* When a parent-class source file is fetched directly from disk (via
-* {@link tsGetSourceFile}) rather than from the compiler's moduleMap cache, it
-* arrives with its original decorator syntax intact.  The static-meta parsers
-* (`parseStaticProps`, `parseStaticStates`, etc.) only understand the static-
-* getter form produced by {@link convertDecoratorsToStatic}.
-*
-* This helper creates a self-contained mini TypeScript program for the single
-* file and runs the decorator→static transformer on it, returning the
-* transformed source file.  Prop types may be under-resolved (external imports
-* are not available in the mini program) and will fall back to `any`, which is
-* acceptable for the purpose of walking the inheritance chain.
-*
+* Converts a disk-fetched parent source file (still decorator syntax) to
+* static-getter form via a throwaway single-file program - `parseStatic*`
+* only understands the static-getter form {@link convertDecoratorsToStatic}
+* produces. Cross-file imports can't resolve in this mini program, so prop
+* types may fall back to `any`, which is fine for just walking the chain.
 * @param sourceFile the raw (decorator-syntax) source file from disk
 * @param config the current Stencil validated config
-* @param target the script target to use when converting decorators to static (if needed)
+* @param target the script target to convert decorators with
 * @returns the source file with decorators converted to static getters
 */
 function convertDiskSourceFileDecorators(sourceFile, config, target = ts.ScriptTarget.ESNext) {
@@ -14475,26 +14941,24 @@ function convertDiskSourceFileDecorators(sourceFile, config, target = ts.ScriptT
 	return ts.createSourceFile(sourceFile.fileName, printed, target, true);
 }
 /**
-* Helper function to resolve and process an extended class from a module.
-* This handles:
-* 1. Resolving the module path
-* 2. Getting the source file
-* 3. Finding the class declaration
-* 4. Adding to dependent classes tree
-*
-* @param compilerCtx - the current compiler context
-* @param buildCtx - the current build context
-* @param classDeclaration - the current class being analyzed
-* @param currentSource - the source file of the current class
-* @param moduleSpecifier - the module path to resolve
-* @param className - the name of the class to find in the resolved module
-* @param dependentClasses - the array to add found classes to
-* @param typeChecker - the TypeScript type checker
-* @param ogModule - the original module file of the class declaration
-* @param targetScriptTarget - the script target to use when converting decorators to static (if needed)
-* @returns the found class declaration or undefined
+* Resolves an `extends` target through a module specifier: resolves the
+* module, finds the named class/mixin-factory export, and adds it (and its
+* own ancestors) to `dependentClasses`. Follows one level of re-export (barrel file) when the
+* declaration isn't found directly in the resolved module.
+* @param compilerCtx the current compiler context
+* @param buildCtx the current build context
+* @param classDeclaration the current class being analyzed
+* @param currentSource the source file of the current class
+* @param moduleSpecifier the module path to resolve
+* @param className the name of the class to find in the resolved module
+* @param dependentClasses the array to add found classes to
+* @param typeChecker the TypeScript type checker
+* @param ogModule the original module file of the class declaration
+* @param targetScriptTarget the script target to convert decorators with, if needed
+* @param barrelHopsRemaining re-export hops still allowed before giving up
+* @returns the found class declaration, or `undefined`
 */
-function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, moduleSpecifier, className, dependentClasses, typeChecker, ogModule, targetScriptTarget = ts.ScriptTarget.ESNext) {
+function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, moduleSpecifier, className, dependentClasses, typeChecker, ogModule, targetScriptTarget = ts.ScriptTarget.ESNext, barrelHopsRemaining = 1) {
 	let keepLooking = true;
 	const foundFile = tsResolveModuleName(buildCtx.config, compilerCtx, moduleSpecifier, currentSource.fileName);
 	if (!foundFile?.resolvedModule || !className) return;
@@ -14503,7 +14967,7 @@ function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration,
 		foundSource = tsGetSourceFile(buildCtx.config, foundFile);
 		if (!foundSource) {
 			const err = buildWarn(buildCtx.diagnostics);
-			err.messageText = `Unable to resolve import "${moduleSpecifier}" from "${currentSource.fileName}". 
+			err.messageText = `Unable to resolve import "${moduleSpecifier}" from "${currentSource.fileName}".
                     This can happen when trying to resolve .js files and "allowJs" is not set to "true" in your tsconfig.json.`;
 			if (!buildCtx.config._isTesting) augmentDiagnosticWithNode(err, classDeclaration);
 			return;
@@ -14512,8 +14976,10 @@ function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration,
 	}
 	const matchedStatement = foundSource.statements.find(matchesNamedDeclaration(className));
 	if (!matchedStatement) {
+		const reExport = barrelHopsRemaining > 0 ? findReExport(foundSource, className) : void 0;
+		if (reExport) return resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, foundSource, reExport.moduleSpecifier, reExport.localName, dependentClasses, typeChecker, ogModule, targetScriptTarget, barrelHopsRemaining - 1);
 		const err = buildWarn(buildCtx.diagnostics);
-		err.messageText = `Unable to find "${className}" in the imported module "${moduleSpecifier}". 
+		err.messageText = `Unable to find "${className}" in the imported module "${moduleSpecifier}".
                   Please import class / mixin-factory declarations directly and not via barrel files.`;
 		if (!buildCtx.config._isTesting) augmentDiagnosticWithNode(err, classDeclaration);
 		return;
@@ -14533,71 +14999,20 @@ function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration,
 	}
 	return foundClassDeclaration;
 }
-/**
-* A recursive function that walks the AST to find a class declaration.
-* @param node the current AST node
-* @param depth the current depth in the AST
-* @param name optional name of the class to find
-* @returns the found class declaration or undefined
-*/
-function findClassWalk(node, name, depth = 0) {
-	if (!node) return void 0;
-	if (node && ts.isClassDeclaration(node)) {
-		if (!name || node.name?.text === name) return node;
-	} else if (node && ts.isVariableDeclaration(node) && (!name || name === (node.name?.text || node.name?.escapedText)) && node.initializer && ts.isArrowFunction(node.initializer)) {
-		let found;
-		ts.forEachChild(node.initializer.body, (child) => {
-			if (found) return;
-			if (ts.isClassDeclaration(child)) found = child;
-		});
-		return found;
-	}
-	let found;
-	ts.forEachChild(node, (child) => {
-		if (found) return;
-		const result = findClassWalk(child, name, depth + 1);
-		if (result) found = result;
-	});
-	return found;
-}
-/**
-* A function that checks if a statement matches a named declaration.
-* @param name the name to match
-* @returns a function that checks if a statement is a named declaration
-*/
-function matchesNamedDeclaration(name) {
-	return function(stmt) {
-		if (ts.isClassDeclaration(stmt) && stmt.name?.text === name) return true;
-		if (ts.isFunctionDeclaration(stmt) && stmt.name?.text === name) return true;
-		if (ts.isVariableStatement(stmt)) {
-			for (const decl of stmt.declarationList.declarations) if (ts.isIdentifier(decl.name) && decl.name.text === name) return true;
-		}
-		return false;
-	};
-}
-/**
-* Helper function to convert a .d.ts declaration file path to its corresponding
-* .js source file path and get the source file from the compiler context.
-* This is needed because in external projects the extended class may only be found as a .d.ts declaration.
-*  *
-* @param declarationSourceFile the path to the .d.ts declaration file
-* @param compilerCtx the current compiler context
-* @returns the corresponding .js source file
-*/
 function convertDtsToJs(declarationSourceFile, compilerCtx) {
 	const jsPath = normalizePath(declarationSourceFile.replace(/\.d\.ts$/, ".js").replace("/types/", "/collection/"));
 	return compilerCtx.moduleMap.get(jsPath)?.staticSourceFile;
 }
 /**
-* A recursive function that builds a tree of classes that extend from each other.
-*
+* Recursively walks a class's heritage clauses to build a flat list of every
+* class it extends from (and their own ancestors in turn).
 * @param compilerCtx the current compiler context
 * @param classDeclaration a class declaration to analyze
-* @param dependentClasses a flat array tree of classes that extend from each other
+* @param dependentClasses the flat array to accumulate found classes into
 * @param typeChecker the TypeScript type checker
 * @param buildCtx the current build context
 * @param ogModule the original module file of the class declaration
-* @returns a flat array of classes that extend from each other, including the current class
+* @returns `dependentClasses`, mutated in place
 */
 function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeChecker, buildCtx, ogModule) {
 	const hasHeritageClauses = classDeclaration.heritageClauses;
@@ -14614,10 +15029,10 @@ function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeC
 	});
 	classIdentifiers.forEach((extendee) => {
 		try {
-			const symbol = typeChecker?.getSymbolAtLocation(extendee);
-			const aliasedSymbol = symbol ? typeChecker.getAliasedSymbol(symbol) : void 0;
-			let source = aliasedSymbol?.declarations?.[0].getSourceFile();
-			let declarations = aliasedSymbol?.declarations;
+			let symbol = typeChecker?.getSymbolAtLocation(extendee);
+			if (symbol && symbol.flags & ts.SymbolFlags.Alias) symbol = typeChecker.getAliasedSymbol(symbol);
+			let source = symbol?.declarations?.[0].getSourceFile();
+			let declarations = symbol?.declarations;
 			if (source.fileName.endsWith(".d.ts")) {
 				source = convertDtsToJs(source.fileName, compilerCtx);
 				declarations = [...source.statements];
@@ -14689,7 +15104,8 @@ function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeC
 				if (statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause?.namedBindings)) statement.importClause?.namedBindings.elements.forEach((element) => {
 					if (element.name.getText() === extendee.getText()) {
 						const className = element.propertyName?.getText() || element.name.getText();
-						resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, statement.moduleSpecifier.getText().replaceAll(/['"]/g, ""), className, dependentClasses, typeChecker, ogModule, targetScriptTarget);
+						const moduleSpecifier = statement.moduleSpecifier.getText().replaceAll(/['"]/g, "");
+						resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, moduleSpecifier, className, dependentClasses, typeChecker, ogModule, targetScriptTarget);
 					}
 				});
 			});
@@ -14698,17 +15114,15 @@ function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeC
 	return dependentClasses;
 }
 /**
-* Given a class declaration, this function will analyze its heritage clauses
-* to find any extended classes, and then parse the static members of those
-* extended classes to merge them into the current class's metadata.
-*
-* @param compilerCtx - the current compiler context
-* @param typeChecker - the TypeScript type checker
-* @param buildCtx - the current build context
-* @param cmpNode - the extending class declaration
-* @param staticMembers - the static members of the extending class to merge with the extended class members
-* @param moduleFile - the module file of the extending class
-* @returns an object containing merged metadata from extended classes
+* Analyzes a class's heritage clauses to find any extended classes, then
+* merges their static members into the extending class's own metadata.
+* @param compilerCtx the current compiler context
+* @param typeChecker the TypeScript type checker
+* @param buildCtx the current build context
+* @param cmpNode the extending class declaration
+* @param staticMembers the static members of the extending class
+* @param moduleFile the module file of the extending class
+* @returns the merged metadata from `cmpNode` and every class it extends
 */
 function mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, staticMembers, moduleFile) {
 	const tree = buildExtendsTree(compilerCtx, cmpNode, [], typeChecker, buildCtx, moduleFile);
@@ -14725,10 +15139,10 @@ function mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, sta
 	let deserializers = parseStaticSerializers(staticMembers, "deserializers");
 	tree.forEach((extendedClass) => {
 		const extendedStaticMembers = extendedClass.classNode.members.filter(isStaticGetter);
-		const mixinProps = parseStaticProps(extendedStaticMembers) ?? [];
+		const mixinProps = reanchorInheritedTypeReferences(parseStaticProps(extendedStaticMembers) ?? [], extendedClass.fileName, moduleFile.sourceFilePath);
 		const mixinStates = parseStaticStates(extendedStaticMembers) ?? [];
-		const mixinMethods = parseStaticMethods(extendedStaticMembers) ?? [];
-		const mixinEvents = parseStaticEvents(extendedStaticMembers) ?? [];
+		const mixinMethods = reanchorInheritedTypeReferences(parseStaticMethods(extendedStaticMembers) ?? [], extendedClass.fileName, moduleFile.sourceFilePath);
+		const mixinEvents = reanchorInheritedTypeReferences(parseStaticEvents(extendedStaticMembers) ?? [], extendedClass.fileName, moduleFile.sourceFilePath);
 		const isMixin = mixinProps.length > 0 || mixinStates.length > 0 || mixinMethods.length > 0 || mixinEvents.length > 0;
 		const module = compilerCtx.moduleMap.get(extendedClass.fileName);
 		if (module) {
@@ -14770,6 +15184,8 @@ function mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, sta
 		deserializers
 	};
 }
+//#endregion
+//#region src/compiler/transformers/static-to-meta/class-extension/extract-inherited-meta.ts
 const EMPTY_DOCS = {
 	text: "",
 	tags: []
@@ -14805,19 +15221,14 @@ function extractDecoratorOptions(node) {
 	return result;
 }
 /**
-* Extract Stencil member metadata from source text using parse-only TypeScript
-* (no Program, no TypeChecker). Handles both decorator syntax (.tsx source files)
-* and compiled static getter syntax (.js collection files).
-*
-* @param code source text to parse
-* @param className name of the class to extract metadata from
-* @param fileName virtual filename used to determine script kind
-* @returns extracted metadata, or null if the named class is not found
+* Same as {@link extractInheritedMeta}, but takes an already-parsed class
+* declaration directly - used for ancestors reached via `findClassWalk`
+* (e.g. a mixin factory's nested class, or a same-file ancestor), where
+* there's no standalone source text to re-parse.
+* @param classDecl the class declaration to extract metadata from
+* @returns extracted metadata
 */
-function extractInheritedMeta(code, className, fileName = "__stencil_parent__.tsx") {
-	const scriptKind = fileName.endsWith(".tsx") || fileName.endsWith(".ts") ? ts.ScriptKind.TSX : ts.ScriptKind.JS;
-	const classDecl = ts.createSourceFile(fileName, code, ts.ScriptTarget.ESNext, true, scriptKind).statements.filter(ts.isClassDeclaration).find((c) => c.name?.text === className);
-	if (!classDecl) return null;
+function extractInheritedMetaFromClass(classDecl) {
 	const methodNames = classDecl.members.filter(ts.isMethodDeclaration).map((m) => ts.isIdentifier(m.name) ? m.name.text : "").filter(Boolean);
 	const staticMembers = classDecl.members.filter(isStaticGetter);
 	if (staticMembers.some((m) => ts.isGetAccessorDeclaration(m) && ts.isIdentifier(m.name) && [
@@ -14917,11 +15328,68 @@ function extractInheritedMeta(code, className, fileName = "__stencil_parent__.ts
 		methodNames
 	};
 }
-function getExtendsClassName(node) {
+//#endregion
+//#region src/compiler/transformers/static-to-meta/class-extension/resolve-import-merge.ts
+/**
+* Same purpose as `convertDiskSourceFileDecorators` in compiler-ctx-merge.ts,
+* but serves the already-parsed in-memory source directly instead of
+* re-reading it from disk - the parent source here comes from a
+* caller-supplied `resolveImport` callback and isn't guaranteed to
+* correspond to a real file on disk.
+* @param sourceFile the raw (decorator-syntax) parent source file, already parsed
+* @param config the current Stencil validated config
+* @returns the source converted to static-getter form, or `null` if the mini-program transform fails
+*/
+function convertInMemorySourceDecorators(sourceFile, config) {
+	const compilerOptions = {
+		...config.tsCompilerOptions,
+		experimentalDecorators: true,
+		noLib: true,
+		noResolve: true,
+		isolatedModules: false,
+		target: sourceFile.languageVersion
+	};
+	const compilerHost = {
+		getSourceFile: (fileName) => fileName === sourceFile.fileName ? sourceFile : void 0,
+		writeFile: () => {},
+		getDefaultLibFileName: () => "lib.d.ts",
+		useCaseSensitiveFileNames: () => false,
+		getCanonicalFileName: (fileName) => fileName,
+		getCurrentDirectory: () => "",
+		getNewLine: () => "\n",
+		fileExists: (fileName) => fileName === sourceFile.fileName,
+		readFile: () => "",
+		directoryExists: () => true,
+		getDirectories: () => []
+	};
+	try {
+		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 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);
+	} catch {
+		return null;
+	}
+}
+/**
+* Reads the name(s) a class declaration extends from - either a single
+* identifier (`extends Foo`) or, for the mixin composition pattern, each
+* mixin factory argument (`extends Mixin(A, B)` > `['A', 'B']`).
+*
+* @param node the class declaration to inspect
+* @returns the extended identifier names, or an empty array if the class
+* doesn't extend anything recognizable
+*/
+function getExtendsClassNames(node) {
 	const heritage = node.heritageClauses?.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword);
-	if (!heritage?.types.length) return null;
+	if (!heritage?.types.length) return [];
 	const expr = heritage.types[0].expression;
-	return ts.isIdentifier(expr) ? expr.text : null;
+	if (ts.isIdentifier(expr)) return [expr.text];
+	if (ts.isCallExpression(expr) && expr.expression.getText() === "Mixin") return expr.arguments.filter(ts.isIdentifier).map((id) => id.text);
+	return [];
 }
 function findImportSpecifier(sf, localName) {
 	for (const stmt of sf.statements) {
@@ -14937,17 +15405,208 @@ function findImportSpecifier(sf, localName) {
 	return null;
 }
 /**
+* A single-file mini-program (see `convertInMemorySourceDecorators`) can
+* never load an imported module's own `SourceFile`, so a type that's
+* genuinely imported still ends up classified `location: 'global'`
+*
+* This reclassifies those cases using the same syntactic import lookup used
+* to walk the extends chain: if the type name matches something imported in
+* the file that declares it, it's an import, not a global, regardless of
+* whether the mini-program could load that file - downstream consumers
+* (e.g. `@stencil/unplugin`'s own type expansion) resolve `path` themselves.
+*
+* @param members inherited members whose type references should be reclassified
+* @param declaringSf the source file that declares these members
+* @param declaringPath the resolved absolute path of `declaringSf`
+* @param resolveImport callback used to resolve a canonical id for the reclassified reference
+* @returns the same members, with `global` references reclassified where possible
+*/
+function reclassifyGlobalTypeReferences(members, declaringSf, declaringPath, resolveImport) {
+	members.forEach((member) => {
+		const references = member.complexType?.references;
+		if (!references) return;
+		Object.entries(references).forEach(([typeName, reference]) => {
+			if (reference.location !== "global") return;
+			const specifier = findImportSpecifier(declaringSf, typeName);
+			if (!specifier) return;
+			const resolved = resolveImport(specifier, declaringPath);
+			reference.location = "import";
+			reference.path = specifier;
+			reference.id = `${resolved?.path ?? specifier}::${typeName}`;
+		});
+	});
+	return members;
+}
+/**
+* Looks for `name` as a direct top-level declaration in `sf`; if not found, follows one level of
+* re-export (barrel file) via `resolveImport` - matching `compiler-ctx-merge.ts`'s equivalent
+* one-hop fallback (see `findReExport` in `shared.ts` for why it's capped at one hop).
+*
+* @param sf the source file to search
+* @param path the resolved absolute path of `sf`
+* @param name the declaration name to find
+* @param resolveImport callback used to follow a re-export's module specifier
+* @returns the matched statement and the source file/path it was actually found in (which may
+* differ from `sf`/`path` if resolved through a re-export), or `undefined`
+*/
+function findDeclarationOrReExport(sf, path, name, resolveImport) {
+	const direct = sf.statements.find(matchesNamedDeclaration(name));
+	if (direct) return {
+		statement: direct,
+		sourceFile: sf,
+		path
+	};
+	const reExport = findReExport(sf, name);
+	if (!reExport) return void 0;
+	const resolved = resolveImport(reExport.moduleSpecifier, path);
+	if (!resolved) return void 0;
+	const { code, path: resolvedPath } = resolved;
+	const isTs = resolvedPath.endsWith(".tsx") || resolvedPath.endsWith(".ts");
+	const reExportSf = ts.createSourceFile(resolvedPath, code, ts.ScriptTarget.ESNext, true, isTs ? ts.ScriptKind.TSX : ts.ScriptKind.JS);
+	const statement = reExportSf.statements.find(matchesNamedDeclaration(reExport.localName));
+	if (!statement) return void 0;
+	return {
+		statement,
+		sourceFile: reExportSf,
+		path: resolvedPath
+	};
+}
+/**
+* Recursively resolves a class's `extends` heritage into a flat, deduplicated
+* list of ancestor classes, using `resolveImport` (and same-file lookups)
+* instead of a TypeChecker - the `resolveImport`-callback equivalent of
+* `compiler-ctx-merge.ts`'s `buildExtendsTree`. Handles both a plain
+* `extends Foo` and `extends Mixin(A, B, ...)`, resolving each mixin
+* argument independently.
+*
+* A found ancestor that's wrapped in a mixin factory function (rather than a
+* plain class) stops that branch's recursion - the factory's own `extends`
+* target is a dynamic parameter (e.g. `Base`), not a statically resolvable
+* name.
+* @param classNode the class declaration whose heritage should be walked
+* @param sf the source file containing `classNode` (for import/statement lookups)
+* @param path the resolved absolute path of `sf`
+* @param resolveImport callback that resolves an import specifier to source code
+* @param visited cycle guard, keyed by `resolvedPath::name`
+* @param ancestors the flat array to accumulate found ancestors into
+* @param rootClassDeclaration the top-level component class, used to anchor any "not found" warning
+* @param buildCtx used to surface a warning when an imported extends/mixin target can't be found -
+* omit to resolve silently (e.g. from tests that don't care about diagnostics)
+*/
+function resolveAncestors(classNode, sf, path, resolveImport, visited, ancestors, rootClassDeclaration, buildCtx) {
+	const parentNames = getExtendsClassNames(classNode);
+	for (const parentName of parentNames) {
+		let foundClass;
+		let foundSf = sf;
+		let foundPath = path;
+		let keepLooking = true;
+		const sameFileStatement = sf.statements.find(matchesNamedDeclaration(parentName));
+		if (sameFileStatement) {
+			if (ts.isClassDeclaration(sameFileStatement)) foundClass = sameFileStatement;
+			else {
+				foundClass = findClassWalk(sameFileStatement);
+				keepLooking = false;
+			}
+		} else {
+			const specifier = findImportSpecifier(sf, parentName);
+			if (!specifier) continue;
+			const resolved = resolveImport(specifier, path);
+			if (!resolved) continue;
+			const { code, path: resolvedPath } = resolved;
+			const visitKey = `${resolvedPath}::${parentName}`;
+			if (visited.has(visitKey)) continue;
+			visited.add(visitKey);
+			const isTs = resolvedPath.endsWith(".tsx") || resolvedPath.endsWith(".ts");
+			const found = findDeclarationOrReExport(ts.createSourceFile(resolvedPath, code, ts.ScriptTarget.ESNext, true, isTs ? ts.ScriptKind.TSX : ts.ScriptKind.JS), resolvedPath, parentName, resolveImport);
+			if (!found) {
+				if (buildCtx) {
+					const err = buildWarn(buildCtx.diagnostics);
+					err.messageText = `Unable to find "${parentName}" in the imported module "${specifier}".
+                        Please import class / mixin-factory declarations directly and not via barrel files.`;
+					if (!buildCtx.config._isTesting) augmentDiagnosticWithNode(err, rootClassDeclaration);
+				}
+				continue;
+			}
+			foundSf = found.sourceFile;
+			foundPath = found.path;
+			if (ts.isClassDeclaration(found.statement)) foundClass = found.statement;
+			else {
+				foundClass = findClassWalk(found.statement);
+				keepLooking = false;
+			}
+		}
+		if (!foundClass || ancestors.some((a) => a.classNode === foundClass)) continue;
+		ancestors.push({
+			classNode: foundClass,
+			sourceFile: foundSf,
+			path: foundPath
+		});
+		if (keepLooking) resolveAncestors(foundClass, foundSf, foundPath, resolveImport, visited, ancestors, rootClassDeclaration, buildCtx);
+	}
+}
+/**
+* Extracts Stencil member metadata for a single resolved ancestor - static
+* getter form, or decorator syntax run through a throwaway single-file
+* program so real `complexType` info is computed, falling back to the
+* type-blind `extractInheritedMetaFromClass` walk if that program fails.
+* @param ancestor the resolved ancestor to extract metadata from
+* @param cmpSourceFile the extending component's source file (re-anchor target)
+* @param resolveImport callback that resolves an import specifier to source code
+* @param config used to compute real `complexType` info via a mini `ts.Program`
+* @returns the ancestor's metadata
+*/
+function extractAncestorMeta(ancestor, cmpSourceFile, resolveImport, config) {
+	const { classNode, sourceFile: parentSf, path: resolvedPath } = ancestor;
+	const className = classNode.name?.text;
+	const parentStaticMembers = classNode.members.filter(isStaticGetter);
+	let resolvedClassNode = classNode;
+	let resolvedStaticMembers = parentStaticMembers;
+	let hasUsableStaticMembers = parentStaticMembers.some((m) => ts.isGetAccessorDeclaration(m) && ts.isIdentifier(m.name) && [
+		"properties",
+		"states",
+		"events",
+		"listeners",
+		"watchers",
+		"methods"
+	].includes(m.name.text));
+	if (!hasUsableStaticMembers && className) {
+		const converted = convertInMemorySourceDecorators(parentSf, config);
+		const convertedClass = converted && findClassWalk(converted, className);
+		if (convertedClass) {
+			resolvedClassNode = convertedClass;
+			resolvedStaticMembers = convertedClass.members.filter(isStaticGetter);
+			hasUsableStaticMembers = true;
+		}
+	}
+	if (!hasUsableStaticMembers) return extractInheritedMetaFromClass(classNode);
+	return {
+		properties: reanchorInheritedTypeReferences(reclassifyGlobalTypeReferences(parseStaticProps(resolvedStaticMembers) ?? [], parentSf, resolvedPath, resolveImport), resolvedPath, cmpSourceFile.fileName),
+		states: parseStaticStates(resolvedStaticMembers) ?? [],
+		methods: reanchorInheritedTypeReferences(reclassifyGlobalTypeReferences(parseStaticMethods(resolvedStaticMembers) ?? [], parentSf, resolvedPath, resolveImport), resolvedPath, cmpSourceFile.fileName),
+		events: reanchorInheritedTypeReferences(reclassifyGlobalTypeReferences(parseStaticEvents(resolvedStaticMembers) ?? [], parentSf, resolvedPath, resolveImport), resolvedPath, cmpSourceFile.fileName),
+		listeners: parseStaticListeners(resolvedStaticMembers) ?? [],
+		watchers: parseStaticWatchers(resolvedStaticMembers) ?? [],
+		methodNames: resolvedClassNode.members.filter(ts.isMethodDeclaration).map((m) => ts.isIdentifier(m.name) ? m.name.text : "").filter(Boolean)
+	};
+}
+/**
 * Resolves the inheritance chain for a component using a caller-supplied
-* `resolveImport` callback instead of the full compiler infrastructure.
-* Safe to call from `transpileSync`/`transpileAsync` (no TypeChecker needed).
+* `resolveImport` callback instead of the full compiler infrastructure -
+* safe to call from `transpileSync`/`transpileAsync` (no TypeChecker needed).
+* Handles both a plain `extends Foo` and the mixin composition pattern
+* (`extends Mixin(A, B, ...)`).
 *
 * @param cmpNode the component's class declaration
 * @param staticMembers static getter members already parsed from the component
 * @param sourceFile the source file containing the component (for import resolution)
 * @param resolveImport callback that resolves an import specifier to source code
+* @param config used to compute real `complexType` info for decorator-syntax
+* parent classes via a mini `ts.Program`
+* @param buildCtx used to surface a warning when an imported extends/mixin target can't be
+* found - optional so existing (non-diagnostic-checking) callers aren't forced to supply one
 * @returns merged metadata including all inherited members
 */
-function mergeExtendedClassMetaWithResolveImport(cmpNode, staticMembers, sourceFile, resolveImport) {
+function mergeExtendedClassMetaWithResolveImport(cmpNode, staticMembers, sourceFile, resolveImport, config, buildCtx) {
 	let doesExtend = false;
 	let properties = parseStaticProps(staticMembers);
 	let states = parseStaticStates(staticMembers);
@@ -14958,42 +15617,10 @@ function mergeExtendedClassMetaWithResolveImport(cmpNode, staticMembers, sourceF
 	let classMethods = cmpNode.members.filter(ts.isMethodDeclaration).map((m) => ts.isIdentifier(m.name) ? m.name.text : "").filter(Boolean);
 	const serializers = [];
 	const deserializers = [];
-	let currentNode = cmpNode;
-	let currentSf = sourceFile;
-	let currentPath = sourceFile.fileName;
-	const visited = /* @__PURE__ */ new Set();
-	while (true) {
-		const parentClassName = getExtendsClassName(currentNode);
-		if (!parentClassName) break;
-		const specifier = findImportSpecifier(currentSf, parentClassName);
-		if (!specifier) break;
-		const resolved = resolveImport(specifier, currentPath);
-		if (!resolved) break;
-		const { code, path: resolvedPath } = resolved;
-		if (visited.has(resolvedPath)) break;
-		visited.add(resolvedPath);
-		const isTs = resolvedPath.endsWith(".tsx") || resolvedPath.endsWith(".ts");
-		const parentSf = ts.createSourceFile(resolvedPath, code, ts.ScriptTarget.ESNext, true, isTs ? ts.ScriptKind.TSX : ts.ScriptKind.JS);
-		const parentClass = parentSf.statements.filter(ts.isClassDeclaration).find((c) => c.name?.text === parentClassName);
-		if (!parentClass) break;
-		const parentStaticMembers = parentClass.members.filter(isStaticGetter);
-		const parentMeta = parentStaticMembers.some((m) => ts.isGetAccessorDeclaration(m) && ts.isIdentifier(m.name) && [
-			"properties",
-			"states",
-			"events",
-			"listeners",
-			"watchers",
-			"methods"
-		].includes(m.name.text)) ? {
-			properties: parseStaticProps(parentStaticMembers),
-			states: parseStaticStates(parentStaticMembers),
-			methods: parseStaticMethods(parentStaticMembers),
-			events: parseStaticEvents(parentStaticMembers),
-			listeners: parseStaticListeners(parentStaticMembers),
-			watchers: parseStaticWatchers(parentStaticMembers),
-			methodNames: parentClass.members.filter(ts.isMethodDeclaration).map((m) => ts.isIdentifier(m.name) ? m.name.text : "").filter(Boolean)
-		} : extractInheritedMeta(code, parentClassName, resolvedPath);
-		if (!parentMeta) break;
+	const ancestors = [];
+	resolveAncestors(cmpNode, sourceFile, sourceFile.fileName, resolveImport, /* @__PURE__ */ new Set(), ancestors, cmpNode, buildCtx);
+	ancestors.forEach((ancestor) => {
+		const parentMeta = extractAncestorMeta(ancestor, sourceFile, resolveImport, config);
 		doesExtend = true;
 		const mixinPropsExcludingStates = parentMeta.properties.filter((mp) => !states.some((s) => s.name === mp.name));
 		const mixinStatesExcludingProps = parentMeta.states.filter((ms) => !properties.some((p) => p.name === ms.name));
@@ -15004,10 +15631,7 @@ function mergeExtendedClassMetaWithResolveImport(cmpNode, staticMembers, sourceF
 		listeners = [...deDupeMembers(parentMeta.listeners, listeners), ...listeners];
 		watchers = [...deDupeMembers(parentMeta.watchers, watchers), ...watchers];
 		classMethods = [...classMethods, ...parentMeta.methodNames];
-		currentNode = parentClass;
-		currentSf = parentSf;
-		currentPath = resolvedPath;
-	}
+	});
 	return {
 		doesExtend,
 		properties,
@@ -15125,9 +15749,7 @@ const parseStaticPatches = (encapsulation, staticMembers) => {
 		case "clone":
 			result.clone = true;
 			break;
-		case "insert":
-			result.insert = true;
-			break;
+		case "insert": result.insert = true;
 	}
 	return Object.keys(result).length > 0 ? result : null;
 };
@@ -15291,8 +15913,9 @@ const parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile,
 	const staticMembers = cmpNode.members.filter(isStaticGetter);
 	const tagName = getComponentTagName(staticMembers);
 	if (tagName == null) return cmpNode;
-	const { doesExtend, properties, states, methods, listeners, events, watchers, classMethods, serializers, deserializers } = transformOpts?.resolveImport ? mergeExtendedClassMetaWithResolveImport(cmpNode, staticMembers, moduleFile.staticSourceFile, transformOpts.resolveImport) : mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, staticMembers, moduleFile);
-	const docs = serializeSymbol(typeChecker, typeChecker ? typeChecker.getSymbolAtLocation(cmpNode.name) : void 0);
+	const { doesExtend, properties, states, methods, listeners, events, watchers, classMethods, serializers, deserializers } = transformOpts?.resolveImport ? mergeExtendedClassMetaWithResolveImport(cmpNode, staticMembers, moduleFile.staticSourceFile, transformOpts.resolveImport, buildCtx.config, buildCtx) : mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, staticMembers, moduleFile);
+	const symbol = typeChecker ? typeChecker.getSymbolAtLocation(cmpNode.name) : void 0;
+	const docs = serializeSymbol(typeChecker, symbol);
 	const isCollectionDependency = moduleFile.isCollectionDependency;
 	const encapsulation = parseStaticEncapsulation(staticMembers);
 	const cmp = {
@@ -15380,6 +16003,7 @@ const parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile,
 		htmlAttrNames: [],
 		htmlTagNames: [],
 		htmlParts: [],
+		htmlSlots: [],
 		isUpdateable: false,
 		potentialCmpRefs: [],
 		dependents: [],
@@ -15402,9 +16026,11 @@ const parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile,
 	cmp.hasModernPropertyDecls = detectModernPropDeclarations(cmpNode) || doesExtend;
 	cmp.htmlAttrNames = unique(cmp.htmlAttrNames);
 	cmp.htmlTagNames = unique(cmp.htmlTagNames);
+	cmp.htmlSlots = unique(cmp.htmlSlots);
 	cmp.hasSlot = cmp.hasSlot || cmp.htmlTagNames.includes("slot");
 	cmp.potentialCmpRefs = unique(cmp.potentialCmpRefs);
 	setComponentBuildConditionals(cmp);
+	if (cmp.isPlain && cmpNode.heritageClauses?.some((c) => c.token === ts.SyntaxKind.ExtendsKeyword)) cmp.isPlain = false;
 	if (transformOpts && transformOpts.componentMetadata === "compilerstatic") cmpNode = addComponentMetaStatic(cmpNode, cmp);
 	const foundIndex = moduleFile.cmps.findIndex((c) => c.tagName === cmp.tagName && c.sourceFilePath === cmp.sourceFilePath);
 	if (foundIndex > -1) moduleFile.cmps[foundIndex] = cmp;
@@ -15412,22 +16038,32 @@ const parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile,
 	compilerCtx.nodeMap.set(cmpNode, cmp);
 	return cmpNode;
 };
+/**
+* Check whether a class declaration is a Stencil component, i.e. it's
+* decorated with `@Component({ tag: ... })`.
+* @param classNode the class declaration to check
+* @returns whether `classNode` is a Stencil component class
+*/
+const isStencilComponentClass = (classNode) => {
+	const decorator = ts.getDecorators(classNode)?.[0];
+	return decorator != null && ts.isCallExpression(decorator.expression) && decorator.expression.arguments.length === 1 && ts.isObjectLiteralExpression(decorator.expression.arguments[0]) && decorator.expression.arguments[0].properties.some((prop) => ts.isPropertyAssignment(prop) && prop.name.getText() === "tag");
+};
 const validateComponentMembers = (node, buildCtx) => {
 	/**
 	* validate if:
 	*/
-	if (ts.isGetAccessorDeclaration(node) && ts.isIdentifier(node.name) && typeof node.name.escapedText === "string" && BLACKLISTED_COMPONENT_METHODS.includes(node.name.escapedText) && node.parent && ts.isClassDeclaration(node.parent)) {
+	if (ts.isGetAccessorDeclaration(node) && ts.isIdentifier(node.name) && typeof node.name.escapedText === "string" && BLACKLISTED_COMPONENT_METHODS.includes(node.name.escapedText) && node.parent && ts.isClassDeclaration(node.parent) && isStencilComponentClass(node.parent)) {
 		const propName = node.name.escapedText;
-		const decorator = ts.getDecorators(node.parent)[0];
-		/**
-		* the class is actually a Stencil component, has a decorator with a property named "tag"
-		*/
-		if (ts.isCallExpression(decorator.expression) && decorator.expression.arguments.length === 1 && ts.isObjectLiteralExpression(decorator.expression.arguments[0]) && decorator.expression.arguments[0].properties.some((prop) => ts.isPropertyAssignment(prop) && prop.name.getText() === "tag")) {
-			const componentName = node.parent.name.getText();
-			const err = buildWarn(buildCtx.diagnostics);
-			err.messageText = `The component "${componentName}" has a getter called "${propName}". This getter is reserved for use by Stencil components and should not be defined by the user.`;
-			augmentDiagnosticWithNode(err, node);
-		}
+		const componentName = node.parent.name.getText();
+		const err = buildWarn(buildCtx.diagnostics);
+		err.messageText = `The component "${componentName}" has a getter called "${propName}". This getter is reserved for use by Stencil components and should not be defined by the user.`;
+		augmentDiagnosticWithNode(err, node);
+	}
+	if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name) && node.name.escapedText === "componentShouldUpdate" && node.parameters.length > 1 && node.parent && ts.isClassDeclaration(node.parent) && isStencilComponentClass(node.parent)) {
+		const componentName = node.parent.name.getText();
+		const err = buildWarn(buildCtx.diagnostics);
+		err.messageText = `The component "${componentName}" defines "componentShouldUpdate" with ${node.parameters.length} parameters. As of Stencil v5, "componentShouldUpdate" is called once per render with a single "changes" argument (a map of prop/state names to "{ newVal, oldVal }") instead of once per prop with "(newVal, oldVal, propName)". This method will still compile, but any extra parameters will be "undefined" at runtime.`;
+		augmentDiagnosticWithNode(err, node);
 	}
 };
 const parseVirtualProps = (docs) => {
@@ -15470,7 +16106,7 @@ const parseModuleImport = (config, compilerCtx, buildCtx, moduleFile, dirPath, i
 			importPath = normalizePath(importPath);
 			moduleFile.localImports.push(importPath);
 		} else if (importPath.startsWith(".")) {
-			importPath = normalizePath(resolve$2(dirPath, importPath));
+			importPath = normalizePath(join$2(dirPath, importPath));
 			moduleFile.localImports.push(importPath);
 		} else addExternalImport(config, compilerCtx, buildCtx, moduleFile, moduleFile.sourceFilePath, importPath, resolveCollections, !importNode.importClause);
 	}
@@ -15536,7 +16172,8 @@ const updateModule = (config, compilerCtx, buildCtx, tsSourceFile, sourceFileTex
 	const prevModuleFile = getModule(compilerCtx, sourceFilePath);
 	if (prevModuleFile && prevModuleFile.staticSourceFileText === sourceFileText) return prevModuleFile;
 	const srcDirPath = dirname$1(sourceFilePath);
-	emitFilePath = normalizePath(join$2(srcDirPath, basename$1(emitFilePath)));
+	const emitFileName = basename$1(emitFilePath);
+	emitFilePath = normalizePath(join$2(srcDirPath, emitFileName));
 	const moduleFile = createModule(tsSourceFile, sourceFileText, emitFilePath);
 	if (emitFilePath.endsWith(".js.map")) {
 		moduleFile.sourceMapPath = emitFilePath;
@@ -15588,15 +16225,18 @@ const updateModule = (config, compilerCtx, buildCtx, tsSourceFile, sourceFileTex
 //#region src/compiler/transformers/collection/parse-collection-components.ts
 const parseCollectionComponents = (config, compilerCtx, buildCtx, collectionDir, collectionManifest, collection) => {
 	if (collectionManifest.mixins) collectionManifest.mixins.forEach((mixinPath) => {
-		transpileCollectionModule(config, compilerCtx, buildCtx, collection, join$2(collectionDir, mixinPath));
+		const fullPath = join$2(collectionDir, mixinPath);
+		transpileCollectionModule(config, compilerCtx, buildCtx, collection, fullPath);
 	});
 	if (collectionManifest.entries) collectionManifest.entries.forEach((entryPath) => {
-		transpileCollectionModule(config, compilerCtx, buildCtx, collection, join$2(collectionDir, entryPath));
+		const componentPath = join$2(collectionDir, entryPath);
+		transpileCollectionModule(config, compilerCtx, buildCtx, collection, componentPath);
 	});
 };
 const transpileCollectionModule = (config, compilerCtx, buildCtx, collection, inputFileName) => {
 	const sourceText = compilerCtx.fs.readFileSync(inputFileName);
-	return updateModule(config, compilerCtx, buildCtx, ts.createSourceFile(inputFileName, sourceText, ts.ScriptTarget.ES2017, true, ts.ScriptKind.JS), sourceText, inputFileName, void 0, collection);
+	const sourceFile = ts.createSourceFile(inputFileName, sourceText, ts.ScriptTarget.ES2017, true, ts.ScriptKind.JS);
+	return updateModule(config, compilerCtx, buildCtx, sourceFile, sourceText, inputFileName, void 0, collection);
 };
 //#endregion
 //#region src/compiler/transformers/collection/parse-collection-manifest.ts
@@ -15626,7 +16266,8 @@ const parseCollectionDependencies = (collectionManifest) => {
 };
 const parseGlobal = (config, compilerCtx, buildCtx, collectionDir, collectionManifest, collection) => {
 	if (typeof collectionManifest.global !== "string") return;
-	collection.global = transpileCollectionModule(config, compilerCtx, buildCtx, collection, normalizePath(join$2(collectionDir, collectionManifest.global)));
+	const sourceFilePath = normalizePath(join$2(collectionDir, collectionManifest.global));
+	collection.global = transpileCollectionModule(config, compilerCtx, buildCtx, collection, sourceFilePath);
 };
 const parseBundles = (collectionManifest) => {
 	if (invalidArrayData(collectionManifest.bundles)) return [];
@@ -15644,12 +16285,14 @@ const parseCollection = (config, compilerCtx, buildCtx, moduleId, pkgJsonFilePat
 	let collection = compilerCtx.collections.find((c) => c.collectionName === collectionName);
 	if (collection != null) return collection;
 	const collectionPackageRootDir = dirname$1(pkgJsonFilePath);
-	const collectionFilePath = join$2(collectionPackageRootDir, pkgData.collection ?? pkgData.collection);
+	const collectionManifestPath = pkgData.collection ?? pkgData.collection;
+	const collectionFilePath = join$2(collectionPackageRootDir, collectionManifestPath);
 	const relPath = relative$1(config.rootDir, collectionFilePath);
 	config.logger.debug(`load collection: ${collectionName}, ${relPath}`);
 	const collectionJsonStr = compilerCtx.fs.readFileSync(collectionFilePath);
 	if (!collectionJsonStr) return null;
-	collection = parseCollectionManifest(config, compilerCtx, buildCtx, collectionName, normalizePath(dirname$1(collectionFilePath)), collectionJsonStr);
+	const collectionDir = normalizePath(dirname$1(collectionFilePath));
+	collection = parseCollectionManifest(config, compilerCtx, buildCtx, collectionName, collectionDir, collectionJsonStr);
 	collection.moduleId = moduleId;
 	if (pkgData.module && pkgData.module !== pkgData.main) collection.hasExports = true;
 	collection.moduleDir = collectionPackageRootDir;
@@ -15693,7 +16336,8 @@ const resolveAndIngestCollection = (config, compilerCtx, buildCtx, containingFil
 	})) return;
 	buildCtx.collections.push(collection);
 	if (Array.isArray(collection.dependencies)) collection.dependencies.forEach((dependencyModuleId) => {
-		resolveAndIngestCollection(config, compilerCtx, buildCtx, dirname$1(pkgJsonFilePath), dependencyModuleId, resolveCollections);
+		const resolveFromDir = dirname$1(pkgJsonFilePath);
+		resolveAndIngestCollection(config, compilerCtx, buildCtx, resolveFromDir, dependencyModuleId, resolveCollections);
 	});
 };
 /**
@@ -16019,6 +16663,18 @@ const validateUniqueTagNames = (config, buildCtx, cmp) => {
 //#endregion
 //#region src/compiler/transpile/run-program.ts
 /**
+* In dev mode, downgrade unused-variable diagnostics to warnings so they don't fail the build
+* while a component is mid-edit.
+*
+* @param config - the validated Stencil configuration
+* @param diags - the diagnostics to relax in place
+*/
+const applyDevModeRelaxation = (config, diags) => {
+	if (config.devMode) diags.forEach((diag) => {
+		if (diag.code === "6133" || diag.code === "6192") diag.level = "warn";
+	});
+};
+/**
 * Run the TypeScript program to transpile source files.
 *
 * @param config - the validated Stencil configuration
@@ -16039,6 +16695,21 @@ const runTsProgram = async (config, compilerCtx, buildCtx, tsBuilder) => {
 	const tsTypeChecker = tsProgram.getTypeChecker();
 	const typesOutputTarget = config.outputTargets.filter(isOutputTargetTypes);
 	const emittedDts = [];
+	if (buildCtx.isRebuild && buildCtx.hasScriptChanges && config.validateTypes) {
+		const emitBuilder = tsBuilder;
+		let affected = emitBuilder.getSemanticDiagnosticsOfNextAffectedFile?.();
+		while (affected) {
+			if ("fileName" in affected.affected) {
+				const fileName = normalizePath(affected.affected.fileName);
+				if (!fileName.includes("node_modules") && !fileName.endsWith(".d.ts") && fileName.startsWith(normalizePath(config.srcDir))) {
+					const tsSemantic = loadTypeScriptDiagnostics(affected.result);
+					applyDevModeRelaxation(config, tsSemantic);
+					buildCtx.diagnostics.push(...tsSemantic);
+				}
+			}
+			affected = emitBuilder.getSemanticDiagnosticsOfNextAffectedFile?.();
+		}
+	}
 	const emitCallback = (emitFilePath, data, _w, _e, tsSourceFiles) => {
 		if (emitFilePath.includes("e2e.") || emitFilePath.includes("spec.") || emitFilePath.endsWith("e2e.d.ts") || emitFilePath.endsWith("spec.d.ts")) return;
 		if (emitFilePath.endsWith(".js") || emitFilePath.endsWith("js.map")) updateModule(config, compilerCtx, buildCtx, tsSourceFiles[0], data, emitFilePath, tsTypeChecker, null);
@@ -16087,7 +16758,8 @@ const runTsProgram = async (config, compilerCtx, buildCtx, tsBuilder) => {
 	const changedmodules = Array.from(compilerCtx.changedModules.keys());
 	buildCtx.debug("Transpiled modules: " + JSON.stringify(changedmodules, null, "\n"));
 	buildCtx.moduleFiles = Array.from(compilerCtx.moduleMap.values());
-	const { components: filteredComponents, excludedComponents } = filterExcludedComponents(getComponentsFromModules(buildCtx.moduleFiles), config);
+	const allComponents = getComponentsFromModules(buildCtx.moduleFiles);
+	const { components: filteredComponents, excludedComponents } = filterExcludedComponents(allComponents, config);
 	buildCtx.components = filteredComponents;
 	if (excludedComponents.length > 0 && typesOutputTarget.length > 0) excludedComponents.forEach((cmp) => {
 		const srcPath = normalizePath(cmp.sourceFilePath);
@@ -16126,36 +16798,15 @@ const validateTypesAfterGeneration = async (config, compilerCtx, buildCtx, tsBui
 			needsRebuild: true
 		};
 	}
-	if (config.validateTypes) {
-		const applyDevModeRelaxation = (diags) => {
-			if (config.devMode) diags.forEach((d) => {
-				if (d.code === "6133" || d.code === "6192") d.level = "warn";
-			});
-		};
-		if (buildCtx.isRebuild) {
-			const emitBuilder = tsBuilder;
-			let affected = emitBuilder.getSemanticDiagnosticsOfNextAffectedFile?.();
-			while (affected) {
-				if ("fileName" in affected.affected) {
-					const fileName = normalizePath(affected.affected.fileName);
-					if (!fileName.includes("node_modules") && !fileName.endsWith(".d.ts") && fileName.startsWith(normalizePath(config.srcDir))) {
-						const tsSemantic = loadTypeScriptDiagnostics(affected.result);
-						applyDevModeRelaxation(tsSemantic);
-						buildCtx.diagnostics.push(...tsSemantic);
-					}
-				}
-				affected = emitBuilder.getSemanticDiagnosticsOfNextAffectedFile?.();
-			}
-		} else {
-			const sourceFiles = tsProgram.getSourceFiles().filter((sf) => {
-				const fileName = normalizePath(sf.fileName);
-				return !fileName.includes("node_modules") && !fileName.endsWith(".d.ts") && fileName.startsWith(normalizePath(config.srcDir));
-			});
-			for (const sourceFile of sourceFiles) {
-				const tsSemantic = loadTypeScriptDiagnostics(tsProgram.getSemanticDiagnostics(sourceFile));
-				applyDevModeRelaxation(tsSemantic);
-				buildCtx.diagnostics.push(...tsSemantic);
-			}
+	if (config.validateTypes && !buildCtx.isRebuild) {
+		const sourceFiles = tsProgram.getSourceFiles().filter((sf) => {
+			const fileName = normalizePath(sf.fileName);
+			return !fileName.includes("node_modules") && !fileName.endsWith(".d.ts") && fileName.startsWith(normalizePath(config.srcDir));
+		});
+		for (const sourceFile of sourceFiles) {
+			const tsSemantic = loadTypeScriptDiagnostics(tsProgram.getSemanticDiagnostics(sourceFile));
+			applyDevModeRelaxation(config, tsSemantic);
+			buildCtx.diagnostics.push(...tsSemantic);
 		}
 	}
 	const hasTypesChanged = await generateAppTypes(config, compilerCtx, buildCtx, "src");
@@ -16263,7 +16914,10 @@ const getComponentsUpdated = (compilerCtx, buildCtx) => {
 	const changedScriptFiles = [];
 	const checkedFiles = /* @__PURE__ */ new Set();
 	const allModuleFiles = buildCtx.moduleFiles.filter((m) => m.localImports && m.localImports.length > 0);
-	while (filesToLookForImporters.length > 0) addTsFileImporters(allModuleFiles, filesToLookForImporters, checkedFiles, changedScriptFiles, filesToLookForImporters.shift());
+	while (filesToLookForImporters.length > 0) {
+		const scriptFile = filesToLookForImporters.shift();
+		addTsFileImporters(allModuleFiles, filesToLookForImporters, checkedFiles, changedScriptFiles, scriptFile);
+	}
 	const tags = changedScriptFiles.reduce((acc, changedTsFile) => {
 		const moduleFile = compilerCtx.moduleMap.get(changedTsFile);
 		if (moduleFile != null) moduleFile.cmps.forEach((cmp) => {
@@ -16448,43 +17102,47 @@ function generateBuildStats(config, buildCtx) {
 	const buildResults = buildCtx.buildResults;
 	try {
 		if (buildResults.hasError) return err({ diagnostics: buildResults.diagnostics });
-		else return ok({
-			timestamp: buildResults.timestamp,
-			compiler: {
-				name: config.sys.name,
-				version: config.sys.version
-			},
-			app: {
-				namespace: config.namespace,
-				fsNamespace: config.fsNamespace,
-				components: Object.keys(buildResults.componentGraph ?? {}).length,
-				entries: Object.keys(buildResults.componentGraph ?? {}).length,
-				bundles: buildResults.outputs.reduce((total, en) => total + en.files.length, 0),
-				outputs: getAppOutputs(config, buildResults)
-			},
-			options: {
-				minifyJs: !!config.minifyJs,
-				minifyCss: !!config.minifyCss
-			},
-			formats: {
-				esmBrowser: sanitizeBundlesForStats(buildCtx.esmBrowserComponentBundle),
-				esm: sanitizeBundlesForStats(buildCtx.esmComponentBundle),
-				commonjs: sanitizeBundlesForStats(buildCtx.commonJsComponentBundle)
-			},
-			components: getComponentsFileMap(config, buildCtx),
-			entries: buildCtx.entryModules,
-			componentGraph: buildResults.componentGraph ?? {},
-			sourceGraph: getSourceGraph(config, buildCtx),
-			rolldownResults: buildCtx.rolldownResults ?? { modules: [] },
-			collections: getCollections(config, buildCtx)
-		});
+		else {
+			const stats = {
+				timestamp: buildResults.timestamp,
+				compiler: {
+					name: config.sys.name,
+					version: config.sys.version
+				},
+				app: {
+					namespace: config.namespace,
+					fsNamespace: config.fsNamespace,
+					components: Object.keys(buildResults.componentGraph ?? {}).length,
+					entries: Object.keys(buildResults.componentGraph ?? {}).length,
+					bundles: buildResults.outputs.reduce((total, en) => total + en.files.length, 0),
+					outputs: getAppOutputs(config, buildResults)
+				},
+				options: {
+					minifyJs: !!config.minifyJs,
+					minifyCss: !!config.minifyCss
+				},
+				formats: {
+					esmBrowser: sanitizeBundlesForStats(buildCtx.esmBrowserComponentBundle),
+					esm: sanitizeBundlesForStats(buildCtx.esmComponentBundle),
+					commonjs: sanitizeBundlesForStats(buildCtx.commonJsComponentBundle)
+				},
+				components: getComponentsFileMap(config, buildCtx),
+				entries: buildCtx.entryModules,
+				componentGraph: buildResults.componentGraph ?? {},
+				sourceGraph: getSourceGraph(config, buildCtx),
+				rolldownResults: buildCtx.rolldownResults ?? { modules: [] },
+				collections: getCollections(config, buildCtx)
+			};
+			return ok(stats);
+		}
 	} catch (e) {
-		return err({ diagnostics: [{
+		const diagnostic = {
 			level: `error`,
 			lines: [],
 			messageText: `Generate Build Stats Error: ` + e,
 			type: `build`
-		}] });
+		};
+		return err({ diagnostics: [diagnostic] });
 	}
 }
 /**
@@ -16660,10 +17318,13 @@ const buildDone = async (config, compilerCtx, buildCtx, aborted) => {
 */
 const logHmr = (logger, hmr) => {
 	if (hmr.componentsUpdated) cleanupUpdateMsg(logger, `updated component`, hmr.componentsUpdated);
-	if (hmr.inlineStylesUpdated) cleanupUpdateMsg(logger, `updated style`, hmr.inlineStylesUpdated.map((s) => s.styleTag).reduce((arr, v) => {
-		if (!arr.includes(v)) arr.push(v);
-		return arr;
-	}, []));
+	if (hmr.inlineStylesUpdated) {
+		const inlineStyles = hmr.inlineStylesUpdated.map((s) => s.styleTag).reduce((arr, v) => {
+			if (!arr.includes(v)) arr.push(v);
+			return arr;
+		}, []);
+		cleanupUpdateMsg(logger, `updated style`, inlineStyles);
+	}
 	if (hmr.externalStylesUpdated) cleanupUpdateMsg(logger, `updated stylesheet`, hmr.externalStylesUpdated);
 	if (hmr.imagesUpdated) cleanupUpdateMsg(logger, `updated image`, hmr.imagesUpdated);
 };
@@ -16760,7 +17421,7 @@ const getPackageJsonRecommendations = (config, compilerCtx) => {
 * @returns an empty Promise
 */
 const validateBuildPackageJson = async (config, compilerCtx, buildCtx) => {
-	if (config.watch || buildCtx.packageJson == null) return;
+	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)));
@@ -16900,26 +17561,30 @@ const validateCollectionFields = async (config, compilerCtx, buildCtx, outputTar
 * @param outputTarget the collection output target to validate against
 */
 const validatePackageFiles = async (config, compilerCtx, buildCtx, outputTarget) => {
-	if (!config.devMode && Array.isArray(buildCtx.packageJson.files)) {
-		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;
-		})) {
-			packageJsonWarn(config, compilerCtx, buildCtx, `package.json "files" array must contain the distribution directory "${actualDistDir}/" when generating a distribution.`, `"files"`);
-			return;
-		}
-		await Promise.all(buildCtx.packageJson.files.map(async (pkgFile) => {
-			if (!isGlob(pkgFile)) {
-				const absPath = join$2(dirname$1(config.packageJsonFilePath), pkgFile);
-				if (!await compilerCtx.fs.access(absPath)) packageJsonError(config, compilerCtx, buildCtx, `Unable to find "${pkgFile}" within the package.json "files" array.`, `"${pkgFile}"`);
-			}
-		}));
+	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.`;
+		packageJsonWarn(config, compilerCtx, buildCtx, msg, `"files"`);
+		return;
 	}
+	await Promise.all(buildCtx.packageJson.files.map(async (pkgFile) => {
+		if (!isGlob(pkgFile)) {
+			const packageJsonDir = dirname$1(config.packageJsonFilePath);
+			const absPath = join$2(packageJsonDir, pkgFile);
+			if (!await compilerCtx.fs.access(absPath)) {
+				const msg = `Unable to find "${pkgFile}" within the package.json "files" array.`;
+				packageJsonError(config, compilerCtx, buildCtx, msg, `"${pkgFile}"`);
+			}
+		}
+	}));
 };
 /**
 * Check that the `collection` field is set correctly in `package.json` for the
@@ -16932,7 +17597,10 @@ const validatePackageFiles = async (config, compilerCtx, buildCtx, outputTarget)
 const validateCollectionField = (config, compilerCtx, buildCtx, outputTarget) => {
 	if (outputTarget.dir) {
 		const collectionRel = normalizePath(join$2(relative$1(config.rootDir, outputTarget.dir), COLLECTION_MANIFEST_FILE_NAME), false);
-		if (!buildCtx.packageJson.collection || normalizePath(buildCtx.packageJson.collection, false) !== collectionRel) packageJsonWarn(config, compilerCtx, buildCtx, `package.json "collection" property should be set to ${collectionRel} when generating a distribution bundle.`, `"collection"`);
+		if (!buildCtx.packageJson.collection || normalizePath(buildCtx.packageJson.collection, false) !== collectionRel) {
+			const msg = `package.json "collection" property should be set to ${collectionRel} when generating a distribution bundle.`;
+			packageJsonWarn(config, compilerCtx, buildCtx, msg, `"collection"`);
+		}
 	}
 };
 /**
@@ -16976,7 +17644,8 @@ const validateManifestJson = (config, compilerCtx, buildCtx) => {
 		try {
 			const manifestContent = await compilerCtx.fs.readFile(manifestFilePath);
 			if (manifestContent) try {
-				await validateManifestJsonData(compilerCtx, buildCtx, manifestFilePath, JSON.parse(manifestContent));
+				const manifestData = JSON.parse(manifestContent);
+				await validateManifestJsonData(compilerCtx, buildCtx, manifestFilePath, manifestData);
 			} catch (e) {
 				const err = buildError(buildCtx.diagnostics);
 				err.header = `Invalid manifest.json: ${e}`;
@@ -16997,7 +17666,8 @@ const validateManifestJsonIcon = async (compilerCtx, buildCtx, manifestFilePath,
 		return;
 	}
 	if (iconSrc.startsWith("/")) iconSrc = iconSrc.slice(1);
-	const iconPath = join$2(dirname$1(manifestFilePath), iconSrc);
+	const manifestDir = dirname$1(manifestFilePath);
+	const iconPath = join$2(manifestDir, iconSrc);
 	if (!await compilerCtx.fs.access(iconPath)) {
 		const msg = `Unable to find manifest icon "${manifestIcon.src}"`;
 		buildJsonFileError(compilerCtx, buildCtx.diagnostics, manifestFilePath, msg, `"${manifestIcon.src}"`);
@@ -17059,11 +17729,18 @@ const generateRootExport = (config, buildCtx, loaderBundle, standalone, types) =
 	if (!(currentImport && isValidRootExport(config, currentImport, loaderBundle, standalone))) {
 		const primaryDir = loaderBundle?.dir ?? standalone?.dir;
 		if (primaryDir) {
-			execSync(`npm pkg set "exports[.][import]"="${normalizePath(relative$1(config.rootDir, join$2(primaryDir, "index.js")))}"`);
-			if (loaderBundle?.cjs) execSync(`npm pkg set "exports[.][require]"="${normalizePath(relative$1(config.rootDir, join$2(loaderBundle.dir, "index.cjs")))}"`);
+			const importPath = normalizePath(relative$1(config.rootDir, join$2(primaryDir, "index.js")));
+			execSync(`npm pkg set "exports[.][import]"="${importPath}"`);
+			if (loaderBundle?.cjs) {
+				const requirePath = normalizePath(relative$1(config.rootDir, join$2(loaderBundle.dir, "index.cjs")));
+				execSync(`npm pkg set "exports[.][require]"="${requirePath}"`);
+			}
 		}
 	}
-	if (types?.dir) execSync(`npm pkg set "exports[.][types]"="${normalizePath(relative$1(config.rootDir, join$2(types.dir, "index.d.ts")))}"`);
+	if (types?.dir) {
+		const typesPath = normalizePath(relative$1(config.rootDir, join$2(types.dir, "index.d.ts")));
+		execSync(`npm pkg set "exports[.][types]"="${typesPath}"`);
+	}
 };
 /**
 * Check if the current root export import path is valid
@@ -17108,12 +17785,17 @@ const ensureRelativePrefix = (path) => {
 */
 const generateLoaderExport = (config, loaderBundle, types) => {
 	const esmDir = join$2(loaderBundle.dir, "esm");
-	execSync(`npm pkg set "exports[./loader][import]"="${ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(esmDir, "loader.js"))))}"`);
+	const esmLoaderPath = ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(esmDir, "loader.js"))));
+	execSync(`npm pkg set "exports[./loader][import]"="${esmLoaderPath}"`);
 	if (loaderBundle.cjs) {
 		const cjsDir = join$2(loaderBundle.dir, "cjs");
-		execSync(`npm pkg set "exports[./loader][require]"="${ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(cjsDir, "loader.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}"`);
 	}
-	if (types?.dir) execSync(`npm pkg set "exports[./loader][types]"="${ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(types.dir, "loader.d.ts"))))}"`);
 };
 /**
 * Generate per-component exports for standalone output.
@@ -17307,8 +17989,10 @@ const compilerRequest = async (config, compilerCtx, data) => {
 			return results;
 		}
 	} catch (e) {
-		if (e) if (e instanceof Error && e.stack) results.content = `/*\n${e.stack}\n*/`;
-		else results.content = `/*\n${e}\n*/`;
+		if (e) {
+			if (e instanceof Error && e.stack) results.content = `/*\n${e.stack}\n*/`;
+			else results.content = `/*\n${e}\n*/`;
+		}
 		results.status = 500;
 	}
 	return results;
@@ -17725,7 +18409,8 @@ const createWatchBuild = async (config, compilerCtx) => {
 			filesAdded.forEach((f) => currentlyBuildingFiles.add(f));
 			filesUpdated.forEach((f) => currentlyBuildingFiles.add(f));
 			filesDeleted.forEach((f) => currentlyBuildingFiles.add(f));
-			await onBuild(incrementalCompiler.rebuild());
+			const tsBuilder = incrementalCompiler.rebuild();
+			await onBuild(tsBuilder);
 		} finally {
 			currentlyBuildingFiles.clear();
 			isBuilding = false;
@@ -17765,7 +18450,7 @@ const createWatchBuild = async (config, compilerCtx) => {
 				if (!compilerCtx.fs.accessSync(key)) compilerCtx.moduleMap.delete(key);
 			}
 		});
-		new Set([...filesUpdated, ...filesAdded]).forEach((filePath) => {
+		(/* @__PURE__ */ new Set([...filesUpdated, ...filesAdded])).forEach((filePath) => {
 			compilerCtx.addWatchFile(filePath);
 		});
 		dirsAdded.clear();
@@ -17778,7 +18463,8 @@ const createWatchBuild = async (config, compilerCtx) => {
 		const result = await build(config, compilerCtx, buildCtx, tsBuilder);
 		if (result === null) {
 			incrementalCompiler.refreshRootNames();
-			await onBuild(incrementalCompiler.rebuild());
+			const freshTsBuilder = incrementalCompiler.rebuild();
+			await onBuild(freshTsBuilder);
 			return;
 		}
 		if (!result.hasError) isRebuild = true;
@@ -17806,7 +18492,8 @@ const createWatchBuild = async (config, compilerCtx) => {
 			...(config.watchExternalDirs || []).map((dir) => watchFiles(compilerCtx, dir))
 		]);
 		incrementalCompiler = new IncrementalCompiler(config);
-		await onBuild(incrementalCompiler.rebuild());
+		const tsBuilder = incrementalCompiler.rebuild();
+		await onBuild(tsBuilder);
 		return watchWaiter;
 	};
 	/**
@@ -17849,9 +18536,7 @@ const createWatchBuild = async (config, compilerCtx) => {
 				case "fileUpdate":
 					filesUpdated.add(filePath);
 					break;
-				case "fileDelete":
-					filesDeleted.add(filePath);
-					break;
+				case "fileDelete": filesDeleted.add(filePath);
 			}
 			if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) tsFilesToInvalidate.add(filePath);
 			config.logger.debug(`WATCH_BUILD::fs_event_change - type=${eventKind}, path=${filePath}, time=${(/* @__PURE__ */ new Date()).getTime()}`);
@@ -18116,7 +18801,7 @@ var Cache = class {
 	}
 };
 const MAX_FAILED = 100;
-const ONE_DAY = 1e3 * 60 * 60 * 24;
+const ONE_DAY = 864e5;
 const ONE_WEEK = ONE_DAY * 7;
 const EXP_STORAGE_KEY = `last_clear_expired_cache`;
 const CACHE_DIR_README = `# Stencil Cache Directory
@@ -18275,6 +18960,9 @@ const validateDocs$1 = (config, diagnostics, userOutputs) => {
 	userOutputs.filter(isOutputTargetDocsCustomElementsManifest).forEach((cemOutput) => {
 		docsOutputs.push(validateCustomElementsManifestOutputTarget(config, cemOutput));
 	});
+	userOutputs.filter(isOutputTargetDocsAgentSkill).forEach((agentSkillOutput) => {
+		docsOutputs.push(validateAgentSkillOutputTarget(config, agentSkillOutput));
+	});
 	return docsOutputs;
 };
 const validateReadmeOutputTarget = (config, outputTarget) => {
@@ -18314,6 +19002,13 @@ const validateVScodeDocsOutputTarget = (config, diagnostics, outputTarget) => {
 	if (!isBoolean$1(outputTarget.skipInDev)) outputTarget.skipInDev = !config._docsFlag;
 	return outputTarget;
 };
+const DEFAULT_AGENT_SKILL_DIR = "dist/skill";
+const validateAgentSkillOutputTarget = (config, outputTarget) => {
+	outputTarget.dir = getAbsolutePath(config, outputTarget.dir || DEFAULT_AGENT_SKILL_DIR);
+	outputTarget.name = toSkillName(outputTarget.name || config.fsNamespace);
+	if (!isBoolean$1(outputTarget.skipInDev)) outputTarget.skipInDev = !config._docsFlag;
+	return outputTarget;
+};
 const validateCustomElementsManifestOutputTarget = (config, outputTarget) => {
 	if (!isString$1(outputTarget.file)) outputTarget.file = "custom-elements.json";
 	if (!isAbsolute$1(outputTarget.file)) outputTarget.file = join$2(config.rootDir, outputTarget.file);
@@ -18342,9 +19037,10 @@ const validateGlobalStyle = (config, userOutputs) => {
 		const input = isString$1(outputTarget.input) ? getAbsolutePath(config, outputTarget.input) : config.globalStyle ?? void 0;
 		let fileName;
 		if (isString$1(outputTarget.fileName)) fileName = outputTarget.fileName;
-		else if (input) if (isString$1(outputTarget.input)) fileName = basename(input);
-		else fileName = `${config.fsNamespace}.css`;
-		else fileName = `${config.fsNamespace}.css`;
+		else if (input) {
+			if (isString$1(outputTarget.input)) fileName = basename(input);
+			else fileName = `${config.fsNamespace}.css`;
+		} else fileName = `${config.fsNamespace}.css`;
 		const validInjectValues = [
 			"none",
 			"client",
@@ -18367,9 +19063,10 @@ const validateGlobalStyle = (config, userOutputs) => {
 //#region src/compiler/config/outputs/validate-lazy.ts
 const validateLazy = (config, userOutputs) => {
 	return userOutputs.filter(isOutputTargetDistLazy).map((o) => {
+		const dir = getAbsolutePath(config, o.dir || join$2("dist", config.fsNamespace));
 		return {
 			type: DIST_LAZY,
-			esmDir: getAbsolutePath(config, o.dir || join$2("dist", config.fsNamespace)),
+			esmDir: dir,
 			isBrowserBuild: true,
 			empty: isBoolean$1(o.empty) ? o.empty : true
 		};
@@ -18433,7 +19130,8 @@ const validateLoaderBundle = (config, diagnostics, userOutputs) => {
 		if (!config.devMode || !loaderBundleOutput.skipInDev) {
 			const esmDir = join$2(loaderBundleOutput.dir, "esm");
 			const cjsDir = loaderBundleOutput.cjs ? join$2(loaderBundleOutput.dir, "cjs") : void 0;
-			const typesDir = getAbsolutePath(config, userOutputs.find(isOutputTargetTypes)?.dir ?? "dist/types");
+			const typesOutput = userOutputs.find(isOutputTargetTypes);
+			const typesDir = getAbsolutePath(config, typesOutput?.dir ?? "dist/types");
 			outputs.push({
 				type: DIST_LAZY,
 				esmDir,
@@ -19245,6 +19943,8 @@ const validateConfig = (userConfig = {}, bootstrapConfig) => {
 	const ldp = validatedConfig.compat.lightDomPatches;
 	if (ldp === void 0) validatedConfig.compat.lightDomPatches = true;
 	else if (typeof ldp !== "boolean" && typeof ldp !== "object") validatedConfig.compat.lightDomPatches = true;
+	validatedConfig.compat.suppressPublicNameWarnings = !!validatedConfig.compat.suppressPublicNameWarnings;
+	validatedConfig.compat.suppressEventNameWarnings = !!validatedConfig.compat.suppressEventNameWarnings;
 	setBooleanConfig(validatedConfig, "watch", false);
 	setBooleanConfig(validatedConfig, "profile", validatedConfig.devMode);
 	setBooleanConfig(validatedConfig, "writeLog", false);
@@ -19252,8 +19952,6 @@ const validateConfig = (userConfig = {}, bootstrapConfig) => {
 	setBooleanConfig(validatedConfig, "autoprefixCss", false);
 	setBooleanConfig(validatedConfig, "validateTypes", !validatedConfig._isTesting);
 	setBooleanConfig(validatedConfig, "allowInlineScripts", true);
-	setBooleanConfig(validatedConfig, "suppressReservedPublicNameWarnings", false);
-	setBooleanConfig(validatedConfig, "suppressReservedEventNameWarnings", false);
 	if (!isString$1(validatedConfig.taskQueue)) validatedConfig.taskQueue = "async";
 	if (!validatedConfig.env) validatedConfig.env = {};
 	validateOutputTargets(validatedConfig, diagnostics);
@@ -19263,6 +19961,7 @@ const validateConfig = (userConfig = {}, bootstrapConfig) => {
 	else validatedConfig.bundles = [];
 	if (!Array.isArray(validatedConfig.excludeComponents)) validatedConfig.excludeComponents = [];
 	if (!Array.isArray(validatedConfig.collections)) validatedConfig.collections = [];
+	if (!Array.isArray(validatedConfig.modes)) validatedConfig.modes = [];
 	validateWorkers(validatedConfig);
 	setBooleanConfig(validatedConfig, "devInspector", validatedConfig.devMode);
 	setBooleanConfig(validatedConfig, "enableCache", true);
@@ -20205,7 +20904,8 @@ const autoprefixCss = async (cssText, opts, filePath, minify = false) => {
 		diagnostics: []
 	};
 	try {
-		const targets = getTargets(opts != null && typeof opts === "object" && Array.isArray(opts.targets) ? opts.targets : DEFAULT_BROWSER_TARGETS);
+		const browserTargets = opts != null && typeof opts === "object" && Array.isArray(opts.targets) ? opts.targets : DEFAULT_BROWSER_TARGETS;
+		const targets = getTargets(browserTargets);
 		output.output = transform({
 			filename: filePath ?? "style.css",
 			code: Buffer.from(cssText),
@@ -20489,7 +21189,8 @@ const parseCss = (css, filePath) => {
 	};
 	const atquery = (name) => {
 		const pos = position();
-		const m = match(new RegExp("^@" + name + " *([^{]+)"));
+		const regex = new RegExp("^@" + name + " *([^{]+)");
+		const m = match(regex);
 		if (!m) return null;
 		const media = trim(m[1]);
 		if (!open()) return error(`@${name} missing '{'`);
@@ -20508,7 +21209,8 @@ const parseCss = (css, filePath) => {
 	*/
 	const nestedAtQuery = (name) => {
 		const pos = position();
-		const m = match(new RegExp("^@" + name + " *([^{]+)"));
+		const regex = new RegExp("^@" + name + " *([^{]+)");
+		const m = match(regex);
 		if (!m) return null;
 		const media = trim(m[1]);
 		const decls = declarations();
@@ -20766,8 +21468,10 @@ const serializeCssVisitNode = (opts, node, index, len) => {
 	const nodeType = node.type;
 	if (nodeType === 4) return serializeCssDeclaration(node, index, len);
 	if (nodeType === 14) return serializeCssRule(opts, node);
-	if (nodeType === 1) if (node.comment?.[0] === "!") return `/*${node.comment}*/`;
-	else return "";
+	if (nodeType === 1) {
+		if (node.comment?.[0] === "!") return `/*${node.comment}*/`;
+		else return "";
+	}
 	if (nodeType === 10) return serializeCssMedia(opts, node);
 	if (nodeType === 11) return serializeCssContainer(opts, node);
 	if (nodeType === 8) return serializeCssKeyframes(opts, node);
@@ -20999,7 +21703,8 @@ const crawlAnchorsForNextUrls = (prerenderConfig, diagnostics, baseUrl, currentU
 		return standardFilterAnchor(diagnostics, anchor, currentUrl);
 	}).map((anchor) => {
 		if (typeof prerenderConfig.normalizeUrl === "function") try {
-			return standardNormalizeUrl(diagnostics, prerenderConfig.normalizeUrl(anchor.href, currentUrl).href, currentUrl);
+			const userNormalizedUrl = prerenderConfig.normalizeUrl(anchor.href, currentUrl);
+			return standardNormalizeUrl(diagnostics, userNormalizedUrl.href, currentUrl);
 		} catch (e) {
 			catchError(diagnostics, e);
 		}
@@ -21101,7 +21806,7 @@ const extname$1 = (str) => {
 	const parts = str.split(".");
 	return parts[parts.length - 1].toLowerCase();
 };
-const SKIP_EXT = new Set([
+const SKIP_EXT = /* @__PURE__ */ new Set([
 	"zip",
 	"rar",
 	"tar",
@@ -21145,8 +21850,10 @@ const getPrerenderConfig = async (diagnostics, prerenderConfigPath) => {
 		const results = await nodeRequire(prerenderConfigPath);
 		diagnostics.push(...results.diagnostics);
 		const mod = results.module?.default ?? results.module;
-		if (mod != null && typeof mod === "object") if (mod.config != null && typeof mod.config === "object") Object.assign(prerenderConfig, mod.config);
-		else Object.assign(prerenderConfig, mod);
+		if (mod != null && typeof mod === "object") {
+			if (mod.config != null && typeof mod.config === "object") Object.assign(prerenderConfig, mod.config);
+			else Object.assign(prerenderConfig, mod);
+		}
 	}
 	return prerenderConfig;
 };
@@ -21203,7 +21910,8 @@ const optimizeJs = async (inputOpts) => {
 		sourceMap: null
 	};
 	try {
-		const minifyOpts = getTerserOptions({}, "latest", !!inputOpts.pretty);
+		const prettyOutput = !!inputOpts.pretty;
+		const minifyOpts = getTerserOptions({}, "latest", prettyOutput);
 		const minifyResults = await minifyJs(inputOpts.input, minifyOpts);
 		if (minifyResults.diagnostics.length > 0) result.diagnostics.push(...minifyResults.diagnostics);
 		else {
@@ -21309,7 +22017,9 @@ s&&((s['data-opts']=s['data-opts']||{}).exclude=__EXCLUDE__);
 const addModulePreloads = (doc, hydrateOpts, hydrateResults, componentGraph) => {
 	if (!componentGraph) return false;
 	const staticComponents = hydrateOpts.staticComponents || [];
-	injectModulePreloads(doc, unique(flatOne(hydrateResults.components.filter((cmp) => !staticComponents.includes(cmp.tag)).map((cmp) => getScopeId(cmp.tag, cmp.mode)).map((scopeId) => componentGraph.get(scopeId) || []))));
+	const cmpTags = hydrateResults.components.filter((cmp) => !staticComponents.includes(cmp.tag));
+	const modulePreloads = unique(flatOne(cmpTags.map((cmp) => getScopeId(cmp.tag, cmp.mode)).map((scopeId) => componentGraph.get(scopeId) || [])));
+	injectModulePreloads(doc, modulePreloads);
 	return true;
 };
 const removeModulePreloads = (doc) => {
@@ -21418,14 +22128,16 @@ const hashPageStateAstAssets = async (sys, hydrateOpts, appDir, currentUrl, page
 };
 const getAttrUrls = (attrName, attrValue) => {
 	const srcValues = [];
-	if (isString$1(attrValue)) if (attrName.toLowerCase() === "srcset") attrValue.split(",").map((a) => a.trim()).filter((a) => a.length > 0).forEach((src) => {
-		const spaceSplt = src.split(" ");
-		if (spaceSplt[0].length > 0) srcValues.push({
-			src: spaceSplt[0],
-			descriptor: spaceSplt[1]
+	if (isString$1(attrValue)) {
+		if (attrName.toLowerCase() === "srcset") attrValue.split(",").map((a) => a.trim()).filter((a) => a.length > 0).forEach((src) => {
+			const spaceSplt = src.split(" ");
+			if (spaceSplt[0].length > 0) srcValues.push({
+				src: spaceSplt[0],
+				descriptor: spaceSplt[1]
+			});
 		});
-	});
-	else srcValues.push({ src: attrValue });
+		else srcValues.push({ src: attrValue });
+	}
 	return srcValues;
 };
 const setAttrUrls = (url, descriptor) => {
@@ -21550,10 +22262,12 @@ const prerenderWorker = async (sys, prerenderRequest) => {
 						[s.id]: JSON.parse(s.content),
 						components: hydrateResults.components.map((c) => c.tag)
 					};
-					const dataFilePath = join$2(pageDir, `${s.id}.json`);
+					const dataFileName = `${s.id}.json`;
+					const dataFilePath = join$2(pageDir, dataFileName);
 					await sys.writeFile(dataFilePath, JSON.stringify(data));
 				} else {
-					const contentFilePath = join$2(pageDir, `${s.id}.txt`);
+					const contentFileName = `${s.id}.txt`;
+					const contentFilePath = join$2(pageDir, contentFileName);
 					await sys.writeFile(contentFilePath, s.content);
 				}
 			}));
@@ -21661,7 +22375,8 @@ const transformCssToEsm = async (input) => {
 * @returns transformed ESM output
 */
 const transformCssToEsmSync = (input) => {
-	return generateTransformCssToEsm(input, transformCssToEsmModule(input));
+	const results = transformCssToEsmModule(input);
+	return generateTransformCssToEsm(input, results);
 };
 /**
 * Performs the actual transformation from CSS to ESM
@@ -21681,7 +22396,7 @@ const transformCssToEsmModule = (input) => {
 	};
 	if (input.docs) parseStyleDocs(results.styleDocs, input.input, input.mode);
 	try {
-		const varNames = new Set([results.defaultVarName]);
+		const varNames = /* @__PURE__ */ new Set([results.defaultVarName]);
 		if (isString$1(input.tag) && input.encapsulation === "scoped") {
 			const scopeId = getScopeId(input.tag, input.mode);
 			results.styleText = scopeCss(results.styleText, scopeId, false);
@@ -21716,7 +22431,7 @@ const transformCssToEsmModule = (input) => {
 */
 const generateTransformCssToEsm = (input, results) => {
 	const s = new MagicString("");
-	results.styleText = results.styleText.replace(/\n/g, " ").replace(/\r/g, " ").replace(/\t/g, " ").replace(/`/g, "\\`").replace(/\u000c/g, "\\f").replace(/\u0008/g, "\\b").replace(/\u000b/g, "\\v").replace(/\0/g, "\\0").replace(/\\/g, "\\\\");
+	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);
 	if (input.module === "cjs") {
@@ -21758,7 +22473,7 @@ const getCssToEsmImports = (varNames, cssText, filePath, modeName) => {
 	const cssImports = [];
 	if (!cssText.includes("@import")) return cssImports;
 	cssText = stripCssComments(cssText);
-	const dir = path$1.dirname(filePath);
+	const dir = path.dirname(filePath);
 	let r;
 	while (r = CSS_IMPORT_RE.exec(cssText)) {
 		const cssImportData = {
@@ -21772,7 +22487,7 @@ const getCssToEsmImports = (varNames, cssText, filePath, modeName) => {
 		else if (isCssNodeModule(cssImportData.url)) {
 			cssImportData.filePath = cssImportData.url.substring(1);
 			cssImportData.isNodeModule = true;
-		} else if (path$1.isAbsolute(cssImportData.url)) cssImportData.filePath = normalizePath(cssImportData.url);
+		} else if (path.isAbsolute(cssImportData.url)) cssImportData.filePath = normalizePath(cssImportData.url);
 		else cssImportData.filePath = normalizePath(resolve$2(dir, cssImportData.url));
 		cssImportData.varName = createCssVarName(cssImportData.filePath, modeName);
 		if (varNames.has(cssImportData.varName)) cssImportData.varName += varNames.size;
@@ -21815,7 +22530,7 @@ const isLocalCssImport = (srcImport) => {
 * @returns an appropriate Css var name
 */
 const createCssVarName = (filePath, modeName) => {
-	let varName = path$1.basename(filePath);
+	let varName = path.basename(filePath);
 	if (modeName && modeName !== "$" && !varName.includes(modeName)) varName = modeName + "-" + varName;
 	return createJsVarName(varName);
 };
@@ -22001,9 +22716,10 @@ const getTsConfigPath = async (config, sys) => {
 		path: "",
 		content: ""
 	};
-	if (isString$1(config.tsconfig)) if (!isAbsolute$1(config.tsconfig)) tsconfig.path = join$2(config.rootDir, config.tsconfig);
-	else tsconfig.path = config.tsconfig;
-	else tsconfig.path = join$2(config.rootDir, "tsconfig.json");
+	if (isString$1(config.tsconfig)) {
+		if (!isAbsolute$1(config.tsconfig)) tsconfig.path = join$2(config.rootDir, config.tsconfig);
+		else tsconfig.path = config.tsconfig;
+	} else tsconfig.path = join$2(config.rootDir, "tsconfig.json");
 	tsconfig.content = await sys.readFile(tsconfig.path);
 	if (!isString$1(tsconfig.content)) {
 		tsconfig.path = join$2(config.rootDir, "tsconfig.json");
@@ -22191,7 +22907,7 @@ const getWriteFilePathFromUrlPath = (manager, inputHref) => {
 	const inputPathParts = inputPathname.split("/");
 	const isPrerrenderRoot = basePathname === inputPathname;
 	let fileName;
-	if (isPrerrenderRoot) fileName = path$1.basename(manager.outputTarget.indexHtml);
+	if (isPrerrenderRoot) fileName = path.basename(manager.outputTarget.indexHtml);
 	else fileName = "index.html";
 	const pathParts = [];
 	for (let i = 0; i < inputPathParts.length; i++) {
@@ -22248,13 +22964,15 @@ const addUrlToPendingQueue = (manager, queueUrl, fromUrl) => {
 };
 const drainPrerenderQueue = (results, manager) => {
 	const nextUrl = manager.urlsPending.values().next();
-	if (!nextUrl.done) if (manager.urlsProcessing.size > manager.maxConcurrency) setTimeout(() => drainPrerenderQueue(results, manager));
-	else {
-		const url = nextUrl.value;
-		manager.urlsPending.delete(url);
-		manager.urlsProcessing.add(url);
-		prerenderUrl(results, manager, url);
-		if (manager.urlsProcessing.size < manager.maxConcurrency) manager.config.sys.nextTick(() => drainPrerenderQueue(results, manager));
+	if (!nextUrl.done) {
+		if (manager.urlsProcessing.size > manager.maxConcurrency) setTimeout(() => drainPrerenderQueue(results, manager));
+		else {
+			const url = nextUrl.value;
+			manager.urlsPending.delete(url);
+			manager.urlsProcessing.add(url);
+			prerenderUrl(results, manager, url);
+			if (manager.urlsProcessing.size < manager.maxConcurrency) manager.config.sys.nextTick(() => drainPrerenderQueue(results, manager));
+		}
 	}
 	if (manager.urlsProcessing.size === 0 && manager.urlsPending.size === 0) {
 		if (isFunction(manager.resolve)) {
@@ -22554,7 +23272,8 @@ const runPrerenderOutputTarget = async (workerCtx, results, diagnostics, config,
 			if (debugDiagnostics.length > 0) config.logger.printDiagnostics(debugDiagnostics);
 		}
 		const duration = timeSpan.duration();
-		await generateRobotsTxt(manager, await generateSitemapXml(manager));
+		const sitemapResults = await generateSitemapXml(manager);
+		await generateRobotsTxt(manager, sitemapResults);
 		const prerenderBuildErrors = prerenderDiagnostics.filter((d) => d.level === "error");
 		const prerenderRuntimeErrors = prerenderDiagnostics.filter((d) => d.type === "runtime");
 		if (prerenderBuildErrors.length > 0) {
@@ -22765,7 +23484,8 @@ const createSystem = (c) => {
 		const itemStat = statSync(oldPath);
 		if (!itemStat.error && !results.error) {
 			if (itemStat.isFile) {
-				const createDirResults = createDirSync(dirname$1(newPath), { recursive: true });
+				const newFileParentDir = dirname$1(newPath);
+				const createDirResults = createDirSync(newFileParentDir, { recursive: true });
 				const fileContent = items.get(oldPath).data;
 				const writeResults = writeFileSync(newPath, fileContent);
 				results.newDirs.push(...createDirResults.newDirs);
@@ -22787,7 +23507,10 @@ const createSystem = (c) => {
 					isDirectory: true,
 					isFile: false
 				});
-				for (const oldDirItemChildPath of oldDirItemChildPaths) renameNewRecursiveSync(oldDirItemChildPath, oldDirItemChildPath.replace(oldPath, newPath), results);
+				for (const oldDirItemChildPath of oldDirItemChildPaths) {
+					const newDirItemChildPath = oldDirItemChildPath.replace(oldPath, newPath);
+					renameNewRecursiveSync(oldDirItemChildPath, newDirItemChildPath, results);
+				}
 			}
 		}
 	};
@@ -23019,7 +23742,7 @@ const createSystem = (c) => {
 		isSymbolicLink,
 		nextTick,
 		normalizePath: normalize,
-		platformPath: path$1,
+		platformPath: path,
 		readDir,
 		readDirSync,
 		readFile,
@@ -23177,13 +23900,13 @@ const getTranspileConfigOpt = (value, validValues, defaultValue) => {
 	if (validValues.has(value)) return value;
 	return defaultValue;
 };
-const VALID_EXPORT = new Set(["customelement", "module"]);
-const VALID_METADATA = new Set(["compilerstatic", null]);
-const VALID_MODULE = new Set(["cjs", "esm"]);
-const VALID_PROXY = new Set(["defineproperty", null]);
-const VALID_STYLE = new Set(["static"]);
-const VALID_STYLE_IMPORT_DATA = new Set(["queryparams"]);
-const VALID_TARGET = new Set([
+const VALID_EXPORT = /* @__PURE__ */ new Set(["customelement", "module"]);
+const VALID_METADATA = /* @__PURE__ */ new Set(["compilerstatic", null]);
+const VALID_MODULE = /* @__PURE__ */ new Set(["cjs", "esm"]);
+const VALID_PROXY = /* @__PURE__ */ new Set(["defineproperty", null]);
+const VALID_STYLE = /* @__PURE__ */ new Set(["static"]);
+const VALID_STYLE_IMPORT_DATA = /* @__PURE__ */ new Set(["queryparams"]);
+const VALID_TARGET = /* @__PURE__ */ new Set([
 	"latest",
 	"esnext",
 	"es2020",
@@ -23343,8 +24066,10 @@ const transpile = async (code, opts = {}) => {
 			patchTypescript(validatedConfig, null);
 			transpileCode(validatedConfig, compileOpts, transformOpts, results);
 		} else if (results.inputFileExtension === "d.ts") results.code = "";
-		else if (results.inputFileExtension === "css") await transpileCss(getTranspileCssConfig(opts, importData, results), results);
-		else if (results.inputFileExtension === "json") transpileJson(results);
+		else if (results.inputFileExtension === "css") {
+			const transformInput = getTranspileCssConfig(opts, importData, results);
+			await transpileCss(transformInput, results);
+		} else if (results.inputFileExtension === "json") transpileJson(results);
 	} catch (e) {
 		catchError(results.diagnostics, e);
 	}
@@ -23368,8 +24093,10 @@ const transpileSync = (code, opts = {}) => {
 			patchTypescript(validatedConfig, null);
 			transpileCode(validatedConfig, compileOpts, transformOpts, results);
 		} else if (results.inputFileExtension === "d.ts") results.code = "";
-		else if (results.inputFileExtension === "css") transpileCssSync(getTranspileCssConfig(opts, importData, results), results);
-		else if (results.inputFileExtension === "json") transpileJson(results);
+		else if (results.inputFileExtension === "css") {
+			const transformInput = getTranspileCssConfig(opts, importData, results);
+			transpileCssSync(transformInput, results);
+		} else if (results.inputFileExtension === "json") transpileJson(results);
 	} catch (e) {
 		catchError(results.diagnostics, e);
 	}