@salesforce/storefront-next-dev 1.0.1 → 1.1.0-alpha.1

package/dist/commands/config/aggregate-extensions.js

@@ -0,0 +1,279 @@
+import { t as logger } from "../../logger.js";
+import "../../logger2.js";
+import { r as commonFlags } from "../../flags.js";
+import { t as GENERATED_EXTENSION_DIRS } from "../../constants.js";
+import { Command, Flags } from "@oclif/core";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { mkdir, readFile, readdir, writeFile } from "fs/promises";
+import { parse } from "@babel/parser";
+
+//#region src/config/aggregate-extension-config.ts
+/** Apache License 2.0 header text for generated files. Inlined to avoid path resolution issues in standalone projects. */
+const APACHE_LICENSE_HEADER = [
+	`Copyright ${(/* @__PURE__ */ new Date()).getFullYear()} Salesforce, Inc.`,
+	"",
+	"Licensed under the Apache License, Version 2.0 (the \"License\");",
+	"you may not use this file except in compliance with the License.",
+	"You may obtain a copy of the License at",
+	"",
+	"    http://www.apache.org/licenses/LICENSE-2.0",
+	"",
+	"Unless required by applicable law or agreed to in writing, software",
+	"distributed under the License is distributed on an \"AS IS\" BASIS,",
+	"WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.",
+	"See the License for the specific language governing permissions and",
+	"limitations under the License."
+].join("\n");
+const OUTPUT_DIR_NAME = GENERATED_EXTENSION_DIRS.config;
+const LOCALES_DIR_NAME = GENERATED_EXTENSION_DIRS.locales;
+/**
+* A camelCased folder name is only usable as a config key if it is also a plain JS identifier:
+* a leading letter followed by letters or digits. Folder names that camelCase to anything else
+* (a dot, a leading digit, an empty string) would emit a barrel that fails to parse.
+*/
+const VALID_CONFIG_KEY = /^[a-zA-Z][a-zA-Z0-9]*$/;
+const CLIENT_MODE = {
+	sourceFileName: "config.ts",
+	outputFileName: "index.ts",
+	barrelFooterComment: [
+		"// Each extension's config.ts default export is namespaced by the camelCase of its folder",
+		"// name (e.g. loqate-address-verification -> loqateAddressVerification), making it available",
+		"// at config.app.extension.<key> and overridable via PUBLIC__app__extension__<key>__<setting>."
+	].join("\n")
+};
+const SERVER_MODE = {
+	sourceFileName: "server-config.ts",
+	outputFileName: "server.ts",
+	barrelFooterComment: [
+		"// Each extension's server-config.ts default export is namespaced by the camelCase of its",
+		"// folder name (e.g. loqate-address-verification -> loqateAddressVerification), making it",
+		"// available at config.app.serverExtension.<key> on the server only. Values never reach the",
+		"// browser: the client extractor strips app.serverExtension before window.__APP_CONFIG__,",
+		"// and a Vite plugin fails the build if any client chunk imports this barrel. There is no",
+		"// PUBLIC__ override path by design — the AST validator forbids process.env, so server-only",
+		"// secrets must be read from process.env in a route handler instead."
+	].join("\n")
+};
+function getDefaultDirs(projectDirectory) {
+	const extensionsDir = join(projectDirectory, "src", "extensions");
+	return {
+		EXTENSIONS_DIR: extensionsDir,
+		OUTPUT_DIR: join(extensionsDir, OUTPUT_DIR_NAME)
+	};
+}
+/** Convert kebab-case to PascalCase (e.g. `store-locator` → `StoreLocator`). */
+function toPascalCase(str) {
+	return str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/**
+* Convert a kebab-case extension folder name to the camelCase key it occupies under
+* `app.extension` (e.g. `loqate-address-verification` → `loqateAddressVerification`). This
+* is the key merchants reference as `PUBLIC__app__extension__<key>__<setting>`.
+*/
+function toCamelCase(str) {
+	const pascal = toPascalCase(str);
+	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+/** Value node types allowed inside a config object: static data only, no computed expressions. */
+const STATIC_VALUE_TYPES = new Set([
+	"StringLiteral",
+	"NumericLiteral",
+	"BooleanLiteral",
+	"NullLiteral",
+	"ArrayExpression",
+	"ObjectExpression",
+	"TSAsExpression"
+]);
+/**
+* Assert an extension's config module is a static, default-exported object literal — and nothing
+* more. Generated barrels import each module as a live ES module, evaluated at build, typegen,
+* `pnpm dev`, and server startup; since extensions are third-party and distributable, any
+* top-level statement (an import, a `fetch`, a `process.env` read) would run arbitrary vendor
+* code in those contexts and could leak secrets into the client bundle. Validating the shape
+* at discovery time turns that supply-chain risk into a clear build-time error. The same rule
+* applies to both client `config.ts` and server `server-config.ts` — the server barrel is
+* structurally fenced from the client, but a vendor calling out to a network or reading env
+* at module-eval time is still a build-time hazard we don't want to inherit.
+*/
+function assertStaticConfigModule(filePath, source) {
+	const reject = (reason) => {
+		throw new Error(`Extension config "${filePath}" must default-export a plain object of static values. ${reason} Config files are imported as live modules at build and server startup, so they may not import, call functions, or read process.env. Move dynamic/server-only values to a route handler.`);
+	};
+	const ast = parse(source, {
+		sourceType: "module",
+		plugins: ["typescript"]
+	});
+	let declaration;
+	for (const node of ast.program.body) if (node.type === "ExportDefaultDeclaration") declaration = node.declaration;
+	else if (node.type !== "EmptyStatement") reject(`Found a top-level \`${node.type}\` (only \`export default { … }\` is allowed).`);
+	if (!declaration) {
+		reject("No default export found.");
+		return;
+	}
+	const unwrap = (n) => n.type === "TSAsExpression" && n.expression ? n.expression : n;
+	const assertStaticValue = (node) => {
+		const v = unwrap(node);
+		if (!STATIC_VALUE_TYPES.has(v.type)) reject(`Found a non-static \`${v.type}\` value.`);
+		if (v.type === "ObjectExpression") for (const prop of v.properties ?? []) {
+			if (prop.type !== "ObjectProperty") reject(`Found a \`${prop.type}\` (spreads and methods are not allowed).`);
+			if (prop.value) assertStaticValue(prop.value);
+		}
+		else if (v.type === "ArrayExpression") {
+			for (const el of v.elements ?? []) if (el) assertStaticValue(el);
+		}
+	};
+	assertStaticValue(unwrap(declaration));
+}
+/**
+* Find every extension folder that ships the mode's source file. The output `config/`
+* directory and the locale aggregator's `locales/` directory are siblings of real
+* extensions, so both are skipped. Each discovered file is validated as a static object
+* literal before it joins the list (see `assertStaticConfigModule`). Results are sorted
+* by folder name for stable output.
+*
+* Imports in the generated barrel target the source file's basename without extension —
+* `../<ext>/config` for client, `../<ext>/server-config` for server. The server barrel
+* sits alongside the client barrel in `src/extensions/config/`, so both barrels resolve
+* extension paths through the same `../` parent.
+*/
+async function findExtensionsWithConfigByMode(extensionsDir, mode) {
+	const extensions = [];
+	const importBasename = mode.sourceFileName.replace(/\.ts$/, "");
+	try {
+		const entries = await readdir(extensionsDir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isDirectory() || entry.name === OUTPUT_DIR_NAME || entry.name === LOCALES_DIR_NAME) continue;
+			const sourcePath = join(extensionsDir, entry.name, mode.sourceFileName);
+			if (existsSync(sourcePath)) {
+				assertStaticConfigModule(`${entry.name}/${mode.sourceFileName}`, await readFile(sourcePath, "utf8"));
+				extensions.push({
+					name: entry.name,
+					path: `../${entry.name}/${importBasename}`
+				});
+			}
+		}
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return extensions.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+* Build the barrel that re-exports each extension's config default under its camelCase key.
+* Imports are widened (no `as const`) so the merged `app.extension` / `app.serverExtension`
+* type stays mutable and a value like `apiKey: ''` types as `string`, not the literal `''`.
+*
+* Throws if two folders collapse to the same camelCase key — config feeds runtime values
+* like API keys, so a silent last-wins could route a setting to the wrong extension.
+*/
+function generateBarrelByMode(extensions, mode) {
+	const header = `${`/**\n${APACHE_LICENSE_HEADER.split("\n").map((line) => line ? ` * ${line}` : " *").join("\n")}\n */`}
+
+// NOTE: This file is auto-generated. Do not edit manually.
+// Run 'pnpm config:aggregate-extensions' to regenerate this file.
+
+`;
+	if (extensions.length === 0) return `${header}// No extension config files found\nexport default {};\n`;
+	const keyByExtension = /* @__PURE__ */ new Map();
+	for (const ext of extensions) {
+		const key = toCamelCase(ext.name);
+		if (ext.name.includes("_")) throw new Error(`Extension folder "${ext.name}" uses underscores. Use hyphens so the name camelCases to the expected config key (e.g. "store-locator" → "storeLocator", not "store_locator").`);
+		if (!VALID_CONFIG_KEY.test(key)) throw new Error(`Extension folder "${ext.name}" maps to an invalid config key "${key}". Use a folder name of letters, digits, and hyphens that starts with a letter (e.g. "loqate-address-verification" → "loqateAddressVerification").`);
+		const existing = keyByExtension.get(key);
+		if (existing) throw new Error(`Extension config key collision: "${existing}" and "${ext.name}" both map to "${key}". Rename one extension folder so each resolves to a distinct config namespace.`);
+		keyByExtension.set(key, ext.name);
+	}
+	const imports = extensions.map((ext) => `import ${toCamelCase(ext.name)}Config from '${ext.path}';`).join("\n");
+	const exports = extensions.map((ext) => {
+		const key = toCamelCase(ext.name);
+		return `    ${key}: ${key}Config,`;
+	}).join("\n");
+	return `${header}${imports}
+
+${mode.barrelFooterComment}
+export default {
+${exports}
+};
+`;
+}
+/**
+* Discover every extension's source file under the given mode and write the matching barrel
+* if its content has changed. Skipping the write when content is unchanged keeps the Vite
+* watcher quiet — a no-op rewrite would touch the file's mtime and trigger a self-induced
+* reload loop on every `pnpm dev` prestep.
+*/
+async function aggregateByMode(options, mode) {
+	const { projectDirectory = process.cwd(), silent = false } = options;
+	const { OUTPUT_DIR, EXTENSIONS_DIR } = options.dirs ?? getDefaultDirs(projectDirectory);
+	const log = (message, ...args) => {
+		if (!silent) logger.debug(message, ...args);
+	};
+	try {
+		log(`🔍 Scanning for extension ${mode.sourceFileName} files...`);
+		const extensions = await findExtensionsWithConfigByMode(EXTENSIONS_DIR, mode);
+		const content = generateBarrelByMode(extensions, mode);
+		await mkdir(OUTPUT_DIR, { recursive: true });
+		const filePath = join(OUTPUT_DIR, mode.outputFileName);
+		if (await readFile(filePath, "utf8").catch(() => null) !== content) await writeFile(filePath, content, "utf8");
+		log(`✅ Generated: src/extensions/config/${mode.outputFileName} (${extensions.length} extension(s))`);
+		return {
+			extensions: extensions.map((ext) => toCamelCase(ext.name)),
+			filePath
+		};
+	} catch (error) {
+		if (!silent) logger.error(`❌ Error generating extension ${mode.outputFileName}: ${String(error)}`);
+		throw error;
+	}
+}
+/**
+* Discover every extension's `config.ts` AND `server-config.ts` and regenerate both barrels:
+* `src/extensions/config/index.ts` (merged into `app.extension`, reaches the client) and
+* `src/extensions/config/server.ts` (merged into `app.serverExtension`, server-only — the
+* loader strips it before React Router serializes the hydration payload, and a Vite plugin
+* fails the build if any client chunk imports the server barrel).
+*
+* Runs both modes in parallel: the source files are distinct (`config.ts` vs
+* `server-config.ts`), the output files are distinct (`index.ts` vs `server.ts`), and each
+* mode does its own mtime-aware write — there's no shared state between them. Folding both
+* into one CLI invocation closes a class of footgun where a contributor regenerates one
+* barrel but not the other and ships an inconsistent `app.extension` / `app.serverExtension`
+* pair (see PR #1964 review).
+*
+* Used as the `sfnext config aggregate-extensions` build prestep (mirrors `sfnext locales
+* aggregate-extensions`).
+*/
+async function aggregateExtensionConfig(options = {}) {
+	const [client, server] = await Promise.all([aggregateByMode(options, CLIENT_MODE), aggregateByMode(options, SERVER_MODE)]);
+	return {
+		client,
+		server
+	};
+}
+
+//#endregion
+//#region src/commands/config/aggregate-extensions.ts
+var AggregateExtensions = class AggregateExtensions extends Command {
+	static description = "Aggregate extension config.ts and server-config.ts files into the app.extension and app.serverExtension barrels";
+	static examples = [
+		"<%= config.bin %> <%= command.id %>",
+		"<%= config.bin %> <%= command.id %> -d ./my-project",
+		"<%= config.bin %> <%= command.id %> --silent"
+	];
+	static flags = {
+		...commonFlags,
+		silent: Flags.boolean({
+			description: "Suppress output",
+			default: false
+		})
+	};
+	async run() {
+		const { flags } = await this.parse(AggregateExtensions);
+		await aggregateExtensionConfig({
+			projectDirectory: flags["project-directory"],
+			silent: flags.silent
+		});
+	}
+};
+
+//#endregion
+export { AggregateExtensions as default };

package/dist/commands/create-storefront.js

@@ -12,7 +12,23 @@ import { parseEnv } from "node:util";
 
 //#region src/create-storefront.ts
 const DEFAULT_STOREFRONT = "sfcc-storefront";
-const STOREFRONT_NEXT_GITHUB_URL = "https://github.com/SalesforceCommerceCloud/storefront-next-template";
+/**
+* Available storefront verticals, keyed by the value accepted by the `--vertical` flag.
+* `label` is the human-facing choice shown in the interactive prompt; `url` is the
+* published template repository cloned for that vertical. Extend this map to surface a
+* new vertical in both the prompt and the flag.
+*/
+const VERTICALS = {
+	fashion: {
+		label: "Salesforce B2C Commerce Retail Storefront (Fashion)",
+		url: "https://github.com/SalesforceCommerceCloud/storefront-next-template"
+	},
+	cosmetic: {
+		label: "Salesforce B2C Commerce Beauty Storefront (Cosmetic)",
+		url: "https://github.com/SalesforceCommerceCloud/storefront-next-beauty"
+	}
+};
+const DEFAULT_VERTICAL = "fashion";
 const isLocalPath = (template) => template.startsWith("file://") || template.startsWith("/") || template.startsWith("./") || template.startsWith("../");
 const createStorefront = async (options = {}) => {
 	try {
@@ -35,15 +51,23 @@ const createStorefront = async (options = {}) => {
 	logger.info("\n");
 	const outputPath = options.outputDir ? path.join(options.outputDir, storefront) : storefront;
 	let template = options.template;
+	if (!template && options.vertical) {
+		const vertical = VERTICALS[options.vertical];
+		if (!vertical) {
+			logger.error(`Unknown vertical "${options.vertical}". Available verticals: ${Object.keys(VERTICALS).join(", ")}.`);
+			process.exit(1);
+		}
+		template = vertical.url;
+	} else if (!template && options.defaults) template = VERTICALS[DEFAULT_VERTICAL].url;
 	if (!template) {
 		template = (await prompts({
 			type: "select",
 			name: "template",
 			message: "📄 Which template would you like to use for your storefront?\n",
-			choices: [{
-				title: "Salesforce B2C Commerce Retail Storefront",
-				value: STOREFRONT_NEXT_GITHUB_URL
-			}, {
+			choices: [...Object.values(VERTICALS).map((vertical) => ({
+				title: vertical.label,
+				value: vertical.url
+			})), {
 				title: "A different template (I will provide the Github URL)",
 				value: "custom"
 			}]
@@ -153,7 +177,7 @@ const createStorefront = async (options = {}) => {
 					logger.warn(`${dependentNames} requires ${addedName}. ${addedName} has been automatically added.`);
 				}
 			}
-			trimExtensions(outputPath, Object.fromEntries(resolvedExtensions.map((ext) => [ext, true])), { extensions: extensionConfig.extensions });
+			await trimExtensions(outputPath, Object.fromEntries(resolvedExtensions.map((ext) => [ext, true])), { extensions: extensionConfig.extensions });
 		}
 	}
 	const configMetaPath = fs.existsSync(path.join(outputPath, "config-meta.json")) ? path.join(outputPath, "config-meta.json") : path.join(outputPath, "src", "config", "config-meta.json");
@@ -198,6 +222,7 @@ var CreateStorefront = class CreateStorefront extends Command {
 	static description = "Create a storefront project";
 	static examples = [
 		"<%= config.bin %> <%= command.id %>",
+		"<%= config.bin %> <%= command.id %> -n my-storefront -V cosmetic",
 		"<%= config.bin %> <%= command.id %> -n my-storefront -t https://github.com/org/template -b release-0.2.x",
 		"<%= config.bin %> <%= command.id %> -n my-storefront -t /path/to/local/template",
 		"<%= config.bin %> <%= command.id %> -l /path/to/monorepo/packages"
@@ -211,6 +236,11 @@ var CreateStorefront = class CreateStorefront extends Command {
 			char: "t",
 			description: "Template repository to use for the storefront (GitHub URL or local path)"
 		}),
+		vertical: Flags.string({
+			char: "V",
+			description: "Vertical template to generate from. Selects the matching published template repository. Ignored if --template is provided.",
+			options: ["fashion", "cosmetic"]
+		}),
 		"template-branch": Flags.string({
 			char: "b",
 			description: "Branch or tag to clone from the template repository"
@@ -234,6 +264,7 @@ var CreateStorefront = class CreateStorefront extends Command {
 		await createStorefront({
 			name: flags.name,
 			template: flags.template,
+			vertical: flags.vertical,
 			templateBranch: flags["template-branch"],
 			localPackagesDir: flags["local-packages-dir"],
 			defaults: flags.defaults,

package/dist/commands/locales/aggregate-extensions.js

@@ -1,6 +1,7 @@
 import { t as logger } from "../../logger.js";
 import "../../logger2.js";
 import { r as commonFlags } from "../../flags.js";
+import { t as GENERATED_EXTENSION_DIRS } from "../../constants.js";
 import { Command, Flags } from "@oclif/core";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
@@ -54,7 +55,7 @@ async function discoverLocales(dirs) {
 	try {
 		const extensions = await readdir(EXTENSIONS_DIR, { withFileTypes: true });
 		for (const extension of extensions) {
-			if (!extension.isDirectory() || extension.name === "locales") continue;
+			if (!extension.isDirectory() || extension.name === GENERATED_EXTENSION_DIRS.locales || extension.name === GENERATED_EXTENSION_DIRS.config) continue;
 			const localesPath = join(EXTENSIONS_DIR, extension.name, "locales");
 			if (!existsSync(localesPath)) continue;
 			const localeEntries = await readdir(localesPath, { withFileTypes: true });
@@ -71,7 +72,7 @@ async function findExtensionsWithLocale(locale, extensionsDir) {
 	try {
 		const extensionEntries = await readdir(extensionsDir, { withFileTypes: true });
 		for (const entry of extensionEntries) {
-			if (!entry.isDirectory() || entry.name === "locales") continue;
+			if (!entry.isDirectory() || entry.name === GENERATED_EXTENSION_DIRS.locales || entry.name === GENERATED_EXTENSION_DIRS.config) continue;
 			if (existsSync(join(extensionsDir, entry.name, "locales", locale, "translations.json"))) extensions.push({
 				name: entry.name,
 				path: `@/extensions/${entry.name}/locales/${locale}/translations.json`

package/dist/commands/push.js

@@ -92,6 +92,8 @@ var Push = class Push extends MrtCommand {
 		this.log(`Uploading bundle to ${origin}`);
 		const result = await uploadBundle(client, projectSlug, bundle, target);
 		this.log(`Bundle ${result.bundleId} uploaded`);
+		const warnings = result.warnings ?? [];
+		for (const w of warnings) this.warn(w);
 		if (flags.wait && target) {
 			this.log(`Waiting for deployment to ${target}...`);
 			let lastState = "";

package/dist/constants.js

@@ -0,0 +1,29 @@
+//#region src/extensibility/constants.ts
+/**
+* Copyright 2026 Salesforce, Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+/**
+* Names of the generated barrel directories under `src/extensions/`. Each aggregator writes
+* into one (`locales/`, `config/`) and both must skip both during discovery, so neither
+* treats the other's output — or its own — as an extension. Shared here so the skip lists in
+* the locale and config aggregators can't drift apart.
+*/
+const GENERATED_EXTENSION_DIRS = {
+	locales: "locales",
+	config: "config"
+};
+
+//#endregion
+export { GENERATED_EXTENSION_DIRS as t };

package/dist/dependency-utils.js

@@ -1,5 +1,6 @@
 import { t as logger } from "./logger.js";
 import path from "path";
+import { createRequire } from "module";
 import fs from "fs";
 
 //#region src/extensibility/path-util.ts
@@ -18,7 +19,7 @@ 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";
-function trimExtensions(directory, selectedExtensions, extensionConfig) {
+async function trimExtensions(directory, selectedExtensions, extensionConfig) {
 	const startTime = Date.now();
 	const configuredExtensions = extensionConfig?.extensions || {};
 	const extensions = {};
@@ -41,8 +42,8 @@ function trimExtensions(directory, selectedExtensions, extensionConfig) {
 	};
 	processDirectory(directory);
 	if (extensionConfig?.extensions) {
+		await updateExtensionConfig(directory, extensions);
 		deleteExtensionFolders(directory, extensions, extensionConfig);
-		updateExtensionConfig(directory, extensions);
 	}
 	const endTime = Date.now();
 	logger.debug(`Trim extensions took ${endTime - startTime}ms`);
@@ -52,13 +53,64 @@ function trimExtensions(directory, selectedExtensions, extensionConfig) {
 * @param projectDirectory - The project directory
 * @param extensionSelections - The selected extensions
 */
-function updateExtensionConfig(projectDirectory, extensionSelections) {
+async function updateExtensionConfig(projectDirectory, extensionSelections) {
 	const extensionConfigPath = path.join(projectDirectory, "src", "extensions", "config.json");
 	const extensionConfig = JSON.parse(fs.readFileSync(extensionConfigPath, "utf8"));
 	Object.keys(extensionConfig.extensions).forEach((extensionKey) => {
 		if (!extensionSelections[extensionKey]) delete extensionConfig.extensions[extensionKey];
 	});
-	fs.writeFileSync(extensionConfigPath, JSON.stringify({ extensions: extensionConfig.extensions }, null, 4), "utf8");
+	const json = JSON.stringify({ extensions: extensionConfig.extensions }, null, 4);
+	fs.writeFileSync(extensionConfigPath, await formatWithProjectPrettier(json, extensionConfigPath), "utf8");
+}
+/**
+* Format generated JSON/JS so the written file matches what the project's
+* `prettier --write` / `pnpm lint` would produce.
+*
+* `trimExtensions` runs during `create-storefront`, BEFORE the generated project's
+* `pnpm install` — so the project's own Prettier is usually not on disk yet. We therefore
+* prefer the consumer's Prettier when it happens to be present (re-runs, manage-extensions
+* after install), but fall back to the SDK-bundled `prettier` (a hard dependency of this
+* package, pinned to the template's version) so formatting is deterministic and available
+* at generate time. Relying on the consumer's copy alone resolved only by accident in the
+* monorepo harness, where the generated dir is nested under the monorepo and `createRequire`
+* walks up to the monorepo's Prettier; a customer in a clean directory would get unformatted
+* output and fail lint on first run (W-23074938).
+*
+* NOTE: mirror of the helper in
+* packages/template-retail-rsc-app/scripts/generate-eslint-config.js — kept separate because
+* the two live in different packages/module systems. Keep the parser/config-resolution
+* behavior in sync; the fallback chains INTENTIONALLY differ — this copy has a two-level
+* fallback (consumer Prettier → SDK-bundled `import('prettier')` → unformatted) because it
+* runs pre-install, while the generator copy has a single fallback (consumer Prettier →
+* unformatted). Don't "fix" that asymmetry or you reintroduce the pre-install bug (W-23074938).
+*
+* @param content - The serialized file content to format.
+* @param filePath - The file's path (drives parser selection + config resolution).
+* @returns The Prettier-formatted content. Returns the content unchanged only if no Prettier
+*   can be resolved at all; a genuine format/config error throws rather than silently shipping
+*   unformatted output.
+*/
+async function formatWithProjectPrettier(content, filePath) {
+	let prettier;
+	try {
+		prettier = createRequire(filePath)("prettier");
+	} catch {
+		try {
+			prettier = (await import("prettier")).default;
+		} catch {
+			logger.warn("⚠️  Prettier could not be resolved; extension config.json will be written unformatted.");
+			return content;
+		}
+	}
+	try {
+		const config = await prettier.resolveConfig(filePath, { editorconfig: true });
+		return await prettier.format(content, {
+			...config,
+			filepath: filePath
+		});
+	} catch (error) {
+		throw new Error(`Prettier formatting failed for ${path.basename(filePath)}: ${error.message}`);
+	}
 }
 /**
 * Process a file to trim extension-specific code based on markers.

package/dist/entry/server.d.ts

@@ -7,7 +7,7 @@ import { ServerEntryModule } from "react-router";
  *
  * - Spreads all app module properties to forward unknown/future exports
  * - Wraps the default handler for platform-level processing
- * - Prepends a platform instrumentation to unstable_instrumentations
+ * - Prepends a platform instrumentation to instrumentations
  */
 declare function composeServerEntry(appModule: ServerEntryModule): ServerEntryModule;
 //#endregion