@stencil/core 5.0.0-beta.14 → 5.0.0-beta.16

package/dist/{compiler-Bit_AiP4.mjs → compiler-BIPF8u8e.mjs}

@@ -1,9 +1,9 @@
 import { n as __require } from "./rolldown-runtime-BhDjJH2R.mjs";
-import { S as HYDRATED_CSS } from "./client-CAQvc3hT.mjs";
+import { E as SERVER_BUILD_FLAGS, T as HYDRATED_CSS, w as CLIENT_BUILD_FLAGS } from "./client-BUal4Vkx.mjs";
 import { $ as VALID_CONFIG_OUTPUT_TARGETS, A as DIST_LAZY, D as COPY, E as COLLECTION_MANIFEST_FILE_NAME, J as STANDALONE, L as EVENT_FLAGS, P as DOCS_JSON, Q as TYPES, R as GENERATED_DTS, S as ASSETS, T as COLLECTION_APP_DATA_FILE_NAME, U as LOADER_BUNDLE, X as STYLE_EXT, Y as STATS, a as isBoolean$1, b as unique, c as isFunction, d as isObject, et as WATCH_FLAGS, f as isString$1, g as sortBy, i as fromEntries, l as isIterable, m as noop, p as mergeIntoWith, r as flatOne, t as dashToPascalCase, u as isNumber$1, v as toDashCase, w as COLLECTION, y as toTitleCase, z as GLOBAL_STYLE } from "./helpers-Cpp3qc3u.mjs";
 import { E as escapeRegExpSpecialCharacters, S as formatComponentRuntimeMeta, T as byteSize, _ as loadRolldownDiagnostics, a as getSourceMappingUrlForEndOfFile, b as splitLineBreaks, c as err, f as augmentDiagnosticWithNode, g as isRolldownError, h as createOnWarnFn, i as getInlineSourceMappingUrlLinker, l as map, m as loadTypeScriptDiagnostics, n as validateComponentTag, p as loadTypeScriptDiagnostic, r as isRemoteUrl, s as rolldownToStencilSourceMap, t as validateComponentModes, u as ok, w as stringifyRuntimeData, x as isRootPath, y as normalizeDiagnostics } from "./validation-DAdGTrys.mjs";
 import { $ as catchError, A as isOutputTargetDocsVscode, B as relativeImport, C as isOutputTargetDistLazy, D as isOutputTargetDocsCustomElementsManifest, E as isOutputTargetDocsCustom, F as isOutputTargetStandalone, G as normalizeFsPathQuery, H as join$2, I as isOutputTargetStats, J as resolve$2, K as normalizePath, L as isOutputTargetTypes, M as isOutputTargetLoaderBundle, N as isOutputTargetSsr, O as isOutputTargetDocsJson, P as isOutputTargetSsrWasm, Q as buildWarn, R as isOutputTargetWww, S as isOutputTargetCustom, T as isOutputTargetDocsAgentSkill, V as shouldExcludeComponent, W as normalizeFsPath, X as buildError, Z as buildJsonFileError, a as hasDependency, b as isOutputTargetCollection, d as parsePackageJson, et as hasError, f as readOnlyArrayHasStringMember, g as getComponentsDtsSrcFilePath, h as filterExcludedComponents, i as getTextDocs, j as isOutputTargetGlobalStyle, k as isOutputTargetDocsReadme, l as isTsFile, m as filterActiveTargets, n as createJsVarName, o as isDtsFile, p as readPackageJson, q as relative$1, r as generatePreamble, rt as isGlob, t as addDocBlock, tt as hasWarning, u as isTsxFile, v as getComponentsFromModules, w as isOutputTargetDocs, x as isOutputTargetCopy, y as isOutputTargetAssets, z as isValidConfigOutputTarget } from "./util-IKfWWLJo.mjs";
-import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-Bw9pHJOq.mjs";
+import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-DGo5Qu7U.mjs";
 import ts, { default as ts$1 } from "typescript";
 import { readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
@@ -23,7 +23,6 @@ import { minify } from "terser";
 import { SelectorType, parse, stringify } from "css-what";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { execSync } from "child_process";
 import * as os from "os";
 import browserslist from "browserslist";
 import { browserslistToTargets, transform } from "lightningcss";
@@ -462,9 +461,9 @@ const scopeCss = (cssText, scopeId, commentOriginalSelector) => {
 };
 //#endregion
 //#region src/version.ts
-const version = "5.0.0-beta.14";
-const buildId = "1790782456";
-const vermoji = "🐬";
+const version = "5.0.0-beta.16";
+const buildId = "1791325639";
+const vermoji = "🔮";
 /**
 * Get the installed version of a tool/dependency.
 * Handles packages with exports maps that point to subdirectories.
@@ -2293,12 +2292,10 @@ const updateBuildConditionals = (config, b) => {
 const CREATE_EVENT = "__stencil_createEvent";
 const DEFINE_CUSTOM_ELEMENT = "__stencil_defineCustomElement";
 const GET_ELEMENT = "__stencil_getElement";
-const HOST = "__stencil_Host";
 const HTML_ELEMENT = "HTMLElement";
 const PROXY_CUSTOM_ELEMENT = "__stencil_proxyCustomElement";
 const REGISTER_INSTANCE = "__stencil_registerInstance";
 const REGISTER_HOST = "__stencil_registerHost";
-const H = "__stencil_h";
 const TRANSFORM_TAG = "__stencil_transformTag";
 const GET_REGISTRY = "__stencil_getRegistry";
 const INJECT_SIDE_EFFECT_STYLE = "__stencil_injectSideEffectStyle";
@@ -2306,9 +2303,7 @@ const RUNTIME_APIS = {
 	createEvent: `createEvent as ${CREATE_EVENT}`,
 	defineCustomElement: `defineCustomElement as ${DEFINE_CUSTOM_ELEMENT}`,
 	getElement: `getElement as ${GET_ELEMENT}`,
-	h: `h as ${H}`,
 	legacyH: `h`,
-	Host: `Host as ${HOST}`,
 	HTMLElement: HTML_ELEMENT,
 	proxyCustomElement: `proxyCustomElement as ${PROXY_CUSTOM_ELEMENT}`,
 	registerHost: `registerHost as ${REGISTER_HOST}`,
@@ -4498,7 +4493,7 @@ const appDataPlugin = (config, compilerCtx, buildCtx, buildConditionals, platfor
 		name: "appDataPlugin",
 		resolveId: {
 			filter: { id: /^@stencil\/core\/app-(data|globals)$/ },
-			handler(id, importer) {
+			handler(id) {
 				if (id === "@stencil/core/app-data" || id === "@stencil/core/app-globals") {
 					if (platform === "worker") this.error("@stencil/core packages cannot be imported from a worker.");
 					return id;
@@ -4687,19 +4682,6 @@ const appendNamespace = (config, s) => {
 };
 //#endregion
 //#region src/compiler/sys/fetch/fetch-utils.ts
-/**
-* A fetch wrapper which dispatches to `sys.fetch` if present, and otherwise
-* uses `global.fetch`.
-*
-* @param sys a compiler system object
-* @param input a `RequestInfo` object
-* @param init an optional `RequestInit` object
-* @returns a Promise wrapping a response
-*/
-const httpFetch = (sys, input, init) => {
-	if (sys && isFunction(sys.fetch)) return sys.fetch(input, init);
-	return fetch(input, init);
-};
 const packageVersions = /* @__PURE__ */ new Map();
 const known404Urls = /* @__PURE__ */ new Set();
 /**
@@ -4770,7 +4752,7 @@ const writeFetchSuccessAsync = async (sys, inMemoryFs, url, filePath, content, p
 const fetchModuleAsync = async (sys, inMemoryFs, pkgVersions, url, filePath) => {
 	if (skipFilePathFetch(filePath) || known404Urls.has(url) || skipUrlFetch(url)) return;
 	try {
-		const rsp = await httpFetch(sys, url);
+		const rsp = await fetch(url);
 		if (rsp) {
 			if (rsp.ok) {
 				const content = await rsp.clone().text();
@@ -4837,13 +4819,11 @@ const coreResolvePlugin = (config, compilerCtx, platform, externalRuntime, lazyL
 				if (filePath && !filePath.startsWith("\0")) {
 					filePath = normalizeFsPath(filePath);
 					if (filePath === internalClient || filePath === internalSsr) {
-						if (platform === "worker") return `
-export const Build = {
-  isDev: ${config.devMode},
-  isBrowser: true,
-  isServer: false,
-  isTesting: false,
-};`;
+						if (platform === "worker") return `export const Build = ${JSON.stringify({
+							...CLIENT_BUILD_FLAGS,
+							isDev: config.devMode,
+							isTesting: false
+						})};`;
 						const cached = transformedCodeCache.get(filePath);
 						if (cached) return cached;
 						let code = await compilerCtx.fs.readFile(filePath);
@@ -4956,6 +4936,139 @@ const buildConditionalsPlugin = (config, buildConditionals) => {
 	};
 };
 //#endregion
+//#region src/compiler/bundle/build-flags-plugin.ts
+const STENCIL_CORE_IMPORT_RE = /^@stencil\/core(?:\/runtime(?:\/(?:client(?:\/(?:standalone|lazy))?|server))?)?$/;
+const BUILD_IMPORT_RE = /\bimport\s*\{[^}]*\bBuild\b[^}]*\}\s*from\s*['"]@stencil\/core/;
+/**
+* Rolldown plugin that folds user-code `Build.<flag>` reads to literals (see {@link foldBuildFlags}),
+* so rolldown can tree-shake gated branches - and anything only they import - before chunking.
+*
+* Only flags whose value is fixed for this bundle are folded. With an external runtime,
+* `isDev` / `isTesting` come from the consumer's app-data, so they're left as runtime reads.
+*
+* @param bundleOpts the options for this bundle
+* @returns a rolldown plugin
+*/
+const buildFlagsPlugin = (bundleOpts) => {
+	const flags = getFoldableBuildFlags(bundleOpts);
+	return {
+		name: "stencil-build-flags",
+		transform: {
+			filter: { code: BUILD_IMPORT_RE },
+			handler(code, id) {
+				if (id.startsWith("\0")) return null;
+				const folded = foldBuildFlags(code, id.split("?")[0], flags);
+				return folded === null ? null : {
+					code: folded,
+					map: null
+				};
+			}
+		}
+	};
+};
+/**
+* The `Build` flags with a fixed value in this bundle.
+*
+* @param bundleOpts the options for this bundle
+* @returns the foldable flags
+*/
+const getFoldableBuildFlags = (bundleOpts) => {
+	if (bundleOpts.platform === "ssr") return { ...SERVER_BUILD_FLAGS };
+	const flags = { ...CLIENT_BUILD_FLAGS };
+	const conditionals = bundleOpts.conditionals;
+	if (bundleOpts.platform === "client" && !bundleOpts.externalRuntime && conditionals) {
+		if (typeof conditionals.isDev === "boolean") flags.isDev = conditionals.isDev;
+		if (typeof conditionals.isTesting === "boolean") flags.isTesting = conditionals.isTesting;
+	}
+	return flags;
+};
+/**
+* Replaces `Build.<flag>` reads (where `Build` is imported from `@stencil/core`) with literals,
+* letting bundlers / minify-ers drop dead branches. Neither oxc nor terser can fold a property
+* read on the runtime's `Build` object.
+*
+* e.g. with `{ isServer: false }`:
+* ```ts
+* if (Build.isServer) { … }  // before
+* if (false         ) { … }  // after
+* ```
+*
+* Replacements are padded to the original length (newlines kept), so an existing sourcemap
+* for `code` stays valid. A `Build` binding that is shadowed or written to in the module is left alone.
+*
+* @param code JS or TS source
+* @param fileName used to pick the parser's script kind
+* @param flags the flag values to fold; flags not present are left as runtime reads
+* @returns the folded code, or `null` if nothing was folded
+*/
+const foldBuildFlags = (code, fileName, flags) => {
+	if (!BUILD_IMPORT_RE.test(code)) return null;
+	const sourceFile = ts.createSourceFile(fileName, code, ts.ScriptTarget.Latest, true, getScriptKind(fileName));
+	const buildSpecifiers = /* @__PURE__ */ new Set();
+	for (const stmt of sourceFile.statements) if (ts.isImportDeclaration(stmt) && stmt.importClause?.phaseModifier !== ts.SyntaxKind.TypeKeyword && ts.isStringLiteral(stmt.moduleSpecifier) && STENCIL_CORE_IMPORT_RE.test(stmt.moduleSpecifier.text) && stmt.importClause?.namedBindings && ts.isNamedImports(stmt.importClause.namedBindings)) {
+		for (const el of stmt.importClause.namedBindings.elements) if (!el.isTypeOnly && (el.propertyName ?? el.name).text === "Build") buildSpecifiers.add(el);
+	}
+	if (buildSpecifiers.size === 0) return null;
+	const locals = new Set([...buildSpecifiers].map((el) => el.name.text));
+	const unsafe = /* @__PURE__ */ new Set();
+	const reads = [];
+	const visit = (node) => {
+		if (ts.isIdentifier(node) && locals.has(node.text)) {
+			const parent = node.parent;
+			if (isDeclarationName(node) && !buildSpecifiers.has(parent)) unsafe.add(node.text);
+			else {
+				const flag = getAccessedFlag(parent, node);
+				if (flag !== void 0) {
+					const access = parent;
+					if (isWriteTarget(access)) unsafe.add(node.text);
+					else {
+						const value = flags[flag];
+						if (typeof value === "boolean") reads.push({
+							local: node.text,
+							start: access.getStart(sourceFile),
+							end: access.end,
+							value
+						});
+					}
+				}
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	const toFold = reads.filter((r) => !unsafe.has(r.local));
+	if (toFold.length === 0) return null;
+	let out = code;
+	for (const { start, end, value } of toFold.sort((a, b) => b.start - a.start)) {
+		const original = code.slice(start, end);
+		const nl = original.search(/[\r\n]/);
+		const head = nl === -1 ? original : original.slice(0, nl);
+		const tail = nl === -1 ? "" : original.slice(nl).replace(/[^\r\n]/g, " ");
+		out = out.slice(0, start) + String(value).padEnd(head.length) + tail + out.slice(end);
+	}
+	return out;
+};
+const getScriptKind = (fileName) => {
+	if (/\.tsx$/.test(fileName)) return ts.ScriptKind.TSX;
+	if (/\.[mc]?ts$/.test(fileName)) return ts.ScriptKind.TS;
+	if (/\.jsx$/.test(fileName)) return ts.ScriptKind.JSX;
+	return ts.ScriptKind.JS;
+};
+const isDeclarationName = (node) => {
+	const p = node.parent;
+	return (ts.isVariableDeclaration(p) || ts.isParameter(p) || ts.isBindingElement(p) || ts.isFunctionDeclaration(p) || ts.isFunctionExpression(p) || ts.isClassDeclaration(p) || ts.isClassExpression(p) || ts.isEnumDeclaration(p) || ts.isModuleDeclaration(p) || ts.isImportEqualsDeclaration(p) || ts.isImportClause(p) || ts.isNamespaceImport(p) || ts.isImportSpecifier(p)) && p.name === node;
+};
+const getAccessedFlag = (parent, node) => {
+	if (ts.isPropertyAccessExpression(parent) && parent.expression === node) return parent.name.text;
+	if (ts.isElementAccessExpression(parent) && parent.expression === node && ts.isStringLiteralLike(parent.argumentExpression)) return parent.argumentExpression.text;
+};
+const isWriteTarget = (access) => {
+	const p = access.parent;
+	if (ts.isBinaryExpression(p)) return p.left === access && p.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && p.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
+	if (ts.isPrefixUnaryExpression(p) || ts.isPostfixUnaryExpression(p)) return p.operator === ts.SyntaxKind.PlusPlusToken || p.operator === ts.SyntaxKind.MinusMinusToken;
+	return ts.isDeleteExpression(p);
+};
+//#endregion
 //#region src/compiler/bundle/constants.ts
 const DEV_MODULE_DIR = `~dev-module`;
 //#endregion
@@ -6506,6 +6619,7 @@ const getRolldownOptions = (config, compilerCtx, buildCtx, bundleOpts) => {
 			loaderPlugin(bundleOpts.loader),
 			userIndexPlugin(config, compilerCtx),
 			typescriptPlugin(compilerCtx, bundleOpts, config),
+			buildFlagsPlugin(bundleOpts),
 			extFormatPlugin(config),
 			extTransformsPlugin(config, compilerCtx, buildCtx),
 			workerPlugin(config, compilerCtx, buildCtx, bundleOpts.platform, !!bundleOpts.inlineWorkers),
@@ -7238,31 +7352,6 @@ const createIdentifierFromStyleIdentifier = (styleIdentifier, externalStyleIds)
 	return ts.factory.createBinaryExpression(createIdentifierFromStyleIdentifier(styleIdentifier, [id]), ts.SyntaxKind.PlusToken, createIdentifierFromStyleIdentifier(styleIdentifier, externalStyleIds.slice(1)));
 };
 //#endregion
-//#region src/compiler/transformers/host-data-transform.ts
-const transformHostData = (classElements, moduleFile) => {
-	if (classElements.some((e) => ts.isMethodDeclaration(e) && e.name.escapedText === "hostData")) {
-		const renderIndex = classElements.findIndex((e) => ts.isMethodDeclaration(e) && e.name.escapedText === "render");
-		if (renderIndex >= 0) {
-			const renderMethod = classElements[renderIndex];
-			classElements[renderIndex] = ts.factory.updateMethodDeclaration(renderMethod, retrieveModifierLike(renderMethod), renderMethod.asteriskToken, ts.factory.createIdentifier(INTERNAL_RENDER), renderMethod.questionToken, renderMethod.typeParameters, renderMethod.parameters, renderMethod.type, renderMethod.body);
-		}
-		classElements.push(syntheticRender(moduleFile, renderIndex >= 0));
-	}
-};
-const syntheticRender = (moduleFile, hasRender) => {
-	addCoreRuntimeApi(moduleFile, RUNTIME_APIS.Host);
-	addCoreRuntimeApi(moduleFile, RUNTIME_APIS.h);
-	const hArguments = [ts.factory.createIdentifier(HOST), ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), "hostData"), void 0, void 0)];
-	if (hasRender) hArguments.push(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), INTERNAL_RENDER), void 0, void 0));
-	/**
-	* render() {
-	*   return h(arguments);
-	* }
-	*/
-	return ts.factory.createMethodDeclaration(void 0, void 0, "render", void 0, void 0, [], void 0, ts.factory.createBlock([ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier(H), void 0, hArguments))]));
-};
-const INTERNAL_RENDER = "__stencil_render";
-//#endregion
 //#region src/compiler/transformers/reactive-handler-meta-transform.ts
 /**
 * Add a getter to a class for a static representation of the watchers
@@ -7344,7 +7433,6 @@ const updateLazyComponentMembers = (transformOpts, styleStatements, classNode, m
 	addReactivePropHandlers(classMembers, cmp, "watchers");
 	addReactivePropHandlers(classMembers, cmp, "serializers");
 	addReactivePropHandlers(classMembers, cmp, "deserializers");
-	transformHostData(classMembers, moduleFile);
 	if (transformOpts.style === "static") addStaticStylePropertyToClass(styleStatements, cmp, buildCtx);
 	return classMembers;
 };
@@ -11158,7 +11246,6 @@ const generateEventDetailTypes = (cmp) => {
 //#endregion
 //#region src/compiler/types/types-utils.ts
 const COMPONENTS_DTS_HEADER = `/* eslint-disable */
-/* tslint:disable */
 /**
  * This is an autogenerated file created by the Stencil compiler.
  * It contains typing information for all components that exist in this project.
@@ -11505,14 +11592,16 @@ export declare function setAssetPath(path: string): string;
 };
 /**
 * Generate standalone.d.ts file for the standalone output target.
-* This provides types for setNonce and setPlatformOptions.
+* This provides types for setNonce and setPlatformOptions, and re-exports the component
+* types (as loader.d.ts does) so they're reachable from a standalone-only package root.
 *
 * @param compilerCtx the current compiler context
 * @param typesDir the directory to write the standalone.d.ts file to
 * @param hasAssets whether any component declares assets, matching whether setAssetPath is actually exported
 */
 const generateStandaloneApiTypes = async (compilerCtx, typesDir, hasAssets) => {
-	const standaloneDtsContent = `/**
+	const standaloneDtsContent = `export * from './components';
+/**
  * Used to specify a nonce value that corresponds with an application's CSP.
  * When set, the nonce will be added to all dynamically created script and style tags at runtime.
  * Alternatively, the nonce value can be set on a meta tag in the DOM head
@@ -12136,7 +12225,6 @@ const getHydrateAttrsToReflect = (cmp) => {
 * - Updating the constructor to be lazy (only initialize when needed in the app factory)
 * - Adding a static getter for the lazy element (which is used in the app factory to determine which components are needed)
 * - Adding reactive property handlers for watchers, serializers, and deserializers (which are used in the app factory to set up reactive properties)
-* - Transforming the `hostData` method to be compatible with SSR
 *
 * @param classNode the class declaration to transform
 * @param moduleFile the module file containing the class declaration
@@ -12155,7 +12243,6 @@ const updateSsrHostComponentMembers = (classNode, moduleFile, cmp, buildCtx) =>
 	addReactivePropHandlers(classMembers, cmp, "serializers");
 	addReactivePropHandlers(classMembers, cmp, "deserializers");
 	addHydrateRuntimeCmpMeta(classMembers, cmp, buildCtx);
-	transformHostData(classMembers, moduleFile);
 	return classMembers;
 };
 //#endregion
@@ -13515,7 +13602,6 @@ const updateNativeHostComponentMembers = (transformOpts, classNode, moduleFile,
 	addReactivePropHandlers(classMembers, cmp, "deserializers");
 	if (cmp.isPlain) addNativeComponentMeta(classMembers, cmp);
 	if (transformOpts.style === "static") addNativeStaticStyle(classMembers, cmp, buildCtx);
-	transformHostData(classMembers, moduleFile);
 	return classMembers;
 };
 //#endregion
@@ -17701,7 +17787,6 @@ function mergeExtendedClassMetaWithResolveImport(cmpNode, staticMembers, sourceF
 //#region src/compiler/transformers/static-to-meta/class-methods.ts
 const parseClassMethods = (classMethods, cmpMeta) => {
 	if (!classMethods?.length) return;
-	const hasHostData = classMethods.includes("hostData");
 	cmpMeta.hasAttributeChangedCallbackFn = classMethods.includes("attributeChangedCallback");
 	cmpMeta.hasConnectedCallbackFn = classMethods.includes("connectedCallback");
 	cmpMeta.hasDisconnectedCallbackFn = classMethods.includes("disconnectedCallback");
@@ -17713,8 +17798,7 @@ const parseClassMethods = (classMethods, cmpMeta) => {
 	cmpMeta.hasComponentShouldUpdateFn = classMethods.includes("componentShouldUpdate");
 	cmpMeta.hasComponentDidUpdateFn = classMethods.includes("componentDidUpdate");
 	cmpMeta.hasLifecycle = cmpMeta.hasComponentWillLoadFn || cmpMeta.hasComponentDidLoadFn || cmpMeta.hasComponentWillUpdateFn || cmpMeta.hasComponentDidUpdateFn;
-	cmpMeta.hasRenderFn = classMethods.includes("render") || hasHostData;
-	cmpMeta.hasVdomRender = cmpMeta.hasVdomRender || hasHostData;
+	cmpMeta.hasRenderFn = classMethods.includes("render");
 };
 //#endregion
 //#region src/compiler/transformers/static-to-meta/element-ref.ts
@@ -18950,13 +19034,13 @@ const getRelativeDts = (config, srcPath, emitDtsPath) => {
 const previousComponentStyles = /* @__PURE__ */ new Map();
 /**
 * Generate the Hot Module Replacement (HMR) data for the current build.
-* @param config a user-supplied config
+* @param config the validated Stencil config
 * @param compilerCtx the compiler context
 * @param buildCtx the build context
 * @returns the HMR data
 */
 const generateHmr = (config, compilerCtx, buildCtx) => {
-	if (config.devServer?.reloadStrategy == null) return null;
+	if (config.devServer.reloadStrategy == null) return null;
 	const hmr = {
 		reloadStrategy: config.devServer.reloadStrategy,
 		versionId: Date.now().toString().substring(6) + "" + Math.round(Math.random() * 89999 + 1e4)
@@ -19052,7 +19136,7 @@ const addTsFileImporters = (allModuleFiles, filesToLookForImporters, checkedFile
 };
 const getExternalStylesUpdated = (config, buildCtx) => {
 	if (!buildCtx.isRebuild) return null;
-	const globalStyleFileNames = /* @__PURE__ */ new Set([...config.fsNamespace ? [getStencilCssFileName(config.fsNamespace)] : [], ...config.outputTargets.filter(isOutputTargetGlobalStyle).map((o) => o.fileName)]);
+	const globalStyleFileNames = /* @__PURE__ */ new Set([getStencilCssFileName(config.fsNamespace), ...config.outputTargets.filter(isOutputTargetGlobalStyle).map((o) => o.fileName)]);
 	const cssFiles = buildCtx.filesWritten.filter((f) => f.endsWith(".css")).map((f) => basename$1(f)).filter((fileName) => !globalStyleFileNames.has(fileName));
 	if (cssFiles.length === 0) return null;
 	return cssFiles.sort();
@@ -19072,7 +19156,7 @@ const getImagesUpdated = (buildCtx, outputTargetsWww) => {
 /**
 * Determine a list of files (if any) which should be excluded from HMR updates.
 *
-* @param config a user-supplied config
+* @param config the validated Stencil config
 * @param excludeHmr a list of glob patterns that should be used to determine
 * whether to exclude a file or not (a file will be excluded if it matches one
 * @param filesChanged an array of files which are changed in the HMR update
@@ -19430,7 +19514,7 @@ const cleanupUpdateMsg = (logger, msg, fileNames) => {
 */
 const cleanDiagnosticsRelativePath = (config, diagnostics) => {
 	diagnostics.forEach((diagnostic) => {
-		if (!diagnostic.relFilePath && diagnostic.absFilePath && !isRemoteUrl(diagnostic.absFilePath) && config.rootDir) diagnostic.relFilePath = relative$1(config.rootDir, diagnostic.absFilePath);
+		if (!diagnostic.relFilePath && diagnostic.absFilePath && !isRemoteUrl(diagnostic.absFilePath)) diagnostic.relFilePath = relative$1(config.rootDir, diagnostic.absFilePath);
 	});
 };
 //#endregion
@@ -19810,149 +19894,199 @@ const validateBuildFiles = (config, compilerCtx, buildCtx) => {
 };
 //#endregion
 //#region src/compiler/build/write-export-maps.ts
+const OWNED_CONDITIONS = [
+	"types",
+	"import",
+	"require"
+];
+const isJsonObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 /**
-* Create the shared {@link NpmPkgSet} used across a single `writeExportMaps` run.
-* @param buildCtx The build context to report a warning diagnostic on if `npm` can't be run
-* @returns A function that shells out to `npm pkg set`, swallowing failure after warning once
-*/
-const createNpmPkgSet = (buildCtx) => {
-	let npmAvailable = true;
-	return (cmd) => {
-		if (!npmAvailable) return;
-		try {
-			execSync(`npm pkg set ${cmd}`);
-		} catch (e) {
-			npmAvailable = false;
-			const warn = buildWarn(buildCtx.diagnostics);
-			warn.messageText = `Unable to generate "exports" map in package.json: the "npm" CLI could not be run (${e.message ?? e}). Set "generateExportMaps: false" in your Stencil config to silence this warning.`;
-		}
-	};
-};
-/**
-* Create export map entry point definitions for the `package.json` file using the npm CLI.
+* Write the `exports` map entry points into the project's `package.json`.
 *
-* In v5, this uses a "smart default" approach:
-* - Check if exports["."] already points to a valid output (loader-bundle or standalone)
-* - If valid, leave it alone (respect user customization)
-* - If missing or invalid, set a sensible default (loader-bundle > standalone priority)
-* - Always ensure types field is set correctly
-* - Generate per-component exports for standalone output
+* - `exports["."]`: an `import` / `types` target that exists on disk is left alone
+*   (respects user customization), otherwise a default is set (loader-bundle > standalone)
+* - every other generated entry is owned by Stencil and rewritten on each build
+* - per-component entries whose component no longer exists are removed
+* - entries Stencil doesn't generate are left untouched
 *
 * @param config The validated Stencil config
-* @param compilerCtx The compiler context (used to detect a user-authored src/index.ts)
+* @param compilerCtx The compiler context
 * @param buildCtx The build context containing the components to generate export maps for
 */
-const writeExportMaps = (config, compilerCtx, buildCtx) => {
+const writeExportMaps = async (config, compilerCtx, buildCtx) => {
 	const loaderBundle = config.outputTargets.find(isOutputTargetLoaderBundle);
 	const standalone = config.outputTargets.find(isOutputTargetStandalone);
+	const ssr = config.outputTargets.find(isOutputTargetSsr);
 	const types = config.outputTargets.find(isOutputTargetTypes);
-	const npmPkgSet = createNpmPkgSet(buildCtx);
-	generateRootExport(config, compilerCtx, buildCtx, loaderBundle, standalone, types, npmPkgSet);
-	if (loaderBundle) generateLoaderExport(config, loaderBundle, types, npmPkgSet);
-	if (standalone) generateComponentExports(config, buildCtx, standalone, npmPkgSet);
+	if (!loaderBundle && !standalone && !ssr) return;
+	const source = await readPackageJsonSource(config, compilerCtx);
+	const pkg = source ? parsePackageJson(source, config.packageJsonFilePath).data : null;
+	if (!source || !isJsonObject(pkg)) return;
+	let exportMap = toExportMap(pkg.exports);
+	if (loaderBundle || standalone) {
+		const root = getRootExport(config, compilerCtx, exportMap["."], loaderBundle, standalone, types);
+		exportMap = "." in exportMap ? {
+			...exportMap,
+			".": root
+		} : {
+			".": root,
+			...exportMap
+		};
+	}
+	const generated = getGeneratedExports(config, buildCtx, loaderBundle, standalone, ssr, types);
+	if (standalone?.dir) removeStaleComponentExports(exportMap, generated, toRelativePath(config, standalone.dir));
+	for (const [key, entry] of Object.entries(generated)) exportMap[key] = isString$1(entry) ? entry : mergeConditions(exportMap[key], entry);
+	pkg.exports = exportMap;
+	const eol = source.includes("\r\n") ? "\r\n" : "\n";
+	const indent = /^([ \t]+)"/m.exec(source)?.[1] ?? 2;
+	let output = JSON.stringify(pkg, null, indent);
+	if (/\n\s*$/.test(source)) output += "\n";
+	output = output.replace(/\n/g, eol);
+	if (output !== source) await compilerCtx.fs.writeFile(config.packageJsonFilePath, output, { immediateWrite: true });
+};
+const readPackageJsonSource = async (config, compilerCtx) => {
+	try {
+		return await compilerCtx.fs.readFile(config.packageJsonFilePath);
+	} catch {
+		return;
+	}
+};
+/**
+* Normalize a `package.json` `exports` value into its subpath-keyed form.
+* @param current The current `exports` value
+* @returns A new subpath-keyed `exports` object
+*/
+const toExportMap = (current) => {
+	if (isString$1(current)) return { ".": current };
+	if (!isJsonObject(current)) return {};
+	const keys = Object.keys(current);
+	return keys.length > 0 && keys.every((key) => !key.startsWith(".")) ? { ".": current } : { ...current };
+};
+/**
+* Build an entry with Stencil's conditions first (`types` has to precede `import` / `require`
+* to be picked up by TypeScript), followed by any other conditions already on the entry.
+* @param current The entry's current value
+* @param owned The conditions to set; any owned condition left out is removed
+* @returns The merged entry
+*/
+const mergeConditions = (current, owned) => {
+	const others = isJsonObject(current) ? Object.entries(current).filter(([key]) => !OWNED_CONDITIONS.includes(key)) : [];
+	const { types, import: importPath, require: requirePath } = owned;
+	return Object.fromEntries([...Object.entries({
+		types,
+		import: importPath,
+		require: requirePath
+	}).filter(([, value]) => value !== void 0), ...others]);
 };
 /**
-* Generate the root export `exports["."]`.
+* Get the root export `exports["."]`.
 *
-* Uses smart default approach:
-* - Check if current root export points to a valid loader-bundle or standalone output
-* - If valid, leave it alone
-* - If missing or invalid, set default (loader-bundle > standalone priority)
 * @param config The validated Stencil config
-* @param compilerCtx The compiler context (used to detect a user-authored src/index.ts)
-* @param buildCtx The build context containing the components to generate export maps for
+* @param compilerCtx The compiler context
+* @param current The current root entry
 * @param loaderBundle The loader-bundle output target, if it exists
 * @param standalone The standalone output target, if it exists
 * @param types The types output target, if it exists
-* @param npmPkgSet Function used to run `npm pkg set`, tolerating an unavailable npm CLI
+* @returns The root entry to write
 */
-const generateRootExport = (config, compilerCtx, buildCtx, loaderBundle, standalone, types, npmPkgSet) => {
-	if (!loaderBundle && !standalone) return;
+const getRootExport = (config, compilerCtx, current, loaderBundle, standalone, types) => {
+	const isUsable = (target) => isString$1(target) ? compilerCtx.fs.accessSync(join$2(config.rootDir, target)) : target != null;
+	if (isString$1(current) && isUsable(current)) return current;
+	const existing = isJsonObject(current) ? current : {};
 	const hasSrcIndex = compilerCtx.fs.accessSync(join$2(config.srcDir, "index.ts"));
 	const rootUsesEmptyLoaderIndex = !!loaderBundle && !hasSrcIndex;
-	const currentImport = ((buildCtx.packageJson?.exports)?.["."])?.import;
-	if (!(currentImport && isValidRootExport(config, currentImport, loaderBundle, standalone))) {
+	const conditions = {
+		types: existing.types,
+		import: existing.import,
+		require: existing.require
+	};
+	if (!isUsable(existing.import)) {
 		const primaryDir = loaderBundle?.dir ?? standalone?.dir;
 		if (primaryDir) {
 			const entryFile = rootUsesEmptyLoaderIndex ? join$2("esm", "loader.js") : "index.js";
-			npmPkgSet(`"exports[.][import]"="${normalizePath(relative$1(config.rootDir, join$2(primaryDir, entryFile)))}"`);
+			conditions.import = toRelativePath(config, join$2(primaryDir, entryFile));
 			if (loaderBundle?.cjs) {
 				const cjsEntryFile = rootUsesEmptyLoaderIndex ? join$2("cjs", "loader.cjs") : "index.cjs";
-				npmPkgSet(`"exports[.][require]"="${normalizePath(relative$1(config.rootDir, join$2(loaderBundle.dir, cjsEntryFile)))}"`);
+				conditions.require = toRelativePath(config, join$2(loaderBundle.dir, cjsEntryFile));
 			}
 		}
 	}
-	if (types?.dir) {
-		const typesFile = rootUsesEmptyLoaderIndex ? "loader.d.ts" : "index.d.ts";
-		npmPkgSet(`"exports[.][types]"="${normalizePath(relative$1(config.rootDir, join$2(types.dir, typesFile)))}"`);
+	if (types?.dir && !isUsable(existing.types)) {
+		const typesFile = hasSrcIndex ? "index.d.ts" : loaderBundle ? "loader.d.ts" : "standalone.d.ts";
+		conditions.types = toRelativePath(config, join$2(types.dir, typesFile));
 	}
+	return mergeConditions(existing, conditions);
 };
 /**
-* Check if the current root export import path is valid
-* (points to either loader-bundle or standalone output).
+* Get every non-root entry Stencil generates for the configured output targets.
+*
 * @param config The validated Stencil config
-* @param currentImport The current import path from exports["."]
+* @param buildCtx The build context containing the components to generate export maps for
 * @param loaderBundle The loader-bundle output target, if it exists
 * @param standalone The standalone output target, if it exists
-* @returns True if the current import path points to a valid output, false otherwise
+* @param ssr The ssr output target, if it exists
+* @param types The types output target, if it exists
+* @returns The generated entries, keyed by subpath
 */
-const isValidRootExport = (config, currentImport, loaderBundle, standalone) => {
-	const normalizedCurrent = normalizePath(currentImport);
-	if (loaderBundle?.dir) {
-		const loaderBundlePath = normalizePath(relative$1(config.rootDir, loaderBundle.dir));
-		if (normalizedCurrent.includes(loaderBundlePath)) return true;
-	}
+const getGeneratedExports = (config, buildCtx, loaderBundle, standalone, ssr, types) => {
+	const generated = {};
+	if (loaderBundle) generated["./loader"] = {
+		types: types?.dir ? toRelativePath(config, join$2(types.dir, "loader.d.ts")) : void 0,
+		import: toRelativePath(config, join$2(loaderBundle.dir, "esm", "loader.js")),
+		require: loaderBundle.cjs ? toRelativePath(config, join$2(loaderBundle.dir, "cjs", "loader.cjs")) : void 0
+	};
 	if (standalone?.dir) {
-		const standalonePath = normalizePath(relative$1(config.rootDir, standalone.dir));
-		if (normalizedCurrent.includes(standalonePath)) return true;
+		const outDir = toRelativePath(config, standalone.dir);
+		generated["./standalone"] = {
+			types: `${outDir}/index.d.ts`,
+			import: `${outDir}/index.js`
+		};
+		for (const cmp of buildCtx.components) generated[`./${cmp.tagName}`] = {
+			types: `${outDir}/${cmp.tagName}.d.ts`,
+			import: `${outDir}/${cmp.tagName}.js`
+		};
 	}
-	return false;
-};
-/**
-* Ensure a path has a relative prefix (./ or ../).
-* Handles cases where normalizePath/relative may or may not add the prefix.
-* @param path The path to ensure has a relative prefix
-* @returns The path with a relative prefix
-*/
-const ensureRelativePrefix = (path) => {
-	if (path.startsWith("./") || path.startsWith("../")) return path;
-	return "./" + path;
+	if (ssr?.dir) {
+		const outDir = toRelativePath(config, ssr.dir);
+		generated["./ssr"] = {
+			types: `${outDir}/index.d.ts`,
+			import: `${outDir}/index.js`,
+			require: ssr.cjs ? `${outDir}/index.cjs` : void 0
+		};
+	}
+	if (loaderBundle || standalone) {
+		const globalStyles = config.outputTargets.filter(isOutputTargetGlobalStyle);
+		const assetsDir = (config.outputTargets.find(isOutputTargetAssets) ?? globalStyles[0])?.dir;
+		if (assetsDir) generated["./assets/*"] = `${toRelativePath(config, assetsDir)}/*`;
+		for (const globalStyle of globalStyles) if (globalStyle.dir && globalStyle.fileName && globalStyle.dir !== assetsDir) generated[`./assets/${globalStyle.fileName}`] = toRelativePath(config, join$2(globalStyle.dir, globalStyle.fileName));
+	}
+	return generated;
 };
 /**
-* Generate the loader export `exports["./loader"]`.
+* Remove per-component entries Stencil generated for components that no longer exist.
+* Only an entry in the exact shape Stencil writes (`./<tag>` → `<standalone dir>/<tag>.js`)
+* is removed, so entries added by the author are left alone.
 *
-* Points directly to the esm/loader.js file in the loader-bundle output.
-* No separate loader directory is generated - package.json exports handle the mapping.
-*
-* @param config The validated Stencil config
-* @param loaderBundle The loader-bundle output target
-* @param types The types output target, if it exists
-* @param npmPkgSet Function used to run `npm pkg set`, tolerating an unavailable npm CLI
+* @param exportMap The export map to remove entries from
+* @param generated The entries generated by this build
+* @param standaloneDir The standalone output directory, relative to the project root
 */
-const generateLoaderExport = (config, loaderBundle, types, npmPkgSet) => {
-	const esmDir = join$2(loaderBundle.dir, "esm");
-	npmPkgSet(`"exports[./loader][import]"="${ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(esmDir, "loader.js"))))}"`);
-	if (loaderBundle.cjs) {
-		const cjsDir = join$2(loaderBundle.dir, "cjs");
-		npmPkgSet(`"exports[./loader][require]"="${ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(cjsDir, "loader.cjs"))))}"`);
+const removeStaleComponentExports = (exportMap, generated, standaloneDir) => {
+	for (const [key, entry] of Object.entries(exportMap)) {
+		const name = key.slice(2);
+		if (!key.startsWith("./") || !name.includes("-") || key in generated) continue;
+		if ((isJsonObject(entry) ? entry.import : entry) === `${standaloneDir}/${name}.js`) delete exportMap[key];
 	}
-	if (types?.dir) npmPkgSet(`"exports[./loader][types]"="${ensureRelativePrefix(normalizePath(relative$1(config.rootDir, join$2(types.dir, "loader.d.ts"))))}"`);
 };
 /**
-* Generate per-component exports for standalone output.
-* Each component gets its own subpath export: `exports["./my-component"]`
+* Get a path relative to the project root, in the `./`-prefixed form `exports` targets require.
 * @param config The validated Stencil config
-* @param buildCtx The build context containing the components to generate export maps for
-* @param standalone The standalone output target
-* @param npmPkgSet Function used to run `npm pkg set`, tolerating an unavailable npm CLI
-*/
-const generateComponentExports = (config, buildCtx, standalone, npmPkgSet) => {
-	let outDir = relative$1(config.rootDir, standalone.dir);
-	if (!outDir.startsWith(".")) outDir = "./" + outDir;
-	buildCtx.components.forEach((cmp) => {
-		npmPkgSet(`"exports[./${cmp.tagName}][import]"="${outDir}/${cmp.tagName}.js"`);
-		npmPkgSet(`"exports[./${cmp.tagName}][types]"="${outDir}/${cmp.tagName}.d.ts"`);
-	});
+* @param path The absolute path
+* @returns The relative path
+*/
+const toRelativePath = (config, path) => {
+	const relativePath = normalizePath(relative$1(config.rootDir, path));
+	return relativePath.startsWith("./") || relativePath.startsWith("../") ? relativePath : "./" + relativePath;
 };
 //#endregion
 //#region src/compiler/build/write-build.ts
@@ -19975,7 +20109,7 @@ const writeBuild = async (config, compilerCtx, buildCtx) => {
 		await compilerCtx.cache.commit();
 		buildCtx.debug(`in-memory-fs: ${compilerCtx.fs.getMemoryStats()}`);
 		buildCtx.debug(`cache: ${compilerCtx.cache.getMemoryStats()}`);
-		if (config.generateExportMaps && !config.devMode) writeExportMaps(config, compilerCtx, buildCtx);
+		if (config.generateExportMaps && !config.devMode) await writeExportMaps(config, compilerCtx, buildCtx);
 		await outputServiceWorkers(config, buildCtx);
 		await validateBuildFiles(config, compilerCtx, buildCtx);
 	} catch (e) {
@@ -20892,7 +21026,7 @@ var Cache = class {
 		return typeof await this.get(key) === "string";
 	}
 	async createKey(domain, ...args) {
-		if (!this.config.enableCache || !this.sys.generateContentHash) return domain + Math.random() * 9999999;
+		if (!this.config.enableCache) return domain + Math.random() * 9999999;
 		const hash = await this.sys.generateContentHash(JSON.stringify(args), 32);
 		return domain + "_" + hash;
 	}
@@ -20901,35 +21035,36 @@ var Cache = class {
 			this.skip = false;
 			this.failed = 0;
 			await this.cacheFs.commit();
-			await this.clearExpiredCache();
+			await this.pruneExpired();
 		}
 	}
+	/**
+	* Remove cache files last written over a week ago. Runs at most once a day,
+	* throttled by the mtime of a marker file in the cache dir.
+	*/
+	async pruneExpired() {
+		if (!this.buildCacheDir) return;
+		const now = Date.now();
+		const markerPath = join$2(this.buildCacheDir, PRUNE_MARKER);
+		const marker = await this.sys.stat(markerPath);
+		if (marker.isFile && marker.mtimeMs && now - marker.mtimeMs < ONE_DAY) return;
+		const filePaths = await this.sys.readDir(this.buildCacheDir);
+		let removed = 0;
+		await Promise.all(filePaths.map(async (filePath) => {
+			if (basename$1(filePath).startsWith("_")) return;
+			const { isFile, mtimeMs } = await this.sys.stat(filePath);
+			if (isFile && mtimeMs && now - mtimeMs > ONE_WEEK) {
+				await this.sys.removeFile(filePath);
+				this.cacheFs.clearFileCache(filePath);
+				removed++;
+			}
+		}));
+		this.logger.debug(`cache prune: removed ${removed} of ${filePaths.length} files`);
+		await this.sys.writeFile(markerPath, "");
+	}
 	clear() {
 		if (this.cacheFs != null) this.cacheFs.clearCache();
 	}
-	async clearExpiredCache() {
-		if (this.cacheFs == null || this.sys.cacheStorage == null) return;
-		const now = Date.now();
-		const lastClear = await this.sys.cacheStorage.get(EXP_STORAGE_KEY);
-		if (lastClear != null) {
-			if (now - lastClear < ONE_DAY) return;
-			const fs = this.cacheFs.sys;
-			const cachedFileNames = await fs.readDir(this.buildCacheDir);
-			const cachedFilePaths = cachedFileNames.map((f) => join$2(this.buildCacheDir, f));
-			let totalCleared = 0;
-			const promises = cachedFilePaths.map(async (filePath) => {
-				const lastModified = (await fs.stat(filePath)).mtimeMs;
-				if (lastModified && now - lastModified > ONE_WEEK) {
-					await fs.removeFile(filePath);
-					totalCleared++;
-				}
-			});
-			await Promise.all(promises);
-			this.logger.debug(`clearExpiredCache, cachedFileNames: ${cachedFileNames.length}, totalCleared: ${totalCleared}`);
-		}
-		this.logger.debug(`clearExpiredCache, set last clear`);
-		await this.sys.cacheStorage.set(EXP_STORAGE_KEY, now);
-	}
 	async clearDiskCache() {
 		if (this.cacheFs != null) {
 			if (await this.cacheFs.access(this.buildCacheDir)) {
@@ -20949,7 +21084,7 @@ var Cache = class {
 const MAX_FAILED = 100;
 const ONE_DAY = 864e5;
 const ONE_WEEK = ONE_DAY * 7;
-const EXP_STORAGE_KEY = `last_clear_expired_cache`;
+const PRUNE_MARKER = "_last_prune.log";
 const CACHE_DIR_README = `# Stencil Cache Directory
 
 This directory contains files which the compiler has
@@ -22038,7 +22173,7 @@ const validateConfig = (userConfig = {}, bootstrapConfig) => {
 		...config,
 		devMode,
 		compat: config.compat || {},
-		generateExportMaps: isBoolean$1(config.generateExportMaps) ? config.generateExportMaps : !isString$1(config.configPath),
+		generateExportMaps: config.generateExportMaps === true,
 		enableCssOnlyComponents: config.enableCssOnlyComponents ?? true,
 		hydratedFlag: validateHydrated(config),
 		logLevel,
@@ -25968,15 +26103,6 @@ const createSystem = (c) => {
 		}
 		return results;
 	};
-	/**
-	* `self` is the global namespace object used within a web worker.
-	* `window` is the browser's global namespace object (I reorganized this to check the reference on that second)
-	* `global` is Node's global namespace object. https://nodejs.org/api/globals.html#globals_global
-	*
-	* loading in this order should allow workers, which are most common, then browser,
-	* then Node to grab the reference to fetch correctly.
-	*/
-	const fetch = typeof self !== "undefined" ? self?.fetch : typeof window !== "undefined" ? window?.fetch : typeof global !== "undefined" ? global?.fetch : void 0;
 	const writeFile = async (p, data) => writeFileSync(p, data);
 	const tmpDirSync = () => "/.tmp";
 	const tick = Promise.resolve();
@@ -25987,6 +26113,7 @@ const createSystem = (c) => {
 		if (typeof hashLength === "number") hashHex = hashHex.slice(0, hashLength);
 		return hashHex;
 	};
+	const generateFileHash = async (filePath, hashLength) => generateContentHash(readFileSync(filePath), hashLength);
 	const copy = async (copyTasks, srcDir) => {
 		const results = {
 			diagnostics: [],
@@ -25996,9 +26123,6 @@ const createSystem = (c) => {
 		logger.info("todo, copy task", copyTasks.length, srcDir);
 		return results;
 	};
-	const getEnvironmentVar = (key) => {
-		return process$1?.env[key];
-	};
 	const getLocalModulePath = (opts) => join$2(opts.rootDir, "node_modules", opts.moduleId, opts.path);
 	const getRemoteModuleUrl = (opts) => {
 		const npmBaseUrl = "https://cdn.jsdelivr.net/npm/";
@@ -26014,13 +26138,14 @@ const createSystem = (c) => {
 		access,
 		accessSync,
 		addDestroy,
+		checkVersion: async () => noop,
 		copyFile,
 		createDir,
 		createDirSync,
 		homeDir,
 		isTTY,
-		getEnvironmentVar,
 		destroy,
+		dynamicImport: (p) => import(p),
 		encodeToBase64,
 		exit: async (exitCode) => logger.warn(`exit ${exitCode}`),
 		getCurrentDirectory,
@@ -26031,6 +26156,7 @@ const createSystem = (c) => {
 		isSymbolicLink,
 		nextTick,
 		normalizePath: normalize,
+		onProcessInterrupt: noop,
 		platformPath: path,
 		readDir,
 		readDirSync,
@@ -26040,7 +26166,6 @@ const createSystem = (c) => {
 		realpathSync,
 		removeDestroy,
 		rename,
-		fetch,
 		resolvePath,
 		removeDir,
 		removeDirSync,
@@ -26055,6 +26180,7 @@ const createSystem = (c) => {
 		writeFile,
 		writeFileSync,
 		generateContentHash,
+		generateFileHash,
 		createWorkerController: null,
 		details: {
 			cpuModel: "",
@@ -26254,6 +26380,7 @@ const transpileModule = (config, input, transformOpts) => {
 		...config,
 		logger: createNodeLogger()
 	};
+	resetDeprecatedApiWarning();
 	const compilerCtx = new CompilerContext();
 	const buildCtx = new BuildContext(config, compilerCtx);
 	const tsCompilerOptions = { ...config.tsCompilerOptions };
@@ -26457,4 +26584,4 @@ const shouldTranspileModule = (ext) => [
 	"js"
 ].includes(ext);
 //#endregion
-export { versions as A, replaceStencilCssComponentsImport as C, buildId as D, parseCssOnlyComponents as E, vermoji as O, hasStencilHydrateImport as S, replaceStencilHydrateImport as T, cmpMetaToDocsComponent as _, createPrerenderer as a, hasStencilCssComponentsImport as b, createWorkerContext as c, nodeRequire as d, optimizeCss as f, generateManifest as g, generateComponentTypesFile as h, createSystem as i, scopeCss as j, version as k, createWorkerMessageHandler as l, validateHydrated as m, transpile as n, loadConfig as o, validateConfig as p, transpileSync as r, createCompiler as s, ts$1 as t, optimizeJs as u, getScopeId as v, replaceStencilGlobalsImport as w, hasStencilGlobalsImport as x, buildHydrateCss as y };
+export { version as A, hasStencilHydrateImport as C, parseCssOnlyComponents as D, replaceStencilHydrateImport as E, scopeCss as M, buildId as O, hasStencilGlobalsImport as S, replaceStencilGlobalsImport as T, cmpMetaToDocsComponent as _, createPrerenderer as a, buildHydrateCss as b, createWorkerContext as c, nodeRequire as d, optimizeCss as f, generateManifest as g, generateComponentTypesFile as h, createSystem as i, versions as j, vermoji as k, createWorkerMessageHandler as l, validateHydrated as m, transpile as n, loadConfig as o, validateConfig as p, transpileSync as r, createCompiler as s, ts$1 as t, optimizeJs as u, getScopeId as v, replaceStencilCssComponentsImport as w, hasStencilCssComponentsImport as x, foldBuildFlags as y };