@salesforce/storefront-next-dev 0.2.0-alpha.2 → 0.3.0-alpha.0

package/dist/index.js

@@ -1,30 +1,106 @@
 import path, { basename, extname, join, resolve } from "node:path";
 import fs from "fs-extra";
+import chalk from "chalk";
 import path$1, { dirname, join as join$1, relative, resolve as resolve$1 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 import { parse } from "@babel/parser";
-import { isJSXAttribute, isJSXElement, isJSXFragment, isJSXIdentifier, jsxClosingElement, jsxClosingFragment, jsxElement, jsxFragment, jsxIdentifier, jsxOpeningElement, jsxOpeningFragment, jsxText } from "@babel/types";
+import { isArrayPattern, isClassDeclaration, isExportSpecifier, isFunctionDeclaration, isIdentifier, isJSXAttribute, isJSXElement, isJSXFragment, isJSXIdentifier, isMemberExpression, isObjectPattern, isObjectProperty, isRestElement, isVariableDeclaration, jsxClosingElement, jsxClosingFragment, jsxElement, jsxFragment, jsxIdentifier, jsxOpeningElement, jsxOpeningFragment, jsxText } from "@babel/types";
 import { generate } from "@babel/generator";
 import traverseModule from "@babel/traverse";
 import fs$1, { existsSync, readFileSync, writeFileSync } from "fs";
 import { glob } from "glob";
 import { Node, Project, ts } from "ts-morph";
 import fs$2, { existsSync as existsSync$1, readFileSync as readFileSync$1, unlinkSync } from "node:fs";
+import { deadCodeElimination, findReferencedIdentifiers } from "babel-dead-code-elimination";
+import httpProxy from "http-proxy";
+import { brotliDecompressSync, gunzipSync, inflateSync } from "zlib";
 import express from "express";
 import { createRequestHandler } from "@react-router/express";
 import { pathToFileURL as pathToFileURL$1 } from "node:url";
 import { createProxyMiddleware } from "http-proxy-middleware";
-import chalk from "chalk";
 import compression from "compression";
 import zlib from "node:zlib";
 import morgan from "morgan";
 import { minimatch } from "minimatch";
+import { SpanStatusCode, context, trace } from "@opentelemetry/api";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { ConsoleSpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { ExportResultCode, hrTimeToTimeStamp } from "@opentelemetry/core";
+import { Resource } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { execSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 import { npmRunPathEnv } from "npm-run-path";
 
+//#region src/utils/logger.ts
+const LEVEL_PRIORITY = {
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3
+};
+let overrideLevel;
+/**
+* Returns true when the `DEBUG` env var targets sfnext or is a general enable flag.
+* Avoids accidentally enabling debug mode when DEBUG is set for unrelated libraries
+* (e.g. `DEBUG=express:*`).
+*/
+function debugEnablesSfnext() {
+	const raw = process.env.DEBUG?.trim();
+	if (!raw) return false;
+	const normalized = raw.toLowerCase();
+	if ([
+		"1",
+		"true",
+		"yes",
+		"on"
+	].includes(normalized)) return true;
+	return raw.split(",").some((token) => {
+		const value = token.trim();
+		return value === "*" || value === "sfnext" || value === "sfnext:*";
+	});
+}
+function resolveLevel() {
+	if (overrideLevel) return overrideLevel;
+	const envLevel = process.env.MRT_LOG_LEVEL ?? process.env.SFCC_LOG_LEVEL;
+	if (envLevel && envLevel in LEVEL_PRIORITY) return envLevel;
+	if (debugEnablesSfnext()) return "debug";
+	if (process.env.NODE_ENV === "production") return "warn";
+	return "info";
+}
+function shouldLog(level) {
+	return LEVEL_PRIORITY[level] <= LEVEL_PRIORITY[resolveLevel()];
+}
+const logger = {
+	error(msg, ...args) {
+		if (!shouldLog("error")) return;
+		console.error(chalk.red("[sfnext:error]"), msg, ...args);
+	},
+	warn(msg, ...args) {
+		if (!shouldLog("warn")) return;
+		console.warn(chalk.yellow("[sfnext:warn]"), msg, ...args);
+	},
+	info(msg, ...args) {
+		if (!shouldLog("info")) return;
+		console.log(chalk.cyan("[sfnext:info]"), msg, ...args);
+	},
+	debug(msg, ...args) {
+		if (!shouldLog("debug")) return;
+		console.log(chalk.gray("[sfnext:debug]"), msg, ...args);
+	},
+	setLevel(level) {
+		overrideLevel = level;
+	},
+	getLevel() {
+		return resolveLevel();
+	}
+};
+
+//#endregion
 //#region src/plugins/fixReactRouterManifestUrls.ts
 function patchAssetsPaths(dir) {
 	const entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -35,7 +111,7 @@ function patchAssetsPaths(dir) {
 			const content = fs.readFileSync(fullPath, "utf-8");
 			if (content.includes("\"/assets/") || content.includes("'/assets/")) {
 				fs.writeFileSync(fullPath, content.replace(/["']\/assets\//g, "(window._BUNDLE_PATH || \"/\") + \"assets/"));
-				console.log(`patched /assets/ references in ${fullPath}`);
+				logger.debug(`patched /assets/ references in ${fullPath}`);
 			}
 		}
 	}
@@ -90,10 +166,41 @@ function getCommerceCloudApiUrl(shortCode, proxyHost) {
 	return proxyHost || `https://${shortCode}.api.commercecloud.salesforce.com`;
 }
 /**
+* Get the configurable base path for the application.
+* Reads from MRT_ENV_BASE_PATH environment variable.
+*
+* The base path is used for CDN routing to the correct MRT environment.
+* It is prepended to all URLs: page routes, /mobify/bundle/ assets, and /mobify/proxy/api.
+*
+* Validation rules:
+* - Must be a single path segment starting with '/'
+* - Max 63 characters after the leading slash
+* - Only URL-safe characters allowed
+* - Returns empty string if not set
+*
+* @returns The sanitized base path (e.g., '/site-a' or '')
+*
+* @example
+* // No base path configured
+* getBasePath() // → ''
+*
+* // With base path '/storefront'
+* getBasePath() // → '/storefront'
+*
+* // Automatically sanitizes
+* // MRT_ENV_BASE_PATH='storefront/' → '/storefront'
+*/
+function getBasePath() {
+	const basePath = process.env.MRT_ENV_BASE_PATH?.trim();
+	if (!basePath) return "";
+	if (!/^\/[a-zA-Z0-9_.+$~"'@:-]{1,63}$/.test(basePath)) throw new Error(`Invalid base path: "${basePath}". Base path must be a single segment starting with '/' (e.g., '/site-a'), contain only URL-safe characters, and be at most 63 characters after the leading slash.`);
+	return basePath;
+}
+/**
 * Get the bundle path for static assets
 */
 function getBundlePath(bundleId) {
-	return `/mobify/bundle/${bundleId}/client/`;
+	return `${getBasePath()}/mobify/bundle/${bundleId}/client/`;
 }
 
 //#endregion
@@ -230,10 +337,16 @@ const managedRuntimeBundlePlugin = () => {
 		await fs.outputFile(loaderPath, "// This file is intentionally empty");
 		const prebuiltMrtEntryPath = path$1.resolve(__dirname$1, `./mrt/${mrtEntryFile}`);
 		await fs.copy(prebuiltMrtEntryPath, mrtEntryPath);
+		const prebuiltMrtEntryMapPath = `${prebuiltMrtEntryPath}.map`;
+		if (await fs.pathExists(prebuiltMrtEntryMapPath)) await fs.copy(prebuiltMrtEntryMapPath, `${mrtEntryPath}.map`);
 		const mrtDir = path$1.resolve(__dirname$1, "./mrt");
 		if (await fs.pathExists(mrtDir)) {
 			const files = await fs.readdir(mrtDir);
-			for (const file of files) if (file.startsWith("sfnext-server-") && file.endsWith(".mjs")) await fs.copy(path$1.join(mrtDir, file), path$1.resolve(buildDirectory, file));
+			for (const file of files) if (file.startsWith("sfnext-server-") && file.endsWith(".mjs")) {
+				await fs.copy(path$1.join(mrtDir, file), path$1.resolve(buildDirectory, file));
+				const mapFile = `${file}.map`;
+				if (files.includes(mapFile)) await fs.copy(path$1.join(mrtDir, mapFile), path$1.resolve(buildDirectory, mapFile));
+			}
 		}
 		const packageJsonPath = path$1.resolve(resolvedConfig.root, "package.json");
 		const buildPackageJsonPath = path$1.resolve(buildDirectory, "package.json");
@@ -246,9 +359,13 @@ const managedRuntimeBundlePlugin = () => {
 		apply: "build",
 		config({ mode }) {
 			return {
+				build: { rollupOptions: { onLog(level, log, defaultHandler) {
+					if (log.code === "SOURCEMAP_ERROR" && log.message.includes("resolve original location")) return;
+					defaultHandler(level, log);
+				} } },
 				environments: { ssr: { resolve: { noExternal: true } } },
 				experimental: { renderBuiltUrl(filename, { type }) {
-					if (mode !== "preview" && (type === "asset" || type === "public")) return { runtime: `(typeof window !== 'undefined' ? window._BUNDLE_PATH : ('/mobify/bundle/'+(process.env.BUNDLE_ID??'local')+'/client/')) + ${JSON.stringify(filename)}` };
+					if (mode !== "preview" && (type === "asset" || type === "public")) return { runtime: `(typeof window !== 'undefined' ? window._BUNDLE_PATH : ((process.env.MRT_ENV_BASE_PATH??'')+'/mobify/bundle/'+(process.env.BUNDLE_ID??'local')+'/client/')) + ${JSON.stringify(filename)}` };
 				} }
 			};
 		},
@@ -311,7 +428,7 @@ const patchReactRouterPlugin = () => {
 
 //#endregion
 //#region src/extensibility/target-utils.ts
-const traverse = traverseModule.default || traverseModule;
+const traverse$1 = traverseModule.default || traverseModule;
 const TARGET_COMPONENT_TAG = "UITarget";
 const TARGET_PROVIDERS_TAG = "TargetProviders";
 const TARGET_ID_ATTRIBUTE = "targetId";
@@ -376,7 +493,7 @@ function runReplacementPass(ast, tagName, targetRegistry = null, contextProvider
 			if (replacedId) targetIdsReplaced.add(replacedId);
 		} else if (contextProviders) findAndReplaceProviders(pathToReplace, contextProviders);
 	};
-	traverse(ast, {
+	traverse$1(ast, {
 		VariableDeclaration(nodePath) {
 			const declarationPaths = nodePath.get("declarations");
 			const declarationsArray = Array.isArray(declarationPaths) ? declarationPaths : [declarationPaths];
@@ -429,7 +546,7 @@ function transformTargets(code, targetRegistry, contextProviders) {
 	});
 	if (code.includes(TARGET_COMPONENT_TAG)) {
 		const replacementImportStatements = buildReplacementImportStatements(runReplacementPass(ast, TARGET_COMPONENT_TAG, targetRegistry, null), targetRegistry);
-		traverse(ast, { ImportDeclaration(nodePath) {
+		traverse$1(ast, { ImportDeclaration(nodePath) {
 			if (nodePath.node.source.value.includes("@/targets/ui-target")) nodePath.replaceWith(jsxText(replacementImportStatements));
 		} });
 	}
@@ -437,7 +554,7 @@ function transformTargets(code, targetRegistry, contextProviders) {
 		const importStatements = /* @__PURE__ */ new Set();
 		for (const contextProvider of contextProviders) importStatements.add(`import ${contextProvider.componentName} from '@/${contextProvider.path.replace(".tsx", "")}';`);
 		const replacementImportStatements = Array.from(importStatements).join("\n");
-		traverse(ast, { ImportDeclaration(nodePath) {
+		traverse$1(ast, { ImportDeclaration(nodePath) {
 			if (nodePath.node.source.value.includes("@/targets/target-providers")) nodePath.replaceWith(jsxText(replacementImportStatements));
 		} });
 		runReplacementPass(ast, TARGET_PROVIDERS_TAG, null, contextProviders);
@@ -527,7 +644,7 @@ function transformTargetPlaceholderPlugin() {
 				};
 				return null;
 			} catch (err) {
-				console.error(`UITarget replace ERROR in ${id}: ${err instanceof Error ? err.stack : String(err)}`);
+				logger.error(`UITarget replace ERROR in ${id}: ${err instanceof Error ? err.stack : String(err)}`);
 				throw err;
 			}
 		}
@@ -550,7 +667,7 @@ const watchConfigFilesPlugin = () => {
 			server.watcher.add(glob$1);
 			const onChange = (file) => {
 				if (file.endsWith("target-config.json")) {
-					console.log(`🔁 target-config.json changed: ${file}`);
+					logger.debug(`🔁 target-config.json changed: ${file}`);
 					server.restart();
 				}
 			};
@@ -630,12 +747,12 @@ function hasFallbackExport(sourceFile) {
 /**
 * Scans all files in the component directory for @Component decorators and extracts metadata using ts-morph
 */
-async function scanComponents(project, projectRoot, componentPath, registryPath, verbose$1) {
+async function scanComponents(project, projectRoot, componentPath, registryPath) {
 	const componentFiles = await glob(`${componentPath}/**/*.{ts,tsx}`, {
 		cwd: projectRoot,
 		absolute: true
 	});
-	if (verbose$1) console.log(`🔍 Scanning ${componentFiles.length} files in ${componentPath}...`);
+	logger.debug(`🔍 Scanning ${componentFiles.length} files in ${componentPath}...`);
 	const components = [];
 	const registryDir = dirname(resolve$1(projectRoot, registryPath));
 	for (const filePath of componentFiles) try {
@@ -660,19 +777,17 @@ async function scanComponents(project, projectRoot, componentPath, registryPath,
 						hasClientLoader: hasClientLoaderExport,
 						hasFallback
 					});
-					if (verbose$1) {
-						const exports = [];
-						if (hasLoaderExport) exports.push("loader");
-						if (hasClientLoaderExport) exports.push("clientLoader");
-						if (hasFallback) exports.push("fallback");
-						const exportsText = exports.length > 0 ? ` (with ${exports.join(", ")})` : "";
-						console.log(`  ✅ Found component: ${componentInfo.id} → ${relativePath}${exportsText}`);
-					}
+					const exports = [];
+					if (hasLoaderExport) exports.push("loader");
+					if (hasClientLoaderExport) exports.push("clientLoader");
+					if (hasFallback) exports.push("fallback");
+					const exportsText = exports.length > 0 ? ` (with ${exports.join(", ")})` : "";
+					logger.debug(`  ✅ Found component: ${componentInfo.id} → ${relativePath}${exportsText}`);
 				}
 			}
 		}
 	} catch (error) {
-		if (verbose$1) console.warn(`⚠️  Could not process ${filePath}:`, error.message);
+		logger.warn(`⚠️  Could not process ${filePath}: ${error.message}`);
 	}
 	return components;
 }
@@ -720,10 +835,10 @@ ${registrations}
 /**
 * Updates the registry.ts file with the generated code
 */
-function updateRegistryFile(registryFilePath, generatedCode, verbose$1) {
+function updateRegistryFile(registryFilePath, generatedCode) {
 	let existingContent;
 	if (!existsSync(registryFilePath)) {
-		if (verbose$1) console.log(`📝 Creating new registry file...`);
+		logger.debug("📝 Creating new registry file...");
 		const basicRegistryContent = `import { ComponentRegistry } from '@/lib/component-registry';
 
 // Create the component registry instance
@@ -748,7 +863,7 @@ export const registry = new ComponentRegistry();
 	const updatedContent = `${existingContent.slice(0, startIndex + 24)}\n${generatedCode}\n${existingContent.slice(endIndex)}`;
 	try {
 		writeFileSync(registryFilePath, updatedContent, "utf-8");
-		if (verbose$1) console.log(`💾 Updated registry file: ${registryFilePath}`);
+		logger.debug(`💾 Updated registry file: ${registryFilePath}`);
 	} catch (error) {
 		throw new Error(`Failed to write registry file: ${error.message}`);
 	}
@@ -777,10 +892,10 @@ export const registry = new ComponentRegistry();
 * })
 */
 const staticRegistryPlugin = (config = {}) => {
-	const { componentPath = "src/components", registryPath = "src/lib/static-registry.ts", registryIdentifier = "registry", failOnError = true, verbose: verbose$1 = false } = config;
+	const { componentPath = "src/components", registryPath = "src/lib/static-registry.ts", registryIdentifier = "registry", failOnError = true } = config;
 	let projectRoot;
 	const runRegistryGeneration = async () => {
-		if (verbose$1) console.log("🚀 Starting static registry generation...");
+		logger.debug("🚀 Starting static registry generation...");
 		const components = await scanComponents(new Project({ compilerOptions: {
 			target: ts.ScriptTarget.Latest,
 			module: ts.ModuleKind.ESNext,
@@ -788,12 +903,12 @@ const staticRegistryPlugin = (config = {}) => {
 			allowJs: true,
 			skipLibCheck: true,
 			noEmit: true
-		} }), projectRoot, componentPath, registryPath, verbose$1);
-		if (verbose$1) console.log(`📦 Found ${components.length} components with @Component decorators`);
+		} }), projectRoot, componentPath, registryPath);
+		logger.debug(`📦 Found ${components.length} components with @Component decorators`);
 		const generatedCode = generateRegistryCode(components, registryIdentifier);
 		const registryFilePath = resolve$1(projectRoot, registryPath);
-		updateRegistryFile(registryFilePath, generatedCode, verbose$1);
-		if (verbose$1) console.log("✅ Static registry generation complete!");
+		updateRegistryFile(registryFilePath, generatedCode);
+		logger.debug("✅ Static registry generation complete!");
 		return registryFilePath;
 	};
 	return {
@@ -805,23 +920,23 @@ const staticRegistryPlugin = (config = {}) => {
 			try {
 				await runRegistryGeneration();
 			} catch (error) {
-				console.error(`❌ Static registry generation failed: ${error.message}`);
+				logger.error(`❌ Static registry generation failed: ${error.message}`);
 				if (failOnError) throw error;
-				console.warn("⚠️  Continuing build without static registry...");
+				logger.warn("⚠️  Continuing build without static registry...");
 			}
 		},
 		async handleHotUpdate({ file, server }) {
 			const normalizedComponentPath = componentPath.replace(/\\/g, "/");
 			const normalizedFile = file.replace(/\\/g, "/");
 			if (normalizedFile.includes(`/${normalizedComponentPath}/`) && (normalizedFile.endsWith(".ts") || normalizedFile.endsWith(".tsx"))) {
-				if (verbose$1) console.log(`🔄 Component file changed: ${file}, regenerating registry...`);
+				logger.debug(`🔄 Component file changed: ${file}, regenerating registry...`);
 				try {
 					const registryFilePath = await runRegistryGeneration();
 					const registryModule = server.moduleGraph.getModuleById(registryFilePath);
 					if (registryModule) await server.reloadModule(registryModule);
-					if (verbose$1) console.log("✅ Registry regenerated successfully!");
+					logger.debug("✅ Registry regenerated successfully!");
 				} catch (error) {
-					console.error(`❌ Failed to regenerate registry: ${error.message}`);
+					logger.error(`❌ Failed to regenerate registry: ${error.message}`);
 				}
 				return [];
 			}
@@ -834,19 +949,19 @@ const staticRegistryPlugin = (config = {}) => {
 /**
 * Load the engagement config from config.server.ts
 */
-async function loadEngagementConfig(projectRoot, configPath, verbose$1) {
+async function loadEngagementConfig(projectRoot, configPath) {
 	const absoluteConfigPath = resolve$1(projectRoot, configPath);
 	try {
 		const config = (await import(pathToFileURL(absoluteConfigPath).href)).default;
-		if (verbose$1) console.log(`  📄 Loaded config from ${configPath}`);
+		logger.debug(`📄 Loaded config from ${configPath}`);
 		const engagement = config?.app?.engagement;
 		if (!engagement) {
-			if (verbose$1) console.log(`  ⚠️  No engagement config found in ${configPath}`);
+			logger.debug(`⚠️  No engagement config found in ${configPath}`);
 			return null;
 		}
 		return engagement;
 	} catch (error) {
-		if (verbose$1) console.warn(`  ⚠️  Could not load config from ${configPath}: ${error.message}`);
+		logger.warn(`⚠️  Could not load config from ${configPath}: ${error.message}`);
 		return null;
 	}
 }
@@ -856,7 +971,7 @@ async function loadEngagementConfig(projectRoot, configPath, verbose$1) {
 /**
 * Extract all trackEvent calls from source files and return the event types found
 */
-async function scanForInstrumentedEvents(projectRoot, scanPaths, verbose$1) {
+async function scanForInstrumentedEvents(projectRoot, scanPaths) {
 	const instrumentedEvents = /* @__PURE__ */ new Set();
 	const trackEventPattern = /trackEvent\s*\([^,]+,[^,]+,[^,]+,\s*['"]([^'"]+)['"]/g;
 	const sendViewPagePattern = /sendViewPageEvent\s*\(/g;
@@ -869,29 +984,29 @@ async function scanForInstrumentedEvents(projectRoot, scanPaths, verbose$1) {
 			"**/*.spec.tsx",
 			"**/node_modules/**"
 		] });
-		if (verbose$1) console.log(`  📂 Scanning ${files.length} files in ${scanPath}...`);
+		logger.debug(`📂 Scanning ${files.length} files in ${scanPath}...`);
 		for (const file of files) try {
 			const content = readFileSync(file, "utf-8");
 			let match;
 			while ((match = trackEventPattern.exec(content)) !== null) {
 				const eventType = match[1];
 				instrumentedEvents.add(eventType);
-				if (verbose$1) console.log(`    ✓ Found trackEvent('${eventType}') in ${file}`);
+				logger.debug(`  ✓ Found trackEvent('${eventType}') in ${file}`);
 			}
 			if (sendViewPagePattern.test(content)) {
 				instrumentedEvents.add("view_page");
-				if (verbose$1) console.log(`    ✓ Found sendViewPageEvent() in ${file}`);
+				logger.debug(`  ✓ Found sendViewPageEvent() in ${file}`);
 			}
 			while ((match = createEventPattern.exec(content)) !== null) {
 				const eventType = match[1];
 				instrumentedEvents.add(eventType);
-				if (verbose$1) console.log(`    ✓ Found createEvent('${eventType}') in ${file}`);
+				logger.debug(`  ✓ Found createEvent('${eventType}') in ${file}`);
 			}
 			trackEventPattern.lastIndex = 0;
 			sendViewPagePattern.lastIndex = 0;
 			createEventPattern.lastIndex = 0;
 		} catch (error) {
-			if (verbose$1) console.warn(`    ⚠️  Could not read ${file}: ${error.message}`);
+			logger.warn(`⚠️  Could not read ${file}: ${error.message}`);
 		}
 	}
 	return instrumentedEvents;
@@ -935,7 +1050,7 @@ function extractEnabledEvents(engagement) {
 * })
 */
 const eventInstrumentationValidatorPlugin = (config = {}) => {
-	const { configPath = "config.server.ts", scanPaths = ["src"], failOnMissing = false, verbose: verbose$1 = false } = config;
+	const { configPath = "config.server.ts", scanPaths = ["src"], failOnMissing = false } = config;
 	let resolvedConfig;
 	return {
 		name: "storefrontnext:event-instrumentation-validator",
@@ -945,34 +1060,29 @@ const eventInstrumentationValidatorPlugin = (config = {}) => {
 		},
 		async buildStart() {
 			const projectRoot = resolvedConfig.root;
-			if (verbose$1) console.log("\n🔍 [event-instrumentation] Validating event instrumentation...");
-			const engagement = await loadEngagementConfig(projectRoot, configPath, verbose$1);
+			logger.debug("🔍 Validating event instrumentation...");
+			const engagement = await loadEngagementConfig(projectRoot, configPath);
 			if (!engagement) {
-				if (verbose$1) console.log("  ℹ️  Skipping validation - no engagement config found\n");
+				logger.debug("ℹ️  Skipping validation - no engagement config found");
 				return;
 			}
 			const adapterEvents = extractEnabledEvents(engagement);
 			if (adapterEvents.size === 0) {
-				if (verbose$1) console.log("  ℹ️  No enabled adapters with event toggles found\n");
+				logger.debug("ℹ️  No enabled adapters with event toggles found");
 				return;
 			}
-			const instrumentedEvents = await scanForInstrumentedEvents(projectRoot, scanPaths, verbose$1);
-			if (verbose$1) {
-				console.log(`\n  🔎 Found ${instrumentedEvents.size} instrumented event types:`);
-				for (const event of instrumentedEvents) console.log(`     - ${event}`);
-			}
+			const instrumentedEvents = await scanForInstrumentedEvents(projectRoot, scanPaths);
+			logger.debug(`🔎 Found ${instrumentedEvents.size} instrumented event types: ${[...instrumentedEvents].join(", ")}`);
 			const missingInstrumentation = [];
 			for (const [adapterName, enabledEvents] of adapterEvents) for (const eventType of enabledEvents) if (!instrumentedEvents.has(eventType)) missingInstrumentation.push({
 				adapter: adapterName,
 				event: eventType
 			});
 			if (missingInstrumentation.length === 0) {
-				if (verbose$1) console.log("\n  ✅ All enabled events are instrumented\n");
+				logger.debug("✅ All enabled events are instrumented");
 				return;
 			}
-			console.log("\n");
-			for (const { adapter, event } of missingInstrumentation) console.warn(`  ⚠️  [event-instrumentation] ${adapter}.${event} is enabled but '${event}' is never instrumented`);
-			console.log("\n");
+			for (const { adapter, event } of missingInstrumentation) logger.warn(`⚠️  ${adapter}.${event} is enabled but '${event}' is never instrumented`);
 			if (failOnMissing) throw new Error(`[event-instrumentation] ${missingInstrumentation.length} event(s) are enabled but not instrumented. Either add instrumentation or disable the event toggles in config.server.ts.`);
 		}
 	};
@@ -1252,6 +1362,242 @@ const workspacePlugin = () => {
 	};
 };
 
+//#endregion
+//#region src/plugins/componentLoaders.ts
+const traverse = traverseModule.default || traverseModule;
+const generate$1 = generate.default || generate;
+/**
+* Names of exports to strip per environment.
+*
+* - `loader` is server-only → strip from the **client** build
+* - `clientLoader` is client-only → strip from the **server** build
+*/
+const STRIP_FROM_CLIENT = ["loader"];
+const STRIP_FROM_SERVER = ["clientLoader"];
+/**
+* Determines which export names should be stripped for a given Vite environment.
+*/
+function getExportsToStrip(environmentName) {
+	if (environmentName === "client") return STRIP_FROM_CLIENT;
+	if (environmentName === "ssr") return STRIP_FROM_SERVER;
+	return [];
+}
+/**
+* Returns `true` when the source code contains at least one of the given export names as a quick pre-check before
+* running the full AST transform.
+*/
+function hasExportCandidate(code, names) {
+	return names.some((name) => code.includes(name));
+}
+/**
+* Checks whether the AST contains at least one class declaration decorated with `@Component(…)`.
+*/
+function hasComponentDecorator(ast) {
+	let found = false;
+	traverse(ast, { ClassDeclaration(path$2) {
+		const decorators = path$2.node.decorators;
+		if (!decorators) return;
+		for (const decorator of decorators) if (decorator.expression.type === "CallExpression" && isIdentifier(decorator.expression.callee) && decorator.expression.callee.name === "Component") {
+			found = true;
+			path$2.stop();
+			return;
+		}
+	} });
+	return found;
+}
+/**
+* Strips the specified named exports from the given source code using a
+* Babel AST transform.
+*
+* The transform handles the following patterns:
+*
+* 1. `export const loader = …;`
+* 2. `export function loader(…) {…}`
+* 3. `export class Loader {…}`
+* 4. `export { loader }` / `export { foo as loader }`
+* 5. `export { loader } from './loaders'`
+*
+* Destructured exports (`export const { loader } = …` or
+* `export const [loader] = …`) cannot be safely removed and will
+* throw an error if encountered (matching React Router behaviour).
+*
+* After removing an export, the transform also:
+* - Removes top-level property assignments to the stripped export
+*   (e.g. `clientLoader.hydrate = true`)
+* - Removes any import declarations that become unused as a result
+*
+* @see {@link https://github.com/remix-run/react-router/blob/main/packages/react-router-dev/vite/remove-exports.ts React Router remove-exports}
+* @returns The transformed source code, or `null` if nothing was changed.
+*/
+function stripExports(code, exportsToStrip, preParsedAst) {
+	const ast = preParsedAst ?? parse(code, {
+		sourceType: "module",
+		plugins: [
+			"typescript",
+			"jsx",
+			"decorators"
+		]
+	});
+	let changed = false;
+	const previouslyReferencedIdentifiers = findReferencedIdentifiers(ast);
+	const removedExportLocalNames = /* @__PURE__ */ new Set();
+	traverse(ast, { ExportNamedDeclaration(path$2) {
+		const { declaration, specifiers } = path$2.node;
+		if (declaration && isVariableDeclaration(declaration)) {
+			const remaining = declaration.declarations.filter((decl) => {
+				if (isIdentifier(decl.id) && exportsToStrip.includes(decl.id.name)) {
+					removedExportLocalNames.add(decl.id.name);
+					return false;
+				}
+				if (isArrayPattern(decl.id) || isObjectPattern(decl.id)) validateDestructuredExports(decl.id, exportsToStrip);
+				return true;
+			});
+			if (remaining.length < declaration.declarations.length) {
+				changed = true;
+				if (remaining.length === 0) {
+					removeLeadingEslintDisableComment(path$2);
+					path$2.remove();
+				} else declaration.declarations = remaining;
+			}
+			return;
+		}
+		if (declaration && isFunctionDeclaration(declaration)) {
+			if (declaration.id && exportsToStrip.includes(declaration.id.name)) {
+				changed = true;
+				removedExportLocalNames.add(declaration.id.name);
+				removeLeadingEslintDisableComment(path$2);
+				path$2.remove();
+				return;
+			}
+		}
+		if (declaration && isClassDeclaration(declaration)) {
+			if (declaration.id && exportsToStrip.includes(declaration.id.name)) {
+				changed = true;
+				removedExportLocalNames.add(declaration.id.name);
+				removeLeadingEslintDisableComment(path$2);
+				path$2.remove();
+				return;
+			}
+		}
+		if (specifiers.length > 0) {
+			const remaining = specifiers.filter((spec) => {
+				if (isExportSpecifier(spec)) {
+					const exportedName = isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value;
+					if (exportsToStrip.includes(exportedName)) {
+						removedExportLocalNames.add(spec.local.name);
+						return false;
+					}
+				}
+				return true;
+			});
+			if (remaining.length < specifiers.length) {
+				changed = true;
+				if (remaining.length === 0) {
+					removeLeadingEslintDisableComment(path$2);
+					path$2.remove();
+				} else path$2.node.specifiers = remaining;
+			}
+		}
+	} });
+	if (changed) traverse(ast, { ExpressionStatement(path$2) {
+		if (!path$2.parentPath?.isProgram()) return;
+		if (path$2.node.expression.type === "AssignmentExpression") {
+			const left = path$2.node.expression.left;
+			if (isMemberExpression(left) && isIdentifier(left.object) && (exportsToStrip.includes(left.object.name) || removedExportLocalNames.has(left.object.name))) {
+				removeLeadingEslintDisableComment(path$2);
+				path$2.remove();
+			}
+		}
+	} });
+	if (changed) deadCodeElimination(ast, previouslyReferencedIdentifiers);
+	if (!changed) return null;
+	return generate$1(ast, { retainLines: true }, code).code;
+}
+/**
+* Validates that no destructured export patterns contain names that should
+* be stripped. Destructured exports cannot be safely removed, so we throw
+* an error instead (matching React Router behaviour).
+*/
+function validateDestructuredExports(id, exportsToStrip) {
+	if (isArrayPattern(id)) for (const element of id.elements) {
+		if (!element) continue;
+		if (isIdentifier(element) && exportsToStrip.includes(element.name)) throw new Error(`Cannot remove destructured export "${element.name}"`);
+		if (isRestElement(element) && isIdentifier(element.argument) && exportsToStrip.includes(element.argument.name)) throw new Error(`Cannot remove destructured export "${element.argument.name}"`);
+		if (isArrayPattern(element) || isObjectPattern(element)) validateDestructuredExports(element, exportsToStrip);
+	}
+	if (isObjectPattern(id)) for (const property of id.properties) {
+		if (!property) continue;
+		if (isObjectProperty(property) && isIdentifier(property.key)) {
+			if (isIdentifier(property.value) && exportsToStrip.includes(property.value.name)) throw new Error(`Cannot remove destructured export "${property.value.name}"`);
+			if (isArrayPattern(property.value) || isObjectPattern(property.value)) validateDestructuredExports(property.value, exportsToStrip);
+		}
+		if (isRestElement(property) && isIdentifier(property.argument) && exportsToStrip.includes(property.argument.name)) throw new Error(`Cannot remove destructured export "${property.argument.name}"`);
+	}
+}
+/**
+* Removes a leading `// eslint-disable-next-line …` comment that sits on
+* the line immediately before the given path.
+*/
+function removeLeadingEslintDisableComment(path$2) {
+	const leadingComments = path$2.node.leadingComments;
+	if (!leadingComments || leadingComments.length === 0) return;
+	const last = leadingComments[leadingComments.length - 1];
+	if (last.type === "CommentLine" && last.value.includes("eslint-disable")) leadingComments.pop();
+}
+/**
+* Vite plugin that strips environment-specific loader exports from
+* component modules.
+*
+* Following the React Router convention:
+* - `export const loader` → server-only, stripped from the **client** bundle
+* - `export const clientLoader` → client-only, stripped from the **server** bundle
+*
+* This ensures that server-only code (e.g. API calls, database access) is
+* never included in the client bundle, and vice versa.
+*
+* The plugin only processes files that:
+* 1. Are under the configured `componentPath` directory
+* 2. Contain a `@Component` decorator (i.e. are Page Designer components)
+* 3. Are not test or story files
+*/
+function componentLoadersPlugin(config = {}) {
+	const { componentPath = "src/components" } = config;
+	let isTestMode = false;
+	return {
+		name: "storefrontnext:component-loaders",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			isTestMode = resolvedConfig.mode === "test";
+		},
+		transform(code, id) {
+			if (isTestMode) return null;
+			if (!id.includes(componentPath)) return null;
+			if (!/\.[mc]?[jt]sx?$/.test(id)) return null;
+			if (/\.(test|spec|stories)\.[jt]sx?$/.test(id)) return null;
+			const environmentName = this.environment?.name;
+			if (!environmentName) return null;
+			const exportsToStrip = getExportsToStrip(environmentName);
+			if (exportsToStrip.length === 0) return null;
+			if (!hasExportCandidate(code, exportsToStrip)) return null;
+			const ast = parse(code, {
+				sourceType: "module",
+				plugins: [
+					"typescript",
+					"jsx",
+					"decorators"
+				]
+			});
+			if (!hasComponentDecorator(ast)) return null;
+			const transformed = stripExports(code, exportsToStrip, ast);
+			if (!transformed) return null;
+			return {
+				code: transformed,
+				map: null
+			};
+		}
+	};
+}
+
 //#endregion
 //#region src/storefront-next-targets.ts
 /**
@@ -1276,13 +1622,11 @@ const workspacePlugin = () => {
 function storefrontNextTargets(config = {}) {
 	const { readableChunkNames = false, staticRegistry = {
 		componentPath: "",
-		registryPath: "",
-		verbose: false
+		registryPath: ""
 	}, eventInstrumentationValidator = {
 		configPath: "config.server.ts",
 		scanPaths: ["src"],
-		failOnMissing: false,
-		verbose: false
+		failOnMissing: false
 	} } = config;
 	const plugins = [
 		...process.env.SCAPI_PROXY_HOST ? [workspacePlugin()] : [],
@@ -1294,12 +1638,383 @@ function storefrontNextTargets(config = {}) {
 		watchConfigFilesPlugin(),
 		buildMiddlewareRegistryPlugin()
 	];
-	if (staticRegistry?.componentPath && staticRegistry?.registryPath) plugins.push(staticRegistryPlugin(staticRegistry));
+	if (staticRegistry?.componentPath && staticRegistry?.registryPath) {
+		plugins.push(staticRegistryPlugin(staticRegistry));
+		plugins.push(componentLoadersPlugin({ componentPath: staticRegistry.componentPath }));
+	}
 	if (eventInstrumentationValidator !== false) plugins.push(eventInstrumentationValidatorPlugin(eventInstrumentationValidator));
 	if (readableChunkNames) plugins.push(readableChunkFileNamesPlugin());
 	return plugins;
 }
 
+//#endregion
+//#region src/plugins/hybridProxy.ts
+/**
+* Check if a request path should skip proxying (Vite internals, assets, etc.)
+*
+* @param pathname - URL pathname to check
+* @returns true if the request should NOT be proxied
+*/
+function shouldSkipProxy(pathname) {
+	if (pathname.startsWith("/@")) return true;
+	if (pathname.startsWith("/__")) return true;
+	if (pathname.startsWith("/src/")) return true;
+	if (pathname.startsWith("/node_modules/")) return true;
+	if (pathname.endsWith(".data")) return true;
+	if (pathname.startsWith("/mobify/")) return true;
+	if (pathname.startsWith("/on/demandware.")) return false;
+	if (/\.(js|jsx|ts|tsx|css|json|map|woff2?|ttf|svg|png|jpe?g|gif|webp|ico|mp4)$/i.test(pathname)) return true;
+	return false;
+}
+/**
+* Rewrite Set-Cookie header for localhost development.
+*
+* Rewrites SFCC Set-Cookie headers so they work on localhost during local development.
+*
+* **LOCAL DEVELOPMENT ONLY** — This function is part of the hybrid proxy Vite plugin
+* which only runs during `pnpm dev`. In production (MRT deployments), SFCC cookies
+* flow through the eCDN unmodified.
+*
+* Rewrites applied:
+* - **Domain**: `.salesforce.com` → `localhost` (browsers reject cross-domain cookies)
+*
+* Attributes intentionally preserved:
+* - **Secure**: Kept. Localhost is a secure context — browsers accept `Secure` cookies
+*   on `http://localhost` (see https://w3c.github.io/webappsec-secure-contexts/).
+* - **SameSite**: Kept. `SameSite=None; Secure` is valid on localhost since `Secure`
+*   is accepted. This keeps SFCC cookies transparent and in sync with Storefront Next
+*   cookies, which is critical for hybrid auth session bridging.
+*
+* @param cookie - Original Set-Cookie header value from SFCC
+* @returns Rewritten cookie suitable for localhost
+*
+* @example
+* Input:  "dwsid=abc123; Domain=.salesforce.com; Path=/; Secure; SameSite=None; HttpOnly"
+* Output: "dwsid=abc123; Domain=localhost; Path=/; Secure; SameSite=None; HttpOnly"
+*/
+function rewriteCookieForLocalhost(cookie) {
+	let rewritten = cookie;
+	rewritten = rewritten.replace(/Domain=[^;]+/gi, "Domain=localhost");
+	if (!/Domain=/i.test(cookie)) rewritten = rewritten.replace(/^([^;]+)/, "$1; Domain=localhost");
+	return rewritten.trim();
+}
+/**
+* Inline script injected into proxied HTML responses to intercept `document.cookie` writes.
+*
+* **Why this is needed (Layer 3 cookie rewriting):**
+*
+* The hybrid proxy rewrites Set-Cookie headers from SFCC responses (Layer 1), but after
+* the SFRA page fully loads, client-side JavaScript sets cookies via `document.cookie`.
+* These writes bypass the proxy entirely.
+*
+* SFRA's JS typically checks `window.location.protocol` to decide whether to add `Secure`.
+* On `http://localhost`, it sees `http:` and omits `Secure`, producing cookies like:
+*
+*     document.cookie = "dwsid=abc; SameSite=None"   // No Secure → browser rejects
+*
+* This interceptor patches `document.cookie` to:
+* 1. Rewrite `Domain=...` → `Domain=localhost`
+* 2. Ensure `Secure` is present (localhost is a secure context)
+* 3. If `SameSite=None` is present without `Secure`, add `Secure`
+*
+* This keeps client-side cookie writes consistent with the proxy's Layer 1 rewrites
+* and ensures hybrid auth cookies (dwsid, cc-*) stay in sync between Storefront Next
+* and SFRA.
+*
+* **LOCAL DEVELOPMENT ONLY** — This script is only injected by the Vite dev server proxy.
+*/
+const COOKIE_INTERCEPTOR_SCRIPT = `<script data-hybrid-proxy="cookie-interceptor">
+(function() {
+    var desc = Object.getOwnPropertyDescriptor(Document.prototype, 'cookie');
+    if (!desc || !desc.set) return;
+    Object.defineProperty(document, 'cookie', {
+        get: function() { return desc.get.call(this); },
+        set: function(val) {
+            // Rewrite Domain to localhost
+            val = val.replace(/Domain=[^;]+/gi, 'Domain=localhost');
+            // Ensure Secure is present if SameSite=None (localhost is a secure context)
+            if (/SameSite=None/i.test(val) && !/;\\s*Secure\\b/i.test(val)) {
+                val += '; Secure';
+            }
+            desc.set.call(this, val);
+        },
+        configurable: true
+    });
+})();
+<\/script>`;
+/**
+* Escape special regex characters in a string for use in `new RegExp()`.
+*/
+function escapeRegExp(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Vite plugin for hybrid proxying between Storefront Next and legacy SFRA.
+*
+* Uses http-proxy to silently forward non-matching requests to SFCC without visible
+* redirects. Rewrites Set-Cookie headers, Location headers, and HTML/JSON response
+* bodies to keep all navigation within the localhost proxy.
+*
+* Routing decisions are delegated to the `routeMatcher` callback injected via options,
+* keeping the SDK free of template-specific routing logic.
+*
+* @param options - Plugin configuration
+* @returns Vite plugin
+*/
+function hybridProxyPlugin(options) {
+	if (!options.enabled) {
+		logger.debug("Hybrid proxy disabled (HYBRID_PROXY_ENABLED is not true)");
+		return { name: "hybrid-proxy" };
+	}
+	if (!options.targetOrigin) {
+		logger.warn("Hybrid proxy: no target origin configured (SFCC_ORIGIN required)");
+		return { name: "hybrid-proxy" };
+	}
+	logger.info(`Hybrid proxy enabled → ${options.targetOrigin}`);
+	logger.debug(`Hybrid proxy routing rules: ${options.routingRules.slice(0, 100)}...`);
+	const locale = options.locale || "default";
+	logger.debug(`Hybrid proxy path transformation: / → /s/${options.siteId}, /path → /s/${options.siteId}/${locale}/path`);
+	const targetOriginPattern = new RegExp(escapeRegExp(options.targetOrigin), "g");
+	const proxy = httpProxy.createProxyServer({
+		changeOrigin: true,
+		followRedirects: false,
+		selfHandleResponse: true
+	});
+	proxy.on("proxyReq", (proxyReq, req) => {
+		const url = new URL(req.url || "", `http://${req.headers.host}`);
+		const pathname = url.pathname;
+		if (!pathname.startsWith("/s/") && !pathname.startsWith("/on/demandware.")) {
+			const originalPath = proxyReq.path;
+			/**
+			* "/" maps to the SFRA/SiteGenesis site root — no locale in the path
+			* This would simply proxy to SFCC hostname (eg.: https://zzrf-001.dx.commercecloud.salesforce.com/s/{siteId}/{locale}/) which is not a valid storefront URL.
+			* We need to rewrite the path to /s/{siteId} so that it can be proxied to the correct SFCC URL.
+			*/
+			if (pathname === "/") proxyReq.path = `/s/${options.siteId}${url.search}`;
+			else proxyReq.path = `/s/${options.siteId}/${locale}${pathname}${url.search}`;
+			logger.debug(`Hybrid proxy path rewrite: ${originalPath} → ${proxyReq.path}`);
+		}
+	});
+	proxy.on("proxyRes", (proxyRes, req, res) => {
+		const clientRes = res;
+		const locationHeader = proxyRes.headers.location;
+		const statusCode = proxyRes.statusCode || 200;
+		if (statusCode >= 300 && statusCode < 400 && typeof locationHeader === "string" && /\/404\b/.test(locationHeader)) {
+			logger.warn(`⚠️  SFCC returned a redirect to 404 for ${req.url}. This usually means your HYBRID_ROUTING_RULES are missing a pattern for this path. Stripping Set-Cookie headers to prevent session cookie corruption. Fix: add a matching pattern to HYBRID_ROUTING_RULES (e.g., "^${req.url?.split("?")[0]}.*")`);
+			delete proxyRes.headers["set-cookie"];
+		}
+		const setCookieHeaders = proxyRes.headers["set-cookie"];
+		if (setCookieHeaders && Array.isArray(setCookieHeaders)) proxyRes.headers["set-cookie"] = setCookieHeaders.map((cookie) => {
+			const rewritten = rewriteCookieForLocalhost(cookie);
+			logger.debug(`Hybrid proxy cookie rewrite: ${cookie.slice(0, 50)}... → ${rewritten.slice(0, 50)}...`);
+			return rewritten;
+		});
+		if (locationHeader && typeof locationHeader === "string") try {
+			const locationUrl = new URL(locationHeader, options.targetOrigin);
+			if (locationUrl.origin === options.targetOrigin) {
+				const localUrl = `http://${req.headers.host}${locationUrl.pathname}${locationUrl.search}${locationUrl.hash}`;
+				proxyRes.headers.location = localUrl;
+				logger.debug(`Hybrid proxy location rewrite: ${locationHeader} → ${localUrl}`);
+			}
+		} catch {
+			logger.warn(`Hybrid proxy: invalid Location header: ${locationHeader}`);
+		}
+		const contentType = (proxyRes.headers["content-type"] || "").split(";")[0].trim();
+		if (!(contentType === "text/html" || contentType === "application/json")) {
+			clientRes.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+			proxyRes.pipe(clientRes);
+			return;
+		}
+		const chunks = [];
+		proxyRes.on("data", (chunk) => chunks.push(chunk));
+		proxyRes.on("end", () => {
+			let body = Buffer.concat(chunks);
+			const encoding = proxyRes.headers["content-encoding"];
+			if (encoding === "gzip") body = gunzipSync(body);
+			else if (encoding === "br") body = brotliDecompressSync(body);
+			else if (encoding === "deflate") body = inflateSync(body);
+			const proxyOrigin = `http://${req.headers.host}`;
+			let text = body.toString("utf8");
+			targetOriginPattern.lastIndex = 0;
+			text = text.replace(targetOriginPattern, proxyOrigin);
+			if (contentType === "text/html") {
+				const headIndex = text.indexOf("<head");
+				if (headIndex !== -1) {
+					const insertAfter = text.indexOf(">", headIndex);
+					if (insertAfter !== -1) text = text.slice(0, insertAfter + 1) + COOKIE_INTERCEPTOR_SCRIPT + text.slice(insertAfter + 1);
+				}
+			}
+			const headers = { ...proxyRes.headers };
+			delete headers["content-encoding"];
+			delete headers["transfer-encoding"];
+			headers["content-length"] = String(Buffer.byteLength(text, "utf8"));
+			clientRes.writeHead(proxyRes.statusCode || 200, headers);
+			clientRes.end(text);
+			logger.debug(`Hybrid proxy rewrote ${contentType} body URLs for ${req.url}`);
+		});
+	});
+	proxy.on("error", (err, req, res) => {
+		logger.error(`Hybrid proxy error: ${err.message} ${req.url}`);
+		if ("writeHead" in res && !res.headersSent) {
+			res.writeHead(502, { "Content-Type": "text/plain" });
+			res.end("Bad Gateway: Failed to proxy to SFCC");
+		}
+	});
+	return {
+		name: "hybrid-proxy",
+		enforce: "pre",
+		configureServer(server) {
+			server.middlewares.use((req, res, next) => {
+				const pathname = req.url?.split("?")[0] || "";
+				if (shouldSkipProxy(pathname)) return next();
+				const isSFCCPath = pathname.startsWith("/on/demandware.");
+				let shouldRouteToNextApp = false;
+				if (!isSFCCPath) {
+					try {
+						shouldRouteToNextApp = options.routeMatcher(pathname, options.routingRules);
+					} catch (error) {
+						logger.error(`Hybrid proxy error checking routing rules: ${String(error)}`);
+						return next();
+					}
+					if (shouldRouteToNextApp) return next();
+				}
+				logger.debug(`Hybrid proxy: ${req.method} ${pathname} → ${options.targetOrigin}`);
+				try {
+					proxy.web(req, res, { target: options.targetOrigin });
+				} catch (error) {
+					logger.error(`Hybrid proxy failed to proxy request: ${String(error)}`);
+					if (!res.headersSent) {
+						res.writeHead(502, { "Content-Type": "text/plain" });
+						res.end("Bad Gateway: Failed to proxy to SFCC");
+					}
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/ecdnMatcher.ts
+/**
+* Cloudflare eCDN Routing Rule Matcher
+*
+* Parses Cloudflare-style routing expressions and tests pathnames against them.
+* This utility is environment-agnostic and works in both Node.js and browser contexts.
+*
+* @example
+* ```typescript
+* const rules = '(http.request.uri.path matches "^/$" or http.request.uri.path matches "^/search.*")';
+* shouldRouteToNext('/', rules);          // true - route to Storefront Next
+* shouldRouteToNext('/search', rules);    // true - route to Storefront Next
+* shouldRouteToNext('/checkout', rules);  // false - proxy to SFRA/legacy
+* ```
+*
+* Environment variables used:
+* - HYBRID_PROXY_ENABLED (optional) - Boolean flag to enable/disable hybrid proxy
+* - HYBRID_ROUTING_RULES (optional) - Cloudflare routing expression string
+* - SFCC_ORIGIN (optional) - Base URL for SFCC sandbox redirects
+*/
+const regexCache = /* @__PURE__ */ new Map();
+/**
+* Extracts regex patterns from a Cloudflare routing expression.
+*
+* Parses Cloudflare "matches" expressions like:
+*   (http.request.uri.path matches "^/$" or http.request.uri.path matches "^/category.*")
+*
+* And extracts the regex patterns: ["^/$", "^/category.*"]
+*
+* @param expression - Cloudflare expression string
+* @returns Array of regex pattern strings
+*
+* @example
+* ```typescript
+* extractPatterns('(http.request.uri.path matches "^/$")');
+* // Returns: ["^/$"]
+*
+* extractPatterns('(http.request.uri.path matches "^/$" or http.request.uri.path matches "^/search.*")');
+* // Returns: ["^/$", "^/search.*"]
+* ```
+*/
+function extractPatterns(expression) {
+	if (!expression || typeof expression !== "string") return [];
+	const regex = /http\.request\.uri\.path\s+matches\s+["']([^"']+)["']/gi;
+	const patterns = [];
+	let match;
+	while ((match = regex.exec(expression)) !== null) patterns.push(match[1]);
+	return patterns;
+}
+/**
+* Tests if a pathname matches any of the provided regex patterns (logical OR).
+* Uses caching to optimize repeated pattern compilations.
+*
+* @param pathname - URL pathname to test (e.g., "/search", "/category/shoes")
+* @param patterns - Array of regex pattern strings
+* @returns true if pathname matches any pattern, false otherwise
+*
+* @example
+* ```typescript
+* testPatterns('/category/shoes', ['^/category.*', '^/search.*']);
+* // Returns: true (matches first pattern)
+*
+* testPatterns('/checkout', ['^/category.*', '^/search.*']);
+* // Returns: false (matches no patterns)
+* ```
+*/
+function testPatterns(pathname, patterns) {
+	if (!pathname || !patterns || patterns.length === 0) return false;
+	for (const pattern of patterns) try {
+		let regex = regexCache.get(pattern);
+		if (!regex) {
+			regex = new RegExp(pattern);
+			regexCache.set(pattern, regex);
+		}
+		if (regex.test(pathname)) return true;
+	} catch (error) {
+		logger.warn(`Invalid regex pattern: ${pattern} ${String(error)}`);
+		continue;
+	}
+	return false;
+}
+/**
+* Main function: Determines if a pathname should route to Storefront Next
+* or be proxied/redirected to SFRA/legacy backend.
+*
+* @param pathname - URL pathname (e.g., "/search", "/checkout")
+* @param routingRules - Cloudflare routing expression string (optional)
+* @returns true if should route to Storefront Next, false if should proxy to SFRA
+*
+* @example
+* ```typescript
+* const rules = '(http.request.uri.path matches "^/$" or http.request.uri.path matches "^/category.*")';
+*
+* shouldRouteToNext('/', rules);              // true - route to Next
+* shouldRouteToNext('/category/mens', rules); // true - route to Next
+* shouldRouteToNext('/checkout', rules);      // false - proxy to SFRA
+* shouldRouteToNext('/any-path', undefined);  // true - no rules = default to Next
+* ```
+*/
+function shouldRouteToNext(pathname, routingRules) {
+	if (!routingRules) return true;
+	const patterns = extractPatterns(routingRules);
+	if (patterns.length === 0) {
+		logger.warn("No valid patterns found in routing rules");
+		return true;
+	}
+	return testPatterns(pathname, patterns);
+}
+/**
+* Clears the regex cache. Useful for testing or when routing rules change.
+*
+* @example
+* ```typescript
+* clearCache();
+* // All cached regex patterns are removed
+* ```
+*/
+function clearCache() {
+	regexCache.clear();
+}
+
 //#endregion
 //#region src/server/ts-import.ts
 /**
@@ -1367,18 +2082,15 @@ function loadConfigFromEnv() {
 	const shortCode = process.env.PUBLIC__app__commerce__api__shortCode;
 	const organizationId = process.env.PUBLIC__app__commerce__api__organizationId;
 	const clientId = process.env.PUBLIC__app__commerce__api__clientId;
-	const siteId = process.env.PUBLIC__app__commerce__api__siteId;
 	const proxy = process.env.PUBLIC__app__commerce__api__proxy || "/mobify/proxy/api";
 	const proxyHost = process.env.SCAPI_PROXY_HOST;
 	if (!shortCode && !proxyHost) throw new Error("Missing PUBLIC__app__commerce__api__shortCode environment variable.\nPlease set it in your .env file or environment.");
 	if (!organizationId) throw new Error("Missing PUBLIC__app__commerce__api__organizationId environment variable.\nPlease set it in your .env file or environment.");
 	if (!clientId) throw new Error("Missing PUBLIC__app__commerce__api__clientId environment variable.\nPlease set it in your .env file or environment.");
-	if (!siteId) throw new Error("Missing PUBLIC__app__commerce__api__siteId environment variable.\nPlease set it in your .env file or environment.");
 	return { commerce: { api: {
 		shortCode: shortCode || "",
 		organizationId,
 		clientId,
-		siteId,
 		proxy,
 		proxyHost
 	} } };
@@ -1404,17 +2116,20 @@ async function loadProjectConfig(projectDirectory) {
 	if (!api.shortCode && !proxyHost) throw new Error("Missing shortCode in config.server.ts commerce.api configuration");
 	if (!api.organizationId) throw new Error("Missing organizationId in config.server.ts commerce.api configuration");
 	if (!api.clientId) throw new Error("Missing clientId in config.server.ts commerce.api configuration");
-	if (!api.siteId) throw new Error("Missing siteId in config.server.ts commerce.api configuration");
 	return { commerce: { api: {
 		shortCode: api.shortCode || "",
 		organizationId: api.organizationId,
 		clientId: api.clientId,
-		siteId: api.siteId,
 		proxy: api.proxy || "/mobify/proxy/api",
 		proxyHost
 	} } };
 }
 
+//#endregion
+//#region src/config.ts
+const SFNEXT_BASE_CARTRIDGE_NAME = "app_storefrontnext_base";
+const SFNEXT_BASE_CARTRIDGE_OUTPUT_DIR = `${SFNEXT_BASE_CARTRIDGE_NAME}/cartridge/experience`;
+
 //#endregion
 //#region src/server/middleware/proxy.ts
 /**
@@ -1429,25 +2144,6 @@ function createCommerceProxyMiddleware(config) {
 	});
 }
 
-//#endregion
-//#region src/utils/logger.ts
-/**
-* Logger utilities
-*/
-const colors = {
-	warn: "yellow",
-	error: "red",
-	success: "cyan",
-	info: "green",
-	debug: "gray"
-};
-const fancyLog = (level, msg) => {
-	const colorFn = chalk[colors[level]];
-	console.log(`${colorFn(level)}: ${msg}`);
-};
-const info = (msg) => fancyLog("info", msg);
-const warn = (msg) => fancyLog("warn", msg);
-
 //#endregion
 //#region src/server/middleware/static.ts
 /**
@@ -1457,7 +2153,7 @@ const warn = (msg) => fancyLog("warn", msg);
 function createStaticMiddleware(bundleId, projectDirectory) {
 	const bundlePath = getBundlePath(bundleId);
 	const clientBuildDir = path$1.join(projectDirectory, "build", "client");
-	info(`Serving static assets from ${clientBuildDir} at ${bundlePath}`);
+	logger.info(`Serving static assets from ${clientBuildDir} at ${bundlePath}`);
 	return express.static(clientBuildDir, { setHeaders: (res) => {
 		res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
 		res.setHeader("x-local-static-cache-control", "1");
@@ -1476,7 +2172,7 @@ function getCompressionLevel() {
 	if (raw == null || raw.trim() === "") return DEFAULT;
 	const level = Number(raw);
 	if (!(Number.isInteger(level) && level >= 0 && level <= 9)) {
-		warn(`[compression] Invalid COMPRESSION_LEVEL="${raw}". Using default (${DEFAULT}).`);
+		logger.warn(`[compression] Invalid COMPRESSION_LEVEL="${raw}". Using default (${DEFAULT}).`);
 		return DEFAULT;
 	}
 	return level;
@@ -1529,20 +2225,18 @@ function createLoggingMiddleware() {
 	});
 	morgan.token("method-colored", (req) => {
 		const method = req.method;
-		const colors$1 = {
+		const colors = {
 			GET: chalk.green,
 			POST: chalk.blue,
 			PUT: chalk.yellow,
 			DELETE: chalk.red,
 			PATCH: chalk.magenta
 		};
-		return (method && colors$1[method] || chalk.white)(method);
+		return (method && colors[method] || chalk.white)(method);
 	});
 	return morgan((tokens, req, res) => {
 		return [
-			chalk.gray("["),
 			tokens["method-colored"](req, res),
-			chalk.gray("]"),
 			tokens.url(req, res),
 			"-",
 			tokens["status-colored"](req, res),
@@ -1594,11 +2288,13 @@ function createHostHeaderMiddleware() {
 */
 function patchReactRouterBuild(build, bundleId) {
 	const bundlePath = getBundlePath(bundleId);
+	const basePath = getBasePath();
 	const patchedAssetsJson = JSON.stringify(build.assets).replace(/"\/assets\//g, `"${bundlePath}assets/`);
 	const newAssets = JSON.parse(patchedAssetsJson);
 	return Object.assign({}, build, {
 		publicPath: bundlePath,
-		assets: newAssets
+		assets: newAssets,
+		...basePath && { basename: basePath }
 	});
 }
 
@@ -1631,6 +2327,225 @@ const ServerModeFeatureMap = {
 	}
 };
 
+//#endregion
+//#region src/otel/mrt-console-span-exporter.ts
+var MrtConsoleSpanExporter = class extends ConsoleSpanExporter {
+	export(spans, resultCallback) {
+		for (const span of spans) try {
+			const ctx = span.spanContext();
+			const spanData = {
+				traceId: ctx.traceId,
+				parentId: span.parentSpanId,
+				name: span.name,
+				id: ctx.spanId,
+				kind: span.kind,
+				timestamp: hrTimeToTimeStamp(span.startTime),
+				duration: span.duration,
+				attributes: span.attributes,
+				status: span.status,
+				events: span.events,
+				links: span.links,
+				start_time: span.startTime,
+				end_time: span.endTime,
+				forwardTrace: process.env.SFNEXT_OTEL_ENABLED === "true"
+			};
+			console.info(JSON.stringify(spanData));
+		} catch {}
+		resultCallback({ code: ExportResultCode.SUCCESS });
+	}
+};
+
+//#endregion
+//#region src/otel/setup.ts
+const SERVICE_NAME = "storefront-next";
+/**
+* Initializes OpenTelemetry and returns a Tracer from the provider directly.
+*
+* Returns the tracer via `provider.getTracer()` instead of the global
+* `trace.getTracer()` API. In the Vite SSR module runner, the built
+* dist/entry/server.js and the externalized @opentelemetry/sdk-trace-node
+* resolve @opentelemetry/api to different module instances (different paths
+* through pnpm's strict node_modules). Each instance has its own
+* ProxyTracerProvider singleton, so `provider.register()` sets the delegate
+* on sdk-trace-node's API instance while our code's `trace.getTracer()`
+* reads from a separate API instance with no delegate — returning a tracer
+* backed by a bare BasicTracerProvider with NoopSpanProcessor.
+*
+* Getting the tracer directly from the provider bypasses the global registry
+* entirely, guaranteeing the tracer uses our configured span processors.
+*/
+let cachedTracer = null;
+const UNDICI_REGISTERED_KEY = Symbol.for("sfnext.otel.undici_registered");
+function initTelemetry() {
+	if (cachedTracer) return cachedTracer;
+	try {
+		const provider = new NodeTracerProvider({ resource: new Resource({ [ATTR_SERVICE_NAME]: SERVICE_NAME }) });
+		provider.addSpanProcessor(new SimpleSpanProcessor(new MrtConsoleSpanExporter()));
+		provider.register();
+		if (!globalThis[UNDICI_REGISTERED_KEY]) {
+			globalThis[UNDICI_REGISTERED_KEY] = true;
+			registerInstrumentations({
+				tracerProvider: provider,
+				instrumentations: [new UndiciInstrumentation({ requestHook(span, request) {
+					try {
+						const method = request.method.toUpperCase();
+						const url = `${request.origin}${request.path}`;
+						span.updateName(`${method} ${url}`);
+					} catch {}
+				} })]
+			});
+		}
+		cachedTracer = provider.getTracer(SERVICE_NAME);
+		return cachedTracer;
+	} catch (error) {
+		logger.error("[otel] Failed to initialize OpenTelemetry:", error);
+		return null;
+	}
+}
+
+//#endregion
+//#region src/otel/express/middleware.ts
+function createOtelExpressMiddleware() {
+	const maybeTracer = initTelemetry();
+	if (!maybeTracer) return (_req, _res, next) => next();
+	const tracer = maybeTracer;
+	return (req, res, next) => {
+		try {
+			const url = new URL(req.originalUrl || req.url, "http://localhost").pathname;
+			const method = req.method;
+			tracer.startActiveSpan(`[sfnext] server ${method} ${url}`, { attributes: {
+				"http.request.method": method,
+				"url.path": url
+			} }, (serverSpan) => {
+				try {
+					const spanContext = trace.getSpan(context.active())?.spanContext();
+					if (spanContext) {
+						const flags = spanContext.traceFlags.toString(16).padStart(2, "0");
+						const traceparent = `00-${spanContext.traceId}-${spanContext.spanId}-${flags}`;
+						res.setHeader("traceparent", traceparent);
+					}
+				} catch {}
+				const serverCtx = context.active();
+				const startTime = performance.now();
+				let streamingSpan = null;
+				let ttfbMs = 0;
+				let ended = false;
+				function recordTTFB() {
+					if (streamingSpan) return;
+					try {
+						ttfbMs = Math.round(performance.now() - startTime);
+						serverSpan.setAttribute("sfnext.ttfb_ms", ttfbMs);
+						streamingSpan = tracer.startSpan(`[sfnext] response streaming ${method} ${url}`, { attributes: {
+							"http.request.method": method,
+							"url.path": url,
+							"sfnext.ttfb_ms": ttfbMs
+						} }, serverCtx);
+					} catch {}
+				}
+				const origWriteHead = res.writeHead.bind(res);
+				res.writeHead = ((...args) => {
+					recordTTFB();
+					return origWriteHead(...args);
+				});
+				const origWrite = res.write.bind(res);
+				res.write = ((...args) => {
+					recordTTFB();
+					return origWrite(...args);
+				});
+				function endSpans() {
+					if (ended) return;
+					ended = true;
+					try {
+						const totalMs = Math.round(performance.now() - startTime);
+						const statusCode = res.statusCode;
+						if (streamingSpan) {
+							streamingSpan.setAttribute("http.streaming_duration_ms", totalMs - ttfbMs);
+							streamingSpan.setAttribute("http.response.status_code", statusCode);
+							if (statusCode >= 500) streamingSpan.setStatus({ code: SpanStatusCode.ERROR });
+							streamingSpan.end();
+						}
+						serverSpan.setAttribute("http.response.status_code", statusCode);
+						serverSpan.setAttribute("http.total_duration_ms", totalMs);
+						if (statusCode >= 500) serverSpan.setStatus({ code: SpanStatusCode.ERROR });
+						serverSpan.end();
+					} catch {}
+				}
+				res.once("close", endSpans);
+				res.once("finish", endSpans);
+				next();
+			});
+		} catch {
+			next();
+		}
+	};
+}
+
+//#endregion
+//#region src/server/handlers/health-check.ts
+const DEFAULT_HEALTH_DESCRIPTION = "storefront-next-dev server health";
+const PACKAGE_JSON_NAME = "package.json";
+const RUNTIME_PACKAGE_NAME = "@salesforce/storefront-next-runtime";
+const DEV_PACKAGE_NAME = "@salesforce/storefront-next-dev";
+const BUILD_FOLDER_NAME = "build";
+const LOCAL_BUNDLE_ID = "local";
+const HEALTH_ENDPOINT_PATH = "/sfdc-health";
+/**
+* Reads a package.json file and returns selected metadata.
+*
+* @param path - Absolute path to a package.json file
+* @returns Parsed metadata, or null if missing/unreadable
+*
+* @example
+* ```ts
+* const metadata = readPackageMetadata('/app/package.json');
+* console.log(metadata?.version);
+* ```
+*/
+function readPackageMetadata(path$2) {
+	if (!existsSync$1(path$2)) return null;
+	try {
+		return JSON.parse(readFileSync$1(path$2, "utf8"));
+	} catch (error) {
+		logger.debug(`Health check: failed to parse package.json at ${path$2}`, error);
+		return null;
+	}
+}
+/**
+* Creates an Express handler that returns Health+JSON for the project.
+*
+* @param options - Handler options
+* @returns Express request handler for the health endpoint
+*
+* @example
+* ```ts
+* app.get(HEALTH_ENDPOINT_PATH, createHealthCheckHandler({
+*     projectDirectory: process.cwd(),
+*     bundleId: LOCAL_BUNDLE_ID,
+* }));
+* ```
+*/
+function createHealthCheckHandler(options) {
+	const { projectDirectory, bundleId } = options;
+	const projectPackage = readPackageMetadata(bundleId === LOCAL_BUNDLE_ID ? resolve(projectDirectory, PACKAGE_JSON_NAME) : resolve(projectDirectory, BUILD_FOLDER_NAME, PACKAGE_JSON_NAME));
+	const allDependencies = {
+		...projectPackage?.dependencies,
+		...projectPackage?.devDependencies
+	};
+	const devVersion = allDependencies?.[DEV_PACKAGE_NAME];
+	const runtimeVersion = allDependencies?.[RUNTIME_PACKAGE_NAME];
+	const notes = [devVersion ? `Built using ${DEV_PACKAGE_NAME}@${devVersion}.` : null, runtimeVersion ? `Running ${RUNTIME_PACKAGE_NAME}@${runtimeVersion}.` : null].filter(Boolean);
+	return (_req, res) => {
+		const healthResponse = {
+			status: "pass",
+			version: projectPackage?.version,
+			bundleId,
+			description: projectPackage?.description ?? DEFAULT_HEALTH_DESCRIPTION,
+			notes: notes.length > 0 ? notes : void 0
+		};
+		res.status(200).type("application/health+json").json(healthResponse);
+	};
+}
+
 //#endregion
 //#region src/server/index.ts
 /** Relative path to the middleware registry TypeScript source (development). Must match appDirectory + server dir + filename used by buildMiddlewareRegistry plugin. */
@@ -1643,6 +2558,7 @@ const MIDDLEWARE_REGISTRY_BUILT_EXTENSIONS = [
 ];
 /** All paths to try when loading the built middlewares (base + extension). */
 const RELATIVE_MIDDLEWARE_REGISTRY_BUILT_PATHS = ["bld/server/middleware-registry", "build/server/middleware-registry"].flatMap((base) => MIDDLEWARE_REGISTRY_BUILT_EXTENSIONS.map((ext) => `${base}${ext}`));
+const DEFAULT_BUNDLE_ID = "local";
 /**
 * Create a unified Express server for development, preview, or production mode
 */
@@ -1651,9 +2567,14 @@ async function createServer(options) {
 	if (mode === "development" && !vite) throw new Error("Vite dev server instance is required for development mode");
 	if ((mode === "preview" || mode === "production") && !build) throw new Error("React Router server build is required for preview/production mode");
 	const config = providedConfig ?? loadConfigFromEnv();
-	const bundleId = process.env.BUNDLE_ID ?? "local";
+	const bundleId = process.env.BUNDLE_ID ?? DEFAULT_BUNDLE_ID;
 	const app = express();
 	app.disable("x-powered-by");
+	if (process.env.SFNEXT_OTEL_ENABLED === "true") app.use(createOtelExpressMiddleware());
+	app.get(HEALTH_ENDPOINT_PATH, createHealthCheckHandler({
+		projectDirectory,
+		bundleId
+	}));
 	if (enableLogging) app.use(createLoggingMiddleware());
 	if (enableCompression && !streaming) app.use(createCompressionMiddleware());
 	if (enableStaticServing && build) {
@@ -1678,8 +2599,14 @@ async function createServer(options) {
 	});
 	if (mode === "development" && vite) app.use(vite.middlewares);
 	if (enableProxy) app.use(config.commerce.api.proxy, createCommerceProxyMiddleware(config));
+	const basePath = getBasePath();
+	if (basePath) app.use((req, res, next) => {
+		if (req.path.startsWith(`${basePath}/`) || req.path === basePath) return next();
+		if (req.path.startsWith("/mobify/")) return next();
+		res.redirect(`${basePath}${req.originalUrl}`);
+	});
 	app.use(createHostHeaderMiddleware());
-	app.all("*", await createSSRHandler(mode, bundleId, vite, build, enableAssetUrlPatching));
+	app.all("*splat", await createSSRHandler(mode, bundleId, vite, build, enableAssetUrlPatching));
 	return app;
 }
 /**
@@ -1707,9 +2634,10 @@ async function createSSRHandler(mode, bundleId, vite, build, enableAssetUrlPatch
 	} else if (build) {
 		let patchedBuild = build;
 		if (enableAssetUrlPatching) patchedBuild = patchReactRouterBuild(build, bundleId);
+		const requestHandlerMode = process.env.NODE_OPTIONS?.includes("--enable-source-maps") ? "development" : process.env.NODE_ENV;
 		return createRequestHandler({
 			build: patchedBuild,
-			mode: process.env.NODE_ENV
+			mode: requestHandlerMode
 		});
 	} else throw new Error("Invalid server configuration: no vite or build provided");
 }
@@ -1731,17 +2659,15 @@ const SINGLE_LINE_MARKER = "@sfdc-extension-line";
 const BLOCK_MARKER_START = "@sfdc-extension-block-start";
 const BLOCK_MARKER_END = "@sfdc-extension-block-end";
 const FILE_MARKER = "@sfdc-extension-file";
-let verbose = false;
-function trimExtensions(directory, selectedExtensions, extensionConfig, verboseOverride = false) {
+function trimExtensions(directory, selectedExtensions, extensionConfig) {
 	const startTime = Date.now();
-	verbose = verboseOverride ?? false;
 	const configuredExtensions = extensionConfig?.extensions || {};
 	const extensions = {};
 	Object.keys(configuredExtensions).forEach((targetKey) => {
 		extensions[targetKey] = Boolean(selectedExtensions?.[targetKey]) || false;
 	});
 	if (Object.keys(extensions).length === 0) {
-		if (verbose) console.log("No targets found, skipping trim");
+		logger.debug("No targets found, skipping trim");
 		return;
 	}
 	const processDirectory = (dir) => {
@@ -1760,7 +2686,7 @@ function trimExtensions(directory, selectedExtensions, extensionConfig, verboseO
 		updateExtensionConfig(directory, extensions);
 	}
 	const endTime = Date.now();
-	if (verbose) console.log(`Trim extensions took ${endTime - startTime}ms`);
+	logger.debug(`Trim extensions took ${endTime - startTime}ms`);
 }
 /**
 * Update the extension config file to only include the selected extensions.
@@ -1785,15 +2711,14 @@ function processFile(filePath, extensions) {
 	if (source.includes(FILE_MARKER)) {
 		const markerLine = source.split("\n").find((line) => line.includes(FILE_MARKER));
 		const extMatch = Object.keys(extensions).find((ext) => markerLine.includes(ext));
-		if (!extMatch) {
-			if (verbose) console.warn(`File ${filePath} is marked with ${markerLine} but it does not match any known extensions`);
-		} else if (extensions[extMatch] === false) {
+		if (!extMatch) logger.warn(`File ${filePath} is marked with ${markerLine} but it does not match any known extensions`);
+		else if (extensions[extMatch] === false) {
 			try {
 				fs$1.unlinkSync(filePath);
-				if (verbose) console.log(`Deleted file ${filePath}`);
+				logger.debug(`Deleted file ${filePath}`);
 			} catch (e) {
 				const error = e;
-				console.error(`Error deleting file ${filePath}: ${error.message}`);
+				logger.error(`Error deleting file ${filePath}: ${error.message}`);
 				throw e;
 			}
 			return;
@@ -1822,7 +2747,7 @@ function processFile(filePath, extensions) {
 						line: i
 					});
 					skippingBlock = extensions[matchingExtension] === false;
-				} else if (verbose) console.warn(`Warning: Unknown marker found in ${filePath} at line ${i}: \n${line}`);
+				} else logger.warn(`Unknown marker found in ${filePath} at line ${i}: \n${line}`);
 			} else if (line.includes(BLOCK_MARKER_END)) {
 				if (Object.keys(extensions).find((extension) => line.includes(extension))) {
 					const extension = Object.keys(extensions).find((p) => line.includes(p));
@@ -1843,10 +2768,10 @@ function processFile(filePath, extensions) {
 		const newSource = newLines.join("\n");
 		if (newSource !== source) try {
 			fs$1.writeFileSync(filePath, newSource);
-			if (verbose) console.log(`Updated file ${filePath}`);
+			logger.debug(`Updated file ${filePath}`);
 		} catch (e) {
 			const error = e;
-			console.error(`Error updating file ${filePath}: ${error.message}`);
+			logger.error(`Error updating file ${filePath}: ${error.message}`);
 			throw e;
 		}
 	}
@@ -1870,11 +2795,11 @@ function deleteExtensionFolders(projectRoot, extensions, extensionConfig) {
 					recursive: true,
 					force: true
 				});
-				if (verbose) console.log(`Deleted extension folder: ${extensionFolderPath}`);
+				logger.debug(`Deleted extension folder: ${extensionFolderPath}`);
 			} catch (err) {
 				const error = err;
-				if (error.code === "EPERM") console.error(`Permission denied - cannot delete ${extensionFolderPath}. You may need to run with sudo or check permissions.`);
-				else console.error(`Error deleting ${extensionFolderPath}: ${error.message}`);
+				if (error.code === "EPERM") logger.error(`Permission denied - cannot delete ${extensionFolderPath}. You may need to run with sudo or check permissions.`);
+				else logger.error(`Error deleting ${extensionFolderPath}: ${error.message}`);
 			}
 		}
 	});
@@ -1950,7 +2875,7 @@ function filePathToRoute(filePath, projectRoot) {
 		const routeFileNormalized = routeFilePosix.replace(/^\.\//, "");
 		if (filePathPosix.endsWith(routeFileNormalized) || filePathPosix.endsWith(`/${routeFileNormalized}`)) return route.path;
 	}
-	console.warn(`Warning: Could not find route for file: ${filePath}`);
+	logger.warn(`Could not find route for file: ${filePath}`);
 	return "/unknown";
 }
 /**
@@ -2025,7 +2950,7 @@ const TYPE_MAPPING = {
 function resolveAttributeType(decoratorType, tsMorphType, fieldName) {
 	if (decoratorType) {
 		if (!VALID_ATTRIBUTE_TYPES.includes(decoratorType)) {
-			console.error(`Error: Invalid attribute type '${decoratorType}' for field '${fieldName || "unknown"}'. Valid types are: ${VALID_ATTRIBUTE_TYPES.join(", ")}`);
+			logger.error(`Invalid attribute type '${decoratorType}' for field '${fieldName || "unknown"}'. Valid types are: ${VALID_ATTRIBUTE_TYPES.join(", ")}`);
 			process.exit(1);
 		}
 		return decoratorType;
@@ -2050,6 +2975,30 @@ function getTypeFromTsMorph(property, _sourceFile) {
 	} catch {}
 	return "string";
 }
+/**
+* Resolve a variable's initializer expression from the same source file,
+* unwrapping `as const` type assertions.
+*/
+function resolveVariableInitializer(sourceFile, name) {
+	const varDecl = sourceFile.getVariableDeclaration(name);
+	if (!varDecl) return void 0;
+	let initializer = varDecl.getInitializer();
+	if (initializer && Node.isAsExpression(initializer)) initializer = initializer.getExpression();
+	return initializer;
+}
+/**
+* Check whether an AST node is a type that `parseExpression` can resolve to a
+* concrete JS value (as opposed to falling through to `getText()`).
+*/
+function isResolvableLiteral(node) {
+	return Node.isStringLiteral(node) || Node.isNumericLiteral(node) || Node.isTrueLiteral(node) || Node.isFalseLiteral(node) || Node.isObjectLiteralExpression(node) || Node.isArrayLiteralExpression(node);
+}
+var UnresolvedConstantReferenceError = class extends Error {
+	constructor(reference) {
+		super(`Cannot resolve constant reference '${reference}'. Ensure the variable is declared in the same file as a literal value.`);
+		this.name = "UnresolvedConstantReferenceError";
+	}
+};
 function parseExpression(expression) {
 	if (Node.isStringLiteral(expression)) return expression.getLiteralValue();
 	else if (Node.isNumericLiteral(expression)) return expression.getLiteralValue();
@@ -2057,7 +3006,26 @@ function parseExpression(expression) {
 	else if (Node.isFalseLiteral(expression)) return false;
 	else if (Node.isObjectLiteralExpression(expression)) return parseNestedObject(expression);
 	else if (Node.isArrayLiteralExpression(expression)) return parseArrayLiteral(expression);
-	else return expression.getText();
+	else if (Node.isPropertyAccessExpression(expression)) {
+		const obj = expression.getExpression();
+		const propName = expression.getName();
+		if (Node.isIdentifier(obj)) {
+			const resolved = resolveVariableInitializer(expression.getSourceFile(), obj.getText());
+			if (resolved && Node.isObjectLiteralExpression(resolved)) {
+				const prop = resolved.getProperty(propName);
+				if (prop && Node.isPropertyAssignment(prop)) {
+					const propInit = prop.getInitializer();
+					if (propInit) return parseExpression(propInit);
+				}
+			}
+			throw new UnresolvedConstantReferenceError(expression.getText());
+		}
+		return expression.getText();
+	} else if (Node.isIdentifier(expression)) {
+		const resolved = resolveVariableInitializer(expression.getSourceFile(), expression.getText());
+		if (resolved && isResolvableLiteral(resolved)) return parseExpression(resolved);
+		return expression.getText();
+	} else return expression.getText();
 }
 function parseNestedObject(objectLiteral) {
 	const result = {};
@@ -2069,7 +3037,7 @@ function parseNestedObject(objectLiteral) {
 			if (initializer) result[name] = parseExpression(initializer);
 		}
 	} catch (error) {
-		console.warn(`Warning: Could not parse nested object: ${error.message}`);
+		logger.warn(`Could not parse nested object: ${error.message}`);
 		return result;
 	}
 	return result;
@@ -2080,7 +3048,7 @@ function parseArrayLiteral(arrayLiteral) {
 		const elements = arrayLiteral.getElements();
 		for (const element of elements) result.push(parseExpression(element));
 	} catch (error) {
-		console.warn(`Warning: Could not parse array literal: ${error.message}`);
+		logger.warn(`Could not parse array literal: ${error.message}`);
 	}
 	return result;
 }
@@ -2113,7 +3081,8 @@ function parseDecoratorArgs(decorator) {
 		}
 		return result;
 	} catch (error) {
-		console.warn(`Warning: Could not parse decorator arguments: ${error.message}`);
+		if (error instanceof UnresolvedConstantReferenceError) throw error;
+		logger.warn(`Could not parse decorator arguments: ${error.message}`);
 		return result;
 	}
 }
@@ -2142,11 +3111,15 @@ function extractAttributesFromSource(sourceFile, className) {
 			attributes.push(attribute);
 		}
 	} catch (error) {
-		console.warn(`Warning: Could not extract attributes from class ${className}: ${error.message}`);
+		if (error instanceof UnresolvedConstantReferenceError) throw error;
+		logger.warn(`Could not extract attributes from class ${className}: ${error.message}`);
 	}
 	return attributes;
 }
-function extractRegionDefinitionsFromSource(sourceFile, className) {
+function normalizeComponentTypeId(typeId, defaultGroup) {
+	return typeId.includes(".") ? typeId : `${defaultGroup}.${typeId}`;
+}
+function extractRegionDefinitionsFromSource(sourceFile, className, defaultComponentGroup = DEFAULT_COMPONENT_GROUP) {
 	const regionDefinitions = [];
 	try {
 		const classDeclaration = sourceFile.getClass(className);
@@ -2165,8 +3138,8 @@ function extractRegionDefinitionsFromSource(sourceFile, className) {
 							name: regionConfig.name || "Region"
 						};
 						if (regionConfig.componentTypes) regionDefinition.component_types = regionConfig.componentTypes;
-						if (Array.isArray(regionConfig.componentTypeInclusions)) regionDefinition.component_type_inclusions = regionConfig.componentTypeInclusions.map((incl) => ({ type_id: incl }));
-						if (Array.isArray(regionConfig.componentTypeExclusions)) regionDefinition.component_type_exclusions = regionConfig.componentTypeExclusions.map((excl) => ({ type_id: excl }));
+						if (Array.isArray(regionConfig.componentTypeInclusions)) regionDefinition.component_type_inclusions = regionConfig.componentTypeInclusions.map((incl) => ({ type_id: normalizeComponentTypeId(String(incl), defaultComponentGroup) }));
+						if (Array.isArray(regionConfig.componentTypeExclusions)) regionDefinition.component_type_exclusions = regionConfig.componentTypeExclusions.map((excl) => ({ type_id: normalizeComponentTypeId(String(excl), defaultComponentGroup) }));
 						if (regionConfig.maxComponents !== void 0) regionDefinition.max_components = regionConfig.maxComponents;
 						if (regionConfig.minComponents !== void 0) regionDefinition.min_components = regionConfig.minComponents;
 						if (regionConfig.allowMultiple !== void 0) regionDefinition.allow_multiple = regionConfig.allowMultiple;
@@ -2177,7 +3150,7 @@ function extractRegionDefinitionsFromSource(sourceFile, className) {
 			}
 		}
 	} catch (error) {
-		console.warn(`Warning: Could not extract region definitions from class ${className}: ${error.message}`);
+		logger.warn(`Warning: Could not extract region definitions from class ${className}: ${error.message}`);
 	}
 	return regionDefinitions;
 }
@@ -2198,12 +3171,13 @@ async function processComponentFile(filePath, _projectRoot) {
 				const className = classDeclaration.getName();
 				if (!className) continue;
 				const componentConfig = parseDecoratorArgs(componentDecorator);
+				const componentGroup = String(componentConfig.group || DEFAULT_COMPONENT_GROUP);
 				const attributes = extractAttributesFromSource(sourceFile, className);
-				const regionDefinitions = extractRegionDefinitionsFromSource(sourceFile, className);
+				const regionDefinitions = extractRegionDefinitionsFromSource(sourceFile, className, componentGroup);
 				const componentMetadata = {
 					typeId: componentConfig.id || className.toLowerCase(),
 					name: componentConfig.name || toHumanReadableName(className),
-					group: componentConfig.group || DEFAULT_COMPONENT_GROUP,
+					group: componentGroup,
 					description: componentConfig.description || `Custom component: ${className}`,
 					regionDefinitions,
 					attributes
@@ -2211,11 +3185,13 @@ async function processComponentFile(filePath, _projectRoot) {
 				components.push(componentMetadata);
 			}
 		} catch (error) {
-			console.warn(`Warning: Could not process file ${filePath}:`, error.message);
+			if (error instanceof UnresolvedConstantReferenceError) throw error;
+			logger.warn(`Could not process file ${filePath}:`, error.message);
 		}
 		return components;
 	} catch (error) {
-		console.warn(`Warning: Could not read file ${filePath}:`, error.message);
+		if (error instanceof UnresolvedConstantReferenceError) throw error;
+		logger.warn(`Could not read file ${filePath}:`, error.message);
 		return [];
 	}
 }
@@ -2251,11 +3227,11 @@ async function processPageTypeFile(filePath, projectRoot) {
 				pageTypes.push(pageTypeMetadata);
 			}
 		} catch (error) {
-			console.warn(`Warning: Could not process file ${filePath}:`, error.message);
+			logger.warn(`Could not process file ${filePath}:`, error.message);
 		}
 		return pageTypes;
 	} catch (error) {
-		console.warn(`Warning: Could not read file ${filePath}:`, error.message);
+		logger.warn(`Could not read file ${filePath}:`, error.message);
 		return [];
 	}
 }
@@ -2278,11 +3254,11 @@ async function processAspectFile(filePath, _projectRoot) {
 			};
 			aspects.push(aspectMetadata);
 		} catch (parseError) {
-			console.warn(`Warning: Could not parse JSON in file ${filePath}:`, parseError.message);
+			logger.warn(`Could not parse JSON in file ${filePath}:`, parseError.message);
 		}
 		return aspects;
 	} catch (error) {
-		console.warn(`Warning: Could not read file ${filePath}:`, error.message);
+		logger.warn(`Could not read file ${filePath}:`, error.message);
 		return [];
 	}
 }
@@ -2311,7 +3287,7 @@ async function generateComponentCartridge(component, outputDir, dryRun = false)
 		await writeFile(outputPath, JSON.stringify(cartridgeData, null, 2));
 	}
 	const prefix = dryRun ? "   - [DRY RUN]" : "   -";
-	console.log(`${prefix} ${String(component.typeId)}: ${String(component.name)} (${String(component.attributes.length)} attributes) → ${fileName}.json`);
+	logger.debug(`${prefix} ${String(component.typeId)}: ${String(component.name)} (${String(component.attributes.length)} attributes) → ${fileName}.json`);
 }
 async function generatePageTypeCartridge(pageType, outputDir, dryRun = false) {
 	const fileName = toCamelCaseFileName(pageType.name);
@@ -2334,7 +3310,7 @@ async function generatePageTypeCartridge(pageType, outputDir, dryRun = false) {
 		await writeFile(outputPath, JSON.stringify(cartridgeData, null, 2));
 	}
 	const prefix = dryRun ? "   - [DRY RUN]" : "   -";
-	console.log(`${prefix} ${String(pageType.name)}: ${String(pageType.description)} (${String(pageType.attributes.length)} attributes) → ${fileName}.json`);
+	logger.debug(`${prefix} ${String(pageType.name)}: ${String(pageType.description)} (${String(pageType.attributes.length)} attributes) → ${fileName}.json`);
 }
 async function generateAspectCartridge(aspect, outputDir, dryRun = false) {
 	const fileName = toCamelCaseFileName(aspect.id);
@@ -2350,7 +3326,7 @@ async function generateAspectCartridge(aspect, outputDir, dryRun = false) {
 		await writeFile(outputPath, JSON.stringify(cartridgeData, null, 2));
 	}
 	const prefix = dryRun ? "   - [DRY RUN]" : "   -";
-	console.log(`${prefix} ${String(aspect.name)}: ${String(aspect.description)} (${String(aspect.attributeDefinitions.length)} attributes) → ${fileName}.json`);
+	logger.debug(`${prefix} ${String(aspect.name)}: ${String(aspect.description)} (${String(aspect.attributeDefinitions.length)} attributes) → ${fileName}.json`);
 }
 /**
 * Runs ESLint with --fix on the specified directory to format JSON files.
@@ -2358,20 +3334,20 @@ async function generateAspectCartridge(aspect, outputDir, dryRun = false) {
 */
 function lintGeneratedFiles(metadataDir, projectRoot) {
 	try {
-		console.log("🔧 Running ESLint --fix on generated JSON files...");
+		logger.debug("🔧 Running ESLint --fix on generated JSON files...");
 		execSync(`npx eslint "${metadataDir}/**/*.json" --fix --no-error-on-unmatched-pattern`, {
 			cwd: projectRoot,
 			stdio: "pipe",
 			encoding: "utf-8"
 		});
-		console.log("✅ JSON files formatted successfully");
+		logger.debug("✅ JSON files formatted successfully");
 	} catch (error) {
 		const execError = error;
 		if (execError.status === 2) {
 			const errMsg = execError.stderr || execError.stdout || "Unknown error";
-			console.warn(`⚠️  Warning: Could not run ESLint --fix: ${errMsg}`);
-		} else if (execError.stderr && execError.stderr.includes("error")) console.warn(`⚠️  Warning: Some linting issues could not be auto-fixed. Run ESLint manually to review.`);
-		else console.log("✅ JSON files formatted successfully");
+			logger.warn(`⚠️  Could not run ESLint --fix: ${errMsg}`);
+		} else if (execError.stderr && execError.stderr.includes("error")) logger.warn(`⚠️  Some linting issues could not be auto-fixed. Run ESLint manually to review.`);
+		else logger.debug("✅ JSON files formatted successfully");
 	}
 }
 async function generateMetadata(projectDirectory, metadataDirectory, options) {
@@ -2379,9 +3355,9 @@ async function generateMetadata(projectDirectory, metadataDirectory, options) {
 		const filePaths = options?.filePaths;
 		const isIncrementalMode = filePaths && filePaths.length > 0;
 		const dryRun = options?.dryRun || false;
-		if (dryRun) console.log("🔍 [DRY RUN] Scanning for decorated components and page types...");
-		else if (isIncrementalMode) console.log(`🔍 Generating metadata for ${filePaths.length} specified file(s)...`);
-		else console.log("🔍 Generating metadata for decorated components and page types...");
+		if (dryRun) logger.debug("🔍 [DRY RUN] Scanning for decorated components and page types...");
+		else if (isIncrementalMode) logger.debug(`🔍 Generating metadata for ${filePaths.length} specified file(s)...`);
+		else logger.debug("🔍 Generating metadata for decorated components and page types...");
 		const projectRoot = resolve(projectDirectory);
 		const srcDir = join(projectRoot, "src");
 		const metadataDir = resolve(metadataDirectory);
@@ -2390,7 +3366,7 @@ async function generateMetadata(projectDirectory, metadataDirectory, options) {
 		const aspectsOutputDir = join(metadataDir, "aspects");
 		if (!dryRun) {
 			if (!isIncrementalMode) {
-				console.log("🗑️  Cleaning existing output directories...");
+				logger.debug("🗑️  Cleaning existing output directories...");
 				for (const outputDir of [
 					componentsOutputDir,
 					pagesOutputDir,
@@ -2400,12 +3376,12 @@ async function generateMetadata(projectDirectory, metadataDirectory, options) {
 						recursive: true,
 						force: true
 					});
-					console.log(`   - Deleted: ${outputDir}`);
+					logger.debug(`   - Deleted: ${outputDir}`);
 				} catch {
-					console.log(`   - Directory not found (skipping): ${outputDir}`);
+					logger.debug(`   - Directory not found (skipping): ${outputDir}`);
 				}
-			} else console.log("📝 Incremental mode: existing cartridge files will be preserved/overwritten");
-			console.log("📁 Creating output directories...");
+			} else logger.debug("📝 Incremental mode: existing cartridge files will be preserved/overwritten");
+			logger.debug("Creating output directories...");
 			for (const outputDir of [
 				componentsOutputDir,
 				pagesOutputDir,
@@ -2416,16 +3392,18 @@ async function generateMetadata(projectDirectory, metadataDirectory, options) {
 				try {
 					await access(outputDir);
 				} catch {
-					console.error(`❌ Error: Failed to create output directory ${outputDir}: ${error.message}`);
+					const err = error;
+					logger.error(`❌ Failed to create output directory ${outputDir}: ${err.message}`);
 					process.exit(1);
+					throw err;
 				}
 			}
-		} else if (isIncrementalMode) console.log(`📝 [DRY RUN] Would process ${filePaths.length} specific file(s)`);
-		else console.log("📝 [DRY RUN] Would clean and regenerate all metadata files");
+		} else if (isIncrementalMode) logger.debug(`📝 [DRY RUN] Would process ${filePaths.length} specific file(s)`);
+		else logger.debug("📝 [DRY RUN] Would clean and regenerate all metadata files");
 		let files = [];
 		if (isIncrementalMode && filePaths) {
 			files = filePaths.map((fp) => resolve(projectRoot, fp));
-			console.log(`📂 Processing ${files.length} specified file(s)...`);
+			logger.debug(`📂 Processing ${files.length} specified file(s)...`);
 		} else {
 			const scanDirectory = async (dir) => {
 				const entries = await readdir(dir, { withFileTypes: true });
@@ -2450,7 +3428,7 @@ async function generateMetadata(projectDirectory, metadataDirectory, options) {
 			allAspects.push(...aspects);
 		}
 		if (allComponents.length === 0 && allPageTypes.length === 0 && allAspects.length === 0) {
-			console.log("⚠️  No decorated components, page types, or aspect files found.");
+			logger.info("⚠️  No decorated components, page types, or aspect files found.");
 			return {
 				componentsGenerated: 0,
 				pageTypesGenerated: 0,
@@ -2459,22 +3437,22 @@ async function generateMetadata(projectDirectory, metadataDirectory, options) {
 			};
 		}
 		if (allComponents.length > 0) {
-			console.log(`✅ Found ${allComponents.length} decorated component(s):`);
+			logger.debug(`✅ Found ${allComponents.length} decorated component(s)`);
 			for (const component of allComponents) await generateComponentCartridge(component, componentsOutputDir, dryRun);
-			if (dryRun) console.log(`📄 [DRY RUN] Would generate ${allComponents.length} component metadata file(s) in: ${componentsOutputDir}`);
-			else console.log(`📄 Generated ${allComponents.length} component metadata file(s) in: ${componentsOutputDir}`);
+			if (dryRun) logger.info(`[DRY RUN] Would generate ${allComponents.length} component metadata file(s)`);
+			else logger.info(`Generated ${allComponents.length} component metadata file(s)`);
 		}
 		if (allPageTypes.length > 0) {
-			console.log(`✅ Found ${allPageTypes.length} decorated page type(s):`);
+			logger.debug(`✅ Found ${allPageTypes.length} decorated page type(s)`);
 			for (const pageType of allPageTypes) await generatePageTypeCartridge(pageType, pagesOutputDir, dryRun);
-			if (dryRun) console.log(`📄 [DRY RUN] Would generate ${allPageTypes.length} page type metadata file(s) in: ${pagesOutputDir}`);
-			else console.log(`📄 Generated ${allPageTypes.length} page type metadata file(s) in: ${pagesOutputDir}`);
+			if (dryRun) logger.info(`[DRY RUN] Would generate ${allPageTypes.length} page type metadata file(s)`);
+			else logger.info(`Generated ${allPageTypes.length} page type metadata file(s)`);
 		}
 		if (allAspects.length > 0) {
-			console.log(`✅ Found ${allAspects.length} decorated aspect(s):`);
+			logger.debug(`✅ Found ${allAspects.length} decorated aspect(s)`);
 			for (const aspect of allAspects) await generateAspectCartridge(aspect, aspectsOutputDir, dryRun);
-			if (dryRun) console.log(`📄 [DRY RUN] Would generate ${allAspects.length} aspect metadata file(s) in: ${aspectsOutputDir}`);
-			else console.log(`📄 Generated ${allAspects.length} aspect metadata file(s) in: ${aspectsOutputDir}`);
+			if (dryRun) logger.info(`[DRY RUN] Would generate ${allAspects.length} aspect metadata file(s)`);
+			else logger.info(`Generated ${allAspects.length} aspect metadata file(s)`);
 		}
 		const shouldLintFix = options?.lintFix !== false;
 		if (!dryRun && shouldLintFix && (allComponents.length > 0 || allPageTypes.length > 0 || allAspects.length > 0)) lintGeneratedFiles(metadataDir, projectRoot);
@@ -2485,11 +3463,13 @@ async function generateMetadata(projectDirectory, metadataDirectory, options) {
 			totalFiles: allComponents.length + allPageTypes.length + allAspects.length
 		};
 	} catch (error) {
-		console.error("❌ Error:", error.message);
+		const err = error;
+		logger.error("❌ Error:", err.message);
 		process.exit(1);
+		throw err;
 	}
 }
 
 //#endregion
-export { createServer, storefrontNextTargets as default, generateMetadata, loadConfigFromEnv, loadProjectConfig, transformTargetPlaceholderPlugin, trimExtensions };
+export { clearCache, createServer, storefrontNextTargets as default, extractPatterns, generateMetadata, hybridProxyPlugin, loadConfigFromEnv, loadProjectConfig, shouldRouteToNext, testPatterns, transformTargetPlaceholderPlugin, trimExtensions };
 //# sourceMappingURL=index.js.map