@salesforce/storefront-next-dev 1.4.0-alpha.1 → 1.4.1-alpha.0

package/dist/flags2.js

@@ -0,0 +1,34 @@
+import { n as PROJECT_DIRECTORY_FLAG } from "./flags.js";
+import { n as sanitizeText } from "./sanitize.js";
+import { Command, Errors, Flags } from "@oclif/core";
+import path from "node:path";
+
+//#region src/audit/command.ts
+/** Base for the audit commands: an error's message is sanitized before oclif prints it, so a token in a `--url` stays out of the terminal. */
+var AuditCommand = class extends Command {
+	async catch(error) {
+		error.message = sanitizeText(error.message);
+		return super.catch(error);
+	}
+};
+
+//#endregion
+//#region src/audit/flags.ts
+/** A string flag that rejects an empty value (`--workspace ""` or `--workspace=`) instead of treating it as the
+* current directory. Like oclif's own parse errors, it exits 2. */
+const text = Flags.custom({ parse(value) {
+	return value ? Promise.resolve(value) : Promise.reject(new Errors.CLIError("needs a value", { exit: 2 }));
+} });
+/** `--workspace`, for the verbs that act on an existing workspace. */
+const workspaceFlag = (description, options = {}) => text({
+	...options,
+	helpValue: "<dir>",
+	description: `${description} (default: <project-directory>/.site-audit)`
+});
+/** The audit workspace: `--workspace`, else `.site-audit` in the project directory. */
+function workspaceFor(flags) {
+	return path.resolve(flags.workspace ?? path.join(flags[PROJECT_DIRECTORY_FLAG], ".site-audit"));
+}
+
+//#endregion
+export { AuditCommand as i, workspaceFlag as n, workspaceFor as r, text as t };

package/dist/generate-cartridge.js

@@ -1,5 +1,6 @@
 import { t as logger } from "./logger.js";
 import { t as formatDirectoryWithProjectBiome } from "./format-with-project-biome.js";
+import { t as importTypescript } from "./ts-import.js";
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { basename, extname, join, resolve } from "node:path";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
@@ -10,6 +11,14 @@ import { randomUUID } from "node:crypto";
 import { npmRunPathEnv } from "npm-run-path";
 
 //#region src/cartridge-services/react-router-config.ts
+const DEFAULT_PAGE_DESIGNER_PREFIXES = {
+	product: "p",
+	category: "c"
+};
+const PAGE_DESIGNER_PARAMETER_NAMES = {
+	product: "productId",
+	category: "categoryId"
+};
 let isCliAvailable = null;
 function filePathEndsWithRoute(filePath, routeFile) {
 	const routeFileNormalized = routeFile.replace(/^\.\//, "");
@@ -78,18 +87,26 @@ function getReactRouterRoutes(projectDirectory) {
 }
 /**
 * Convert a file path to its corresponding route path using React Router's CLI.
-* This ensures we get the exact same route resolution as React Router uses internally.
+* PDP/PLP paths use configured prefixes and named ID parameters for Page Designer.
 * @param filePath - Absolute path to the route file
 * @param projectRoot - The project root directory
-* @returns The route path (e.g., '/cart', '/p/*')
+* @param seoPrefixes - Optional selected site's PDP/PLP prefixes. Defaults to p/c.
+* @returns The computed Page Designer route path (e.g., '/cart', '/p/:productId')
 * @example
 * const route = filePathToRoute('/path/to/project/src/routes/_app.cart.tsx', '/path/to/project');
 * // Returns: '/cart'
 */
-function filePathToRoute(filePath, projectRoot) {
+function filePathToRoute(filePath, projectRoot, seoPrefixes) {
 	const filePathPosix = filePath.replace(/\\/g, "/");
 	const canonicalRoutes = flattenRoutes(getReactRouterRoutes(projectRoot)).filter((route) => !route.id.endsWith("--root-duplicate"));
 	for (const route of canonicalRoutes) if (routeFileMatches(filePathPosix, route.file.replace(/\\/g, "/"))) {
+		const routeFileName = route.id.split("/").at(-1);
+		const seoResource = routeFileName === "_app.p.$" ? "product" : routeFileName === "_app.c.$" ? "category" : void 0;
+		if (seoResource) {
+			const configuredPrefix = seoPrefixes?.[seoResource] ?? DEFAULT_PAGE_DESIGNER_PREFIXES[seoResource];
+			const pathSegments = (route.path ?? "").split("/").filter(Boolean);
+			return `${`/${(pathSegments.at(-1) === "*" ? pathSegments.slice(0, -2) : pathSegments).join("/")}`.replace(/\/$/, "")}/${configuredPrefix}/:${PAGE_DESIGNER_PARAMETER_NAMES[seoResource]}`.replace(/\/+/g, "/");
+		}
 		const seoAliases = canonicalRoutes.filter((candidate) => candidate.id.startsWith(`${route.id}--seo-alias--`)).sort((left, right) => left.path.localeCompare(right.path));
 		if (seoAliases.length > 0) {
 			if (seoAliases.length > 1) logger.warn(`Multiple SEO route aliases match ${filePath}; using ${seoAliases[0].path} for Page Designer metadata.`);
@@ -485,7 +502,7 @@ async function processComponentFile(filePath, _projectRoot) {
 		return [];
 	}
 }
-async function processPageTypeFile(filePath, projectRoot) {
+async function processPageTypeFile(filePath, projectRoot, seoPrefixes) {
 	try {
 		const content = await readFile(filePath, "utf-8");
 		const pageTypes = [];
@@ -504,7 +521,7 @@ async function processPageTypeFile(filePath, projectRoot) {
 				const pageTypeConfig = parseDecoratorArgs(pageTypeDecorator);
 				const attributes = extractAttributesFromSource(sourceFile, className);
 				const regionDefinitions = extractRegionDefinitionsFromSource(sourceFile, className);
-				const route = filePathToRoute(filePath, projectRoot);
+				const route = filePathToRoute(filePath, projectRoot, seoPrefixes);
 				const pageTypeMetadata = {
 					typeId: pageTypeConfig.id || className.toLowerCase(),
 					name: pageTypeConfig.name || toHumanReadableName(className),
@@ -632,6 +649,23 @@ function lintGeneratedFiles(metadataDir) {
 	logger.debug("🔧 Formatting generated JSON files with Biome...");
 	formatDirectoryWithProjectBiome(metadataDir);
 }
+function isCanonicalProductOrCategoryRouteFile(filePath, projectRoot) {
+	const relativePath = filePath.slice(projectRoot.length).replace(/\\/g, "/").replace(/^\//, "");
+	return /^src\/(?:.*\/)?routes\/_app\.(?:p|c)\.\$\.tsx$/.test(relativePath);
+}
+async function loadPageDesignerSeoPrefixes(projectRoot, requestedSiteId) {
+	const configPath = join(projectRoot, "config.server.ts");
+	if (existsSync(configPath) !== true) return void 0;
+	const app = (await importTypescript(configPath, { projectDirectory: projectRoot })).default?.app;
+	const seoRoutes = (app?.url)?.seoRoutes;
+	if (seoRoutes === void 0) return void 0;
+	const siteId = requestedSiteId ?? (typeof app?.defaultSiteId === "string" ? app.defaultSiteId : void 0);
+	const selected = siteId && Object.prototype.hasOwnProperty.call(seoRoutes, siteId) ? seoRoutes[siteId] : seoRoutes["*"];
+	return {
+		product: selected?.product?.prefix,
+		category: selected?.category?.prefix
+	};
+}
 async function generateMetadata(projectDirectory, metadataDirectory, options) {
 	try {
 		const filePaths = options?.filePaths;
@@ -706,13 +740,14 @@ async function generateMetadata(projectDirectory, metadataDirectory, options) {
 				else logger.warn(`   - Unable to access ${configMetadataDir}:`, error.message);
 			}
 		}
+		const seoPrefixes = files.some((file) => isCanonicalProductOrCategoryRouteFile(file, projectRoot)) ? await loadPageDesignerSeoPrefixes(projectRoot, options?.siteId) : void 0;
 		const allComponents = [];
 		const allPageTypes = [];
 		const allAspects = [];
 		for (const file of files) {
 			const components = await processComponentFile(file, projectRoot);
 			allComponents.push(...components);
-			const pageTypes = await processPageTypeFile(file, projectRoot);
+			const pageTypes = await processPageTypeFile(file, projectRoot, seoPrefixes);
 			allPageTypes.push(...pageTypes);
 			const aspects = await processAspectFile(file, projectRoot);
 			allAspects.push(...aspects);

package/dist/har.js

@@ -0,0 +1,205 @@
+import { z } from "zod";
+
+//#region src/audit/rule-helpers/har.ts
+const headerSchema = z.object({
+	name: z.string(),
+	value: z.string()
+}).passthrough();
+const entrySchema = z.object({
+	request: z.object({ url: z.string() }).passthrough(),
+	response: z.object({
+		status: z.number(),
+		headers: z.array(headerSchema),
+		content: z.object({
+			size: z.number().optional(),
+			mimeType: z.string().optional()
+		}).passthrough().optional()
+	}).passthrough()
+}).passthrough();
+const harSchema = z.object({ log: z.object({ entries: z.array(entrySchema) }).passthrough() }).passthrough();
+const networkSchema = z.object({ document: z.object({ url: z.string() }).passthrough() }).passthrough();
+/** Header rules read the same cell as the metric budgets. */
+const REPRESENTATIVE_CELL = "mobile-cold";
+function headerValues(entry, name) {
+	const wanted = name.toLowerCase();
+	return entry.response.headers.flatMap((item, index) => item.name.toLowerCase() === wanted ? [{
+		value: item.value,
+		index
+	}] : []);
+}
+/** A header's combined value (repeated headers joined with ", ", as HTTP defines), or null when absent. */
+function header(entry, name) {
+	const values = headerValues(entry, name);
+	return values.length ? values.map((item) => item.value).join(", ") : null;
+}
+/** Comma-separated header tokens, lowercased. */
+function tokens(value) {
+	return (value ?? "").split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+}
+function normalizedUrl(value) {
+	try {
+		const url = new URL(value);
+		url.hash = "";
+		return url.toString();
+	} catch {
+		return;
+	}
+}
+/** Finds the final document response of one Playhouse cell in its HAR, using `network-<cell>.json` for the document URL. */
+async function matchDocument(playhouse, page, cell) {
+	const harArtifact = `network-${cell}.har`;
+	const [har, network] = await Promise.all([playhouse.readJson(page, harArtifact, harSchema), playhouse.readJson(page, `network-${cell}.json`, networkSchema)]);
+	const finalUrl = network?.document.url ?? null;
+	if (!har || !finalUrl) return {
+		harArtifact,
+		finalUrl,
+		reason: "The HAR or final document identity was unavailable."
+	};
+	const expected = normalizedUrl(finalUrl);
+	const index = har.log.entries.map((entry) => normalizedUrl(entry.request.url)).lastIndexOf(expected);
+	if (index < 0) return {
+		harArtifact,
+		finalUrl,
+		reason: "The final document response could not be matched in the HAR."
+	};
+	return {
+		harArtifact,
+		finalUrl,
+		entries: har.log.entries,
+		document: {
+			entry: har.log.entries[index],
+			index
+		}
+	};
+}
+/** Successful (200) responses served from the document's own host; third-party responses are not graded. */
+function sameHostResponses(match) {
+	const host = new URL(match.finalUrl).host;
+	return match.entries.flatMap((entry, index) => {
+		try {
+			return entry.response.status === 200 && new URL(entry.request.url).host === host ? [{
+				entry,
+				index
+			}] : [];
+		} catch {
+			return [];
+		}
+	});
+}
+function resourceKind(entry) {
+	const type = (entry.response.content?.mimeType || header(entry, "content-type") || "").split(";")[0].trim().toLowerCase();
+	if (type === "text/html" || type === "application/xhtml+xml") return "html";
+	if (type.includes("javascript") || type.includes("ecmascript")) return "js";
+	if (type === "text/css") return "css";
+	if (type.startsWith("image/")) return "image";
+	if (type.startsWith("font/") || type.includes("font-")) return "font";
+	return "other";
+}
+/** `Cache-Control` directives, lowercased, with their values (`max-age=60` → `max-age` → `60`). */
+function cacheControl(entry) {
+	return new Map(tokens(header(entry, "cache-control")).map((item) => {
+		const [name, ...value] = item.split("=");
+		return [name.trim(), value.join("=").trim().replace(/^"|"$/g, "")];
+	}));
+}
+const COMPRESSED_ENCODINGS = [
+	"br",
+	"gzip",
+	"zstd"
+];
+const harRuleDataSchema = z.object({
+	cell: z.string(),
+	checked: z.array(z.object({
+		page: z.string(),
+		url: z.string(),
+		responses: z.number()
+	}).strict()),
+	failures: z.array(z.object({
+		page: z.string(),
+		url: z.string(),
+		entry: z.number(),
+		reasons: z.array(z.string()),
+		headers: z.record(z.string(), z.string().nullable())
+	}).strict()),
+	skipped: z.array(z.object({
+		page: z.string(),
+		reason: z.string()
+	}).strict())
+}).strict();
+const MAX_FAILURE_EVIDENCE = 10;
+/**
+* A rule script that runs `check` on each page's representative HAR. It fails when any response fails, passes when every
+* checked response passes, and leaves the rule undecided when no page could be checked or no response was eligible.
+* `passed` completes the pass summary ("All 12 <subject> checked on home <passed>.").
+*/
+function harRule(subject, check, passed = "passed") {
+	return async ({ pages, playhouse }) => {
+		const data = {
+			cell: REPRESENTATIVE_CELL,
+			checked: [],
+			failures: [],
+			skipped: []
+		};
+		const documents = [];
+		for (const page of pages) {
+			const match = await matchDocument(playhouse, page.label, REPRESENTATIVE_CELL);
+			if ("reason" in match) {
+				data.skipped.push({
+					page: page.label,
+					reason: match.reason
+				});
+				continue;
+			}
+			const result = check(match);
+			data.checked.push({
+				page: page.label,
+				url: match.finalUrl,
+				responses: result.responses
+			});
+			data.failures.push(...result.failures.map((failure) => ({
+				page: page.label,
+				url: failure.entry.entry.request.url,
+				entry: failure.entry.index,
+				reasons: failure.reasons,
+				headers: failure.headers
+			})));
+			documents.push({
+				type: "playhouse",
+				page: page.label,
+				artifact: match.harArtifact,
+				pointer: `/log/entries/${match.document.index}/request/url`,
+				value: match.finalUrl
+			});
+		}
+		const responses = data.checked.reduce((total, item) => total + item.responses, 0);
+		if (!responses) return { data };
+		const pageList = data.checked.map((item) => item.page).join(", ");
+		if (!data.failures.length) return {
+			data,
+			decision: {
+				status: "pass",
+				summary: `All ${responses} ${subject} checked on ${pageList} ${passed}.`,
+				evidence: documents
+			}
+		};
+		const harArtifact = `network-${REPRESENTATIVE_CELL}.har`;
+		const reasons = [...new Set(data.failures.flatMap((failure) => failure.reasons))];
+		return {
+			data,
+			decision: {
+				status: "fail",
+				summary: `${data.failures.length} of ${responses} ${subject} failed: ${reasons.slice(0, 3).join(" ")}${reasons.length > 3 ? ` (+${reasons.length - 3} more)` : ""}`,
+				evidence: data.failures.slice(0, MAX_FAILURE_EVIDENCE).map((failure) => ({
+					type: "playhouse",
+					page: failure.page,
+					artifact: harArtifact,
+					pointer: `/log/entries/${failure.entry}/response/headers`,
+					value: `${failure.url}: ${failure.reasons.join(" ")}`
+				}))
+			}
+		};
+	};
+}
+
+//#endregion
+export { harRuleDataSchema as a, matchDocument as c, sameHostResponses as d, tokens as f, harRule as i, normalizedUrl as l, REPRESENTATIVE_CELL as n, header as o, cacheControl as r, headerValues as s, COMPRESSED_ENCODINGS as t, resourceKind as u };

package/dist/images.js

@@ -0,0 +1,146 @@
+import { z } from "zod";
+
+//#region src/audit/rule-helpers/images.ts
+/**
+* Image rules read the mobile cold-cache median run: its own HAR and Lighthouse result, so request timings line up with
+* the LCP that `summary-lcp.json` reports for that run.
+*/
+const CELL = {
+	formFactor: "mobile",
+	cacheState: "cold"
+};
+/** Savings smaller than this aren't worth a suggestion. */
+const MIN_SAVINGS_BYTES = 10 * 1024;
+const lcpSummarySchema = z.object({ cells: z.array(z.object({
+	formFactor: z.string(),
+	cacheState: z.string(),
+	median: z.object({
+		runId: z.string(),
+		lcp: z.number().nullable().optional(),
+		breakdown: z.record(z.string(), z.number().nullable()).nullable().optional(),
+		resource: z.object({ url: z.string() }).passthrough().nullable().optional()
+	}).passthrough().nullable().optional()
+}).passthrough()) }).passthrough();
+const entrySchema = z.object({
+	_requestTime: z.number().optional(),
+	_priority: z.string().optional(),
+	_initialPriority: z.string().optional(),
+	_resourceType: z.string().optional(),
+	_initiator_type: z.string().optional(),
+	_renderBlocking: z.string().optional(),
+	time: z.number(),
+	request: z.object({
+		url: z.string(),
+		_isLinkPreload: z.boolean().optional()
+	}).passthrough(),
+	response: z.object({
+		status: z.number(),
+		bodySize: z.number().optional(),
+		content: z.object({
+			size: z.number().optional(),
+			mimeType: z.string().optional()
+		}).passthrough().optional()
+	}).passthrough()
+}).passthrough();
+const harSchema = z.object({ log: z.object({ entries: z.array(entrySchema) }).passthrough() }).passthrough();
+const rectSchema = z.object({
+	top: z.number(),
+	width: z.number(),
+	height: z.number()
+}).passthrough();
+const nodeSchema = z.object({
+	path: z.string().optional(),
+	selector: z.string().optional(),
+	nodeLabel: z.string().optional(),
+	snippet: z.string().optional(),
+	boundingRect: rectSchema.optional()
+}).passthrough();
+const tableItem = z.record(z.string(), z.unknown());
+const audit = (details) => z.object({
+	score: z.number().nullable().optional(),
+	numericValue: z.number().optional(),
+	metricSavings: z.record(z.string(), z.number()).optional(),
+	details: details.optional()
+}).passthrough().optional();
+const lhrSchema = z.object({
+	configSettings: z.object({ screenEmulation: z.object({
+		deviceScaleFactor: z.number(),
+		height: z.number()
+	}).passthrough() }).passthrough(),
+	audits: z.object({
+		"image-delivery-insight": audit(z.object({ items: z.array(z.object({
+			url: z.string(),
+			totalBytes: z.number(),
+			wastedBytes: z.number(),
+			node: nodeSchema.optional(),
+			subItems: z.object({ items: z.array(z.object({
+				reason: z.string(),
+				wastedBytes: z.number()
+			}).passthrough()) }).passthrough().optional()
+		}).passthrough()).optional() }).passthrough()),
+		"lcp-discovery-insight": audit(z.object({ items: z.array(tableItem).optional() }).passthrough()),
+		"unsized-images": audit(z.object({ items: z.array(z.object({
+			url: z.string().optional(),
+			node: nodeSchema.optional()
+		}).passthrough()).optional() }).passthrough()),
+		"cls-culprits-insight": audit(z.object({ items: z.array(tableItem).optional() }).passthrough()),
+		"render-blocking-insight": audit(z.object({ items: z.array(z.object({ url: z.string() }).passthrough()).optional() }).passthrough()),
+		"cumulative-layout-shift": audit(z.unknown())
+	}).passthrough()
+}).passthrough();
+/** The mobile cold-cache median run of one page, or why it can't be read. */
+async function readImageRun(playhouse, page) {
+	const median = (await playhouse.readJson(page, "summary-lcp.json", lcpSummarySchema))?.cells.find((cell) => cell.formFactor === CELL.formFactor && cell.cacheState === CELL.cacheState)?.median;
+	if (!median) return { reason: "summary-lcp.json has no mobile cold-cache median run." };
+	const harArtifact = `runs/${median.runId}/network.har`;
+	const lighthouseArtifact = `runs/${median.runId}/lhr.json`;
+	const [har, lhr] = await Promise.all([playhouse.readJson(page, harArtifact, harSchema), playhouse.readJson(page, lighthouseArtifact, lhrSchema)]);
+	if (!har || !lhr) return { reason: `The median run's ${har ? "Lighthouse result" : "HAR"} was not archived.` };
+	const entries = har.log.entries;
+	const origin = Math.min(...entries.map((entry) => entry._requestTime ?? Infinity));
+	return {
+		page,
+		runId: median.runId,
+		harArtifact,
+		lighthouseArtifact,
+		entries,
+		lhr,
+		dpr: lhr.configSettings.screenEmulation.deviceScaleFactor,
+		viewportHeight: lhr.configSettings.screenEmulation.height,
+		lcpMs: median.lcp ?? null,
+		lcpBreakdown: median.breakdown ?? {},
+		lcpUrl: median.resource?.url ?? null,
+		startMs: (entry) => entry._requestTime === void 0 || !Number.isFinite(origin) ? NaN : Math.round((entry._requestTime - origin) * 1e3)
+	};
+}
+const kib = (bytes) => `${Math.round(bytes / 1024)} KiB`;
+/** Bytes an entry downloaded during [start, end] seconds, assuming it downloaded at an even rate. */
+function bytesDuring(entry, start, end) {
+	const from = entry._requestTime;
+	const bytes = entry.response.bodySize ?? 0;
+	if (from === void 0 || bytes <= 0) return 0;
+	const to = from + entry.time / 1e3;
+	const overlap = Math.min(to, end) - Math.max(from, start);
+	return overlap > 0 ? Math.round(bytes * overlap / Math.max(to - from, .001)) : 0;
+}
+const isImage = (entry) => entry._resourceType === "image" || (entry.response.content?.mimeType ?? "").startsWith("image/");
+/** A URL's file name without its query, for readable summaries. */
+function fileName(url) {
+	try {
+		return decodeURIComponent(new URL(url).pathname.split("/").pop() || url);
+	} catch {
+		return url;
+	}
+}
+/** URL without its query string, to match the same image requested at different sizes. */
+function withoutQuery(url) {
+	try {
+		const parsed = new URL(url);
+		return `${parsed.origin}${parsed.pathname}`;
+	} catch {
+		return url;
+	}
+}
+
+//#endregion
+export { kib as a, isImage as i, bytesDuring as n, readImageRun as o, fileName as r, withoutQuery as s, MIN_SAVINGS_BYTES as t };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/plugins/pageDesignerPreloadManifest.ts","../src/plugins/staticRegistry.ts","../src/plugins/eventInstrumentationValidator.ts","../src/storefront-next-targets.ts","../src/plugins/transformTargets.ts","../src/plugins/uiTargetDevMode.ts","../src/plugins/hybridProxy.ts","../src/plugins/ecdnMatcher.ts"],"sourcesContent":[],"mappings":";;;;;AI6BgB,UJGC,iCAAA,CIOc;;;;;;;AGuG/B;;;UN3EiB,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA+Be;;;;;AE3DhC;AAkEA;;UD/EiB,mCAAA;;AEGjB;;;;ECHiB;AA4BjB;;;;ECOiB;AAyZjB;;;;ACxUA;;;;;;;AHjHgB,UDUC,2BAAA,CCV+B;;;;ACHhD;AA4BA;;;;ACOA;AAyZA;;;;ACxUA;;;;;;;;;;;;;;;;;;;mBJrEqB;;;;;;;;;kCAUe;;;;;;;;;;;;;;;;;;;;;iBAsBpB,qBAAA,UAA8B,8BAAmC;;;iBC5EjE,gCAAA,CAAA;;;EJGC,cAAA,CAAA,MAAA,EIOc,cJPmB,CAAA,EAAA,IAAA;;;;ICmCjC,GAAA,EAAA,IAAA;;;;;AE5BjB;AAkEA;;;;AC5EA;;;;ACHiB,UAAA,qBAAA,CAcH;EAcE;;;;ECOC;AAyZjB;;;;ACxUA;;YFtGc;;;;;;;;;;;;;iBAcE,qBAAA,WAAgC,wBAAwB;;;;UCOvD,wBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyZD,iBAAA,UAA2B,2BAA2B;;;;;;;;;;;;;;;;;;;;;;iBCxUtD,iBAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/plugins/pageDesignerPreloadManifest.ts","../src/plugins/staticRegistry.ts","../src/plugins/eventInstrumentationValidator.ts","../src/storefront-next-targets.ts","../src/plugins/transformTargets.ts","../src/plugins/uiTargetDevMode.ts","../src/plugins/hybridProxy.ts","../src/plugins/ecdnMatcher.ts"],"sourcesContent":[],"mappings":";;;;;AI6BgB,UJGC,iCAAA,CIOc;;;;;;;AGuG/B;;;UN3EiB,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA+Be;;;;;AE3DhC;AAkEA;;UD/EiB,mCAAA;;AEGjB;;;;ECHiB;AA4BjB;;;;ECOiB;AAyZjB;;;;ACxUA;;;;;;;AHjHgB,UDUC,2BAAA,CCV+B;;;;ACHhD;AA4BA;;;;ACOA;AAyZA;;;;ACxUA;;;;;;;;;;;;;;;;;;;mBJrEqB;;;;;;;;;kCAUe;;;;;;;;;;;;;;;;;;;;;iBAsBpB,qBAAA,UAA8B,8BAAmC;;;iBC5EjE,gCAAA,CAAA;;;EJGC,cAAA,CAAA,MAAA,EIOc,cJPmB,CAAA,EAAA,IAAA;;;;ICmCjC,GAAA,EAAA,IAAA;;;;;AE5BjB;AAkEA;;;;AC5EA;;;;ACHiB,UAAA,qBAAA,CAAqB;EA4BtB;;;;ECOC;AAyZjB;;;;ACxUA;;YFtGc;;;;;;;;;;;;;iBAcE,qBAAA,WAAgC,wBAAwB;;;;UCOvD,wBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyZD,iBAAA,UAA2B,2BAA2B;;;;;;;;;;;;;;;;;;;;;;iBCxUtD,iBAAA"}