create-better-fullstack 2.1.8 → 2.2.0

package/dist/scaffold-manifest-ByKtMhTd.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { a as isStructuredBaselinePath, c as refreshScaffoldManifestFiles, i as hashContent, l as writeScaffoldManifest, n as collectStructuredBaselines, o as readScaffoldManifest, r as computeScaffoldHashes, s as recordScaffoldManifest, t as SCAFFOLD_MANIFEST_FILE } from "./scaffold-manifest-CNFz-lmH.mjs";
+
+export { collectStructuredBaselines, recordScaffoldManifest };

package/dist/{scaffold-manifest-Dyi0voqE.mjs → scaffold-manifest-CNFz-lmH.mjs}

@@ -39,6 +39,23 @@ const EXCLUDED_FILE_NAMES = new Set([
 	"go.sum",
 	"mix.lock"
 ]);
+/** Files whose render content is stored in the manifest for structured merges. */
+function isStructuredBaselinePath(relPath) {
+	const name = path.basename(relPath);
+	return name === "package.json" || name.endsWith(".env.example");
+}
+const BINARY_FILE_MARKER = "[Binary file]";
+/** Extract structured-merge baseline contents from a generated virtual tree. */
+function collectStructuredBaselines(tree) {
+	const baselines = {};
+	function walk(nodes) {
+		for (const node of nodes) if (node.type === "file") {
+			if (isStructuredBaselinePath(node.path) && node.content !== BINARY_FILE_MARKER) baselines[node.path] = node.content;
+		} else walk(node.children);
+	}
+	walk(tree.root.children);
+	return baselines;
+}
 function hashContent(content) {
 	return createHash("sha256").update(content).digest("hex");
 }
@@ -78,10 +95,12 @@ async function computeScaffoldHashes(projectDir) {
 	return Object.fromEntries(entries.sort(([a], [b]) => a.localeCompare(b)));
 }
 async function writeScaffoldManifest(projectDir, manifest) {
+	const sortEntries = (record) => Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
 	const sorted = {
 		version: manifest.version,
 		createdAt: manifest.createdAt,
-		hashes: Object.fromEntries(Object.entries(manifest.hashes).sort(([a], [b]) => a.localeCompare(b)))
+		hashes: sortEntries(manifest.hashes),
+		...manifest.baselines && Object.keys(manifest.baselines).length > 0 ? { baselines: sortEntries(manifest.baselines) } : {}
 	};
 	const manifestPath = path.join(projectDir, SCAFFOLD_MANIFEST_FILE);
 	await fs.writeFile(manifestPath, `${JSON.stringify(sorted, null, 2)}\n`, "utf-8");
@@ -98,7 +117,8 @@ async function recordScaffoldManifest(projectDir, metadata = {}) {
 		const manifest = {
 			version: MANIFEST_VERSION,
 			createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-			hashes: await computeScaffoldHashes(projectDir)
+			hashes: await computeScaffoldHashes(projectDir),
+			baselines: metadata.baselines
 		};
 		await writeScaffoldManifest(projectDir, manifest);
 		return manifest;
@@ -113,13 +133,18 @@ async function readScaffoldManifest(projectDir) {
 		const raw = await fs.readFile(manifestPath, "utf-8");
 		const parsed = JSON.parse(raw);
 		if (!parsed || typeof parsed !== "object" || typeof parsed.hashes !== "object") return null;
+		if (parsed.baselines !== void 0 && typeof parsed.baselines !== "object") delete parsed.baselines;
 		return parsed;
 	} catch {
 		return null;
 	}
 }
-/** Refresh only files deliberately written by an in-place stack update. */
-async function refreshScaffoldManifestFiles(projectDir, relativePaths) {
+/**
+* Refresh only files deliberately written by an in-place stack update.
+* `baselines` (path -> render content) advances the structured-merge baselines
+* to the render the project was just reconciled against.
+*/
+async function refreshScaffoldManifestFiles(projectDir, relativePaths, baselines) {
 	const manifest = await readScaffoldManifest(projectDir);
 	if (!manifest) return;
 	for (const relativePath of new Set(relativePaths)) {
@@ -128,8 +153,12 @@ async function refreshScaffoldManifestFiles(projectDir, relativePaths) {
 		if (!(await fs.stat(fullPath).catch(() => null))?.isFile()) continue;
 		manifest.hashes[relativePath.split(path.sep).join("/")] = hashContent(await fs.readFile(fullPath));
 	}
+	if (baselines && Object.keys(baselines).length > 0) manifest.baselines = {
+		...manifest.baselines,
+		...baselines
+	};
 	await writeScaffoldManifest(projectDir, manifest);
 }
 
 //#endregion
-export { recordScaffoldManifest as a, readScaffoldManifest as i, computeScaffoldHashes as n, refreshScaffoldManifestFiles as o, hashContent as r, writeScaffoldManifest as s, SCAFFOLD_MANIFEST_FILE as t };
+export { isStructuredBaselinePath as a, refreshScaffoldManifestFiles as c, hashContent as i, writeScaffoldManifest as l, collectStructuredBaselines as n, readScaffoldManifest as o, computeScaffoldHashes as r, recordScaffoldManifest as s, SCAFFOLD_MANIFEST_FILE as t };

package/dist/{update-DJ8CI5KW.mjs → update-B270pWHc.mjs}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { r as readBtsConfig } from "./bts-config-DQVWvPDs.mjs";
+import { r as readBtsConfig } from "./bts-config-B_HhcMXL.mjs";
 import { t as renderTitle } from "./render-title-zvyKC1ej.mjs";
 import { a as handleError } from "./errors-ns_o2OKg.mjs";
-import "./file-formatter-gvmrpd-g.mjs";
-import { a as recordScaffoldManifest, i as readScaffoldManifest, r as hashContent, s as writeScaffoldManifest } from "./scaffold-manifest-Dyi0voqE.mjs";
-import { c as formatGeneratedTree, d as treeToFileMap, l as generateTree, s as configFromBtsConfig } from "./mcp-entry.mjs";
+import "./file-formatter-BgbfpYf4.mjs";
+import { a as isStructuredBaselinePath, i as hashContent, l as writeScaffoldManifest, n as collectStructuredBaselines, o as readScaffoldManifest, s as recordScaffoldManifest } from "./scaffold-manifest-CNFz-lmH.mjs";
+import { c as configFromBtsConfig, d as mergeEnvExample, f as mergePackageJson, l as formatGeneratedTree, m as treeToFileMap, o as PACKAGE_JSON_SECTIONS, u as generateTree } from "./mcp-entry.mjs";
 import { intro, log, outro } from "@clack/prompts";
 import pc from "picocolors";
 import fs from "fs-extra";
@@ -15,16 +15,23 @@ import { writeSelectedFiles } from "@better-fullstack/template-generator/fs-writ
 //#region src/helpers/core/scaffold-upgrade.ts
 const BINARY_FILE_MARKER = "[Binary file]";
 /**
+* Files that are never auto-patched: lockfiles are install artifacts and `.env`
+* holds user secrets — both always go to manual review. package.json and
+* *.env.example (see isStructuredBaselinePath) get a structured merge instead.
+*/
+function isConservativeFile(relPath) {
+	const name = path.basename(relPath);
+	return name === ".env" || name === "bun.lock" || name === "bun.lockb" || name === "package-lock.json" || name === "pnpm-lock.yaml" || name === "yarn.lock";
+}
+/**
 * Files whose on-disk bytes are mutated by create-time post-processing
 * (package-manager version, dependency version channel, db-setup, addons) or by
 * dependency install, so their scaffold baseline is not a pure-template render.
-* Never auto-patched — always routed to manual review. A structured merge
-* (reusing stack-update's mergePackageJson / mergeEnvExample) is a deferred
-* follow-up; the MVP is conservative to avoid clobbering post-processed deps.
+* They never take the plain hash-comparison path: they are either merged
+* structurally or routed to manual review.
 */
 function isStructuredMergeFile(relPath) {
-	const name = path.basename(relPath);
-	return name === "package.json" || name === ".env" || name.endsWith(".env.example") || name === "bun.lock" || name === "bun.lockb" || name === "package-lock.json" || name === "pnpm-lock.yaml" || name === "yarn.lock";
+	return isConservativeFile(relPath) || isStructuredBaselinePath(relPath);
 }
 /**
 * Generated docs (README) are re-derived from project mode / stack summary at
@@ -85,9 +92,108 @@ async function renderCurrentProject(projectDir) {
 		return { error: `Failed to render current templates: ${error instanceof Error ? error.message : String(error)}` };
 	}
 }
+/** Deep equality ignoring object key order (renders may reorder catalog maps etc.). */
+function deepEqualUnordered(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => deepEqualUnordered(item, b[index]));
+	if (a && b && typeof a === "object" && typeof b === "object") {
+		const aRecord = a;
+		const bRecord = b;
+		const aKeys = Object.keys(aRecord);
+		return aKeys.length === Object.keys(bRecord).length && aKeys.every((key) => key in bRecord && deepEqualUnordered(aRecord[key], bRecord[key]));
+	}
+	return false;
+}
+/**
+* Template-side package.json changes mergePackageJson cannot express: key
+* removals inside the merged sections and any change to other top-level fields
+* (exports, workspaces, type, ...). Files with such changes go to manual review
+* instead of being silently labeled user-edited or partially merged.
+*/
+function findUnmergeableTemplateChanges(previousContent, proposedContent) {
+	let previous;
+	let proposed;
+	try {
+		previous = JSON.parse(previousContent);
+		proposed = JSON.parse(proposedContent);
+	} catch {
+		return [];
+	}
+	const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+	if (!isRecord(previous) || !isRecord(proposed)) return [];
+	const changes = [];
+	const mergedSections = new Set(PACKAGE_JSON_SECTIONS);
+	for (const section of PACKAGE_JSON_SECTIONS) {
+		const previousSection = isRecord(previous[section]) ? previous[section] : {};
+		const proposedSection = isRecord(proposed[section]) ? proposed[section] : {};
+		for (const key of Object.keys(previousSection)) if (!(key in proposedSection)) changes.push(`${section}.${key} removed`);
+	}
+	for (const key of new Set([...Object.keys(previous), ...Object.keys(proposed)])) {
+		if (mergedSections.has(key)) continue;
+		if (!deepEqualUnordered(previous[key], proposed[key])) changes.push(key);
+	}
+	return changes;
+}
+/**
+* Structured 3-way merge for package.json / *.env.example, reusing stack-update's
+* merge semantics: template-side changes (proposed vs the recorded render
+* baseline) are folded into the user's file; keys the user (or create-time
+* post-processing) changed are never overwritten — if the template also changed
+* such a key, the whole file becomes a conflict naming the blocked keys.
+*/
+function classifyStructuredMerge(filePath, existingContent, proposedContent, baselineContent) {
+	if (proposedContent === void 0 || proposedContent === BINARY_FILE_MARKER) return {
+		path: filePath,
+		category: "manual",
+		reason: "no comparable template render"
+	};
+	if (baselineContent === void 0) return {
+		path: filePath,
+		category: "manual",
+		reason: "no structured-merge baseline recorded — merge by hand or re-run `update --record-baseline`"
+	};
+	if (path.basename(filePath) === "package.json") {
+		const merged$1 = mergePackageJson(existingContent, baselineContent, proposedContent);
+		if (merged$1.blockers.length > 0) return {
+			path: filePath,
+			category: "conflict",
+			reason: `template and local copy both changed: ${merged$1.blockers.join(", ")}`
+		};
+		const uncovered = findUnmergeableTemplateChanges(baselineContent, proposedContent);
+		if (uncovered.length > 0) return {
+			path: filePath,
+			category: "manual",
+			reason: `template changes the merge cannot apply (${uncovered.join(", ")}) — update by hand`
+		};
+		if (merged$1.content) return {
+			path: filePath,
+			category: "merged",
+			reason: merged$1.summary.join("; "),
+			mergedContent: merged$1.content
+		};
+		return {
+			path: filePath,
+			category: "user-edited",
+			reason: "template dependencies/scripts unchanged — local changes kept"
+		};
+	}
+	const merged = mergeEnvExample(existingContent, baselineContent, proposedContent);
+	if (merged.content) return {
+		path: filePath,
+		category: "merged",
+		reason: `adds ${merged.keys.join(", ")}`,
+		mergedContent: merged.content
+	};
+	return {
+		path: filePath,
+		category: "user-edited",
+		reason: "no new template env keys — local changes kept"
+	};
+}
 function summarize(projectDir, files, manifest) {
 	const byCategory = (category) => files.filter((file) => file.category === category).map((file) => file.path);
 	const drift = byCategory("drift");
+	const merged = byCategory("merged");
 	const newFiles = byCategory("new-file");
 	return {
 		success: true,
@@ -100,9 +206,14 @@ function summarize(projectDir, files, manifest) {
 		userEdited: byCategory("user-edited"),
 		conflicts: byCategory("conflict"),
 		manual: files.filter((file) => file.category === "manual"),
+		merged,
 		newFiles,
 		removed: byCategory("removed"),
-		actionable: [...drift, ...newFiles].sort()
+		actionable: [
+			...drift,
+			...merged,
+			...newFiles
+		].sort()
 	};
 }
 /**
@@ -117,7 +228,8 @@ async function planScaffoldUpgrade(projectDirInput) {
 		projectDir,
 		error: rendered.error
 	};
-	const { renderHashes } = rendered;
+	const { tree, renderHashes } = rendered;
+	const renderFiles = treeToFileMap(tree);
 	const manifest = await readScaffoldManifest(projectDir);
 	const baseline = manifest?.hashes ?? {};
 	const hasBaseline = manifest !== null;
@@ -159,14 +271,18 @@ async function planScaffoldUpgrade(projectDirInput) {
 			continue;
 		}
 		if (isSkippableDoc(filePath)) continue;
-		if (isStructuredMergeFile(filePath)) {
+		if (isConservativeFile(filePath)) {
 			files.push({
 				path: filePath,
 				category: "manual",
-				reason: "post-processed file — merge dependencies/env by hand"
+				reason: "lockfile / secrets file — never auto-patched"
 			});
 			continue;
 		}
+		if (isStructuredBaselinePath(filePath)) {
+			files.push(classifyStructuredMerge(filePath, diskBytes.toString("utf-8"), renderFiles.get(filePath)?.content, manifest?.baselines?.[filePath]));
+			continue;
+		}
 		const baselineHash = baseline[filePath];
 		if (baselineHash === void 0) {
 			files.push({
@@ -210,10 +326,11 @@ async function planScaffoldUpgrade(projectDirInput) {
 	return summarize(projectDir, files, manifest);
 }
 /**
-* Apply the safe part of the plan: overwrite template-drift files and write
-* brand-new template files, then refresh the baseline for every file that now
-* matches the current render. Conflicts, local edits, and post-processed files
-* are left untouched (and reported by the caller for manual review).
+* Apply the safe part of the plan: overwrite template-drift files, write
+* brand-new template files, write structured merges (package.json /
+* *.env.example), then refresh the baseline for every file that was reconciled
+* with the current render. Conflicts, local edits, and lockfiles/secrets are
+* left untouched (and reported by the caller for manual review).
 */
 async function applyScaffoldUpgrade(projectDirInput) {
 	const plan = await planScaffoldUpgrade(projectDirInput);
@@ -228,22 +345,47 @@ async function applyScaffoldUpgrade(projectDirInput) {
 	const { tree, renderHashes } = rendered;
 	const toWrite = new Set([...plan.drift, ...plan.newFiles]);
 	if (toWrite.size > 0) await writeSelectedFiles(tree, projectDir, (candidate) => toWrite.has(candidate));
+	const mergedEntries = plan.files.filter((file) => file.category === "merged" && file.mergedContent !== void 0);
+	for (const entry of mergedEntries) await fs.writeFile(path.join(projectDir, entry.path), entry.mergedContent, "utf-8");
 	const manifest = await readScaffoldManifest(projectDir);
 	if (manifest) {
 		for (const filePath of new Set([...plan.unchanged, ...toWrite])) {
 			const renderHash = renderHashes.get(filePath);
 			if (renderHash) manifest.hashes[filePath] = renderHash;
 		}
+		for (const entry of mergedEntries) manifest.hashes[entry.path] = hashContent(Buffer.from(entry.mergedContent, "utf-8"));
+		const renderFiles = treeToFileMap(tree);
+		const reconciled = [
+			...plan.unchanged,
+			...toWrite,
+			...mergedEntries.map((entry) => entry.path)
+		];
+		for (const filePath of reconciled) {
+			if (!isStructuredBaselinePath(filePath)) continue;
+			const content = renderFiles.get(filePath)?.content;
+			if (content !== void 0 && content !== BINARY_FILE_MARKER) (manifest.baselines ??= {})[filePath] = content;
+		}
 		await writeScaffoldManifest(projectDir, manifest);
 	}
 	return {
 		...plan,
 		applied: {
 			patched: [...plan.drift],
-			added: [...plan.newFiles]
+			added: [...plan.newFiles],
+			merged: mergedEntries.map((entry) => entry.path)
 		}
 	};
 }
+/**
+* Record the scaffold baseline for an existing project (`update
+* --record-baseline`): disk hashes plus, when the project still renders, the
+* structured-merge content baselines for package.json / *.env.example.
+*/
+async function recordUpgradeBaseline(projectDirInput) {
+	const projectDir = path.resolve(projectDirInput);
+	const rendered = await renderCurrentProject(projectDir);
+	return recordScaffoldManifest(projectDir, { baselines: "error" in rendered ? void 0 : collectStructuredBaselines(rendered.tree) });
+}
 
 //#endregion
 //#region src/commands/update.ts
@@ -271,6 +413,12 @@ function reportManual(entries) {
 	log.message(`Needs manual review (${entries.length}):`);
 	for (const entry of entries) log.message(pc.dim(`  ! ${entry.path}${entry.reason ? ` — ${entry.reason}` : ""}`));
 }
+function reportMerged(plan) {
+	const merged = plan.files.filter((file) => file.category === "merged");
+	if (merged.length === 0) return;
+	log.message(`Structured merges (template changes folded into your file) (${merged.length}):`);
+	for (const entry of merged) log.message(pc.dim(`  ± ${entry.path}${entry.reason ? ` — ${entry.reason}` : ""}`));
+}
 function reportRemoved(plan) {
 	const removed = plan.files.filter((file) => file.category === "removed");
 	if (removed.length === 0) return;
@@ -282,13 +430,14 @@ function renderPlan(plan) {
 	log.info(pc.dim(plan.hasBaseline ? `Baseline: bts.lock.json${plan.baselineCreatedAt ? ` (recorded ${plan.baselineCreatedAt})` : ""}` : "Baseline: none — run `update --record-baseline` to enable safe auto-patching"));
 	log.message("");
 	reportGroup("Template drift (safe to patch)", "~", plan.drift);
+	reportMerged(plan);
 	reportGroup("New files from templates", "+", plan.newFiles);
 	reportGroup("Locally edited (kept as-is)", "*", plan.userEdited);
 	reportGroup("Conflicts (template + local both changed)", "!", plan.conflicts);
 	reportManual(plan.manual);
 	reportRemoved(plan);
 	log.message("");
-	log.message(pc.dim(`${plan.unchanged.length} up to date · ${plan.drift.length} drift · ${plan.newFiles.length} new · ${plan.userEdited.length} local · ${plan.conflicts.length} conflict · ${plan.manual.length} manual`));
+	log.message(pc.dim(`${plan.unchanged.length} up to date · ${plan.drift.length} drift · ${plan.merged.length} merge · ${plan.newFiles.length} new · ${plan.userEdited.length} local · ${plan.conflicts.length} conflict · ${plan.manual.length} manual`));
 }
 function toJsonPlan(plan) {
 	return {
@@ -298,6 +447,7 @@ function toJsonPlan(plan) {
 		summary: {
 			unchanged: plan.unchanged.length,
 			drift: plan.drift.length,
+			merged: plan.merged.length,
 			newFiles: plan.newFiles.length,
 			userEdited: plan.userEdited.length,
 			conflicts: plan.conflicts.length,
@@ -305,10 +455,17 @@ function toJsonPlan(plan) {
 			removed: plan.removed.length
 		},
 		drift: plan.drift,
+		merged: plan.files.filter((file) => file.category === "merged").map(({ path: filePath, reason }) => ({
+			path: filePath,
+			reason
+		})),
 		newFiles: plan.newFiles,
 		userEdited: plan.userEdited,
 		conflicts: plan.conflicts,
-		manual: plan.manual,
+		manual: plan.manual.map(({ path: filePath, reason }) => ({
+			path: filePath,
+			reason
+		})),
 		removed: plan.removed,
 		actionable: plan.actionable
 	};
@@ -338,7 +495,7 @@ async function updateCommand(input) {
 		handleError(message);
 	}
 	if (recordBaseline) {
-		const manifest = await recordScaffoldManifest(projectDir);
+		const manifest = await recordUpgradeBaseline(projectDir);
 		if (json) {
 			console.log(JSON.stringify({
 				projectDir,
@@ -384,15 +541,15 @@ async function updateCommand(input) {
 	renderPlan(plan);
 	log.message("");
 	if (applied) {
-		if (applied.patched.length + applied.added.length === 0) log.success(pc.green("Already up to date. No template-drift patches to apply."));
-		else log.success(pc.green(`Applied ${formatCount(applied.patched.length, "patch")} and added ${formatCount(applied.added.length, "file")}.`));
+		if (applied.patched.length + applied.added.length + applied.merged.length === 0) log.success(pc.green("Already up to date. No template-drift patches to apply."));
+		else log.success(pc.green(`Applied ${formatCount(applied.patched.length, "patch")}, ${formatCount(applied.merged.length, "structured merge")}, and added ${formatCount(applied.added.length, "file")}.`));
 		const leftover = plan.conflicts.length + plan.manual.length;
-		if (leftover > 0) log.warn(pc.yellow(`${formatCount(leftover, "file")} still need manual review (conflicts + post-processed files).`));
+		if (leftover > 0) log.warn(pc.yellow(`${formatCount(leftover, "file")} still need manual review (conflicts + lockfiles/manual files).`));
 		outro(pc.magenta("Update complete."));
 		return;
 	}
 	if (plan.actionable.length === 0) log.success(pc.green("Up to date with the current templates."));
-	else log.info(pc.cyan(`Run \`bfs update --apply\` to patch ${formatCount(plan.drift.length, "drift file")} and add ${formatCount(plan.newFiles.length, "new file")}.`));
+	else log.info(pc.cyan(`Run \`bfs update --apply\` to patch ${formatCount(plan.drift.length, "drift file")}, apply ${formatCount(plan.merged.length, "structured merge")}, and add ${formatCount(plan.newFiles.length, "new file")}.`));
 	outro(pc.magenta(apply ? "Update complete." : "Dry run — no files were written."));
 	if (check && plan.actionable.length > 0) process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-fullstack",
-  "version": "2.1.8",
+  "version": "2.2.0",
   "description": "Scaffold production-ready fullstack apps in seconds. Pick your stack from 425 options — the CLI wires everything together.",
   "keywords": [
     "algolia",
@@ -128,15 +128,15 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@better-fullstack/template-generator": "^2.1.8",
-    "@better-fullstack/types": "^2.1.8",
+    "@better-fullstack/template-generator": "^2.2.0",
+    "@better-fullstack/types": "^2.2.0",
     "@clack/core": "^0.5.0",
-    "@clack/prompts": "^1.6.0",
-    "@orpc/server": "^1.14.6",
+    "@clack/prompts": "^1.7.0",
+    "@orpc/server": "^1.14.8",
     "consola": "^3.4.2",
     "env-paths": "^4.0.0",
     "execa": "^9.6.1",
-    "fs-extra": "^11.3.5",
+    "fs-extra": "^11.3.6",
     "gradient-string": "^3.0.0",
     "jsonc-parser": "^3.3.1",
     "oxfmt": "^0.19.0",

package/dist/addons-setup-DnLjAzTw.mjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-import "./bts-config-DQVWvPDs.mjs";
-import "./errors-ns_o2OKg.mjs";
-import "./prompt-environment-BR0Kkw2W.mjs";
-import { t as setupAddons } from "./addons-setup-LaAj43NP.mjs";
-
-export { setupAddons };

package/dist/run-CD8f7PHh.mjs

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-import "./bts-config-DQVWvPDs.mjs";
-import { a as createBtsCli, c as history, d as telemetry, f as update, i as create, l as router, n as builder, o as docs, r as check, s as doctor, t as add, u as sponsors } from "./run-T6g1jkfy.mjs";
-import "./render-title-zvyKC1ej.mjs";
-import "./errors-ns_o2OKg.mjs";
-import "./prompt-environment-BR0Kkw2W.mjs";
-import "./analytics-DVltG11u.mjs";
-import "./file-formatter-gvmrpd-g.mjs";
-import "./install-dependencies-RoUyaE8o.mjs";
-import "./generated-checks-BV9jol5h.mjs";
-import "./config-processing-D9-F2Us9.mjs";
-import "./scaffold-manifest-Dyi0voqE.mjs";
-import "./addons-setup-LaAj43NP.mjs";
-
-export { createBtsCli };

package/dist/scaffold-manifest-DGRyepdb.mjs

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { a as recordScaffoldManifest, i as readScaffoldManifest, n as computeScaffoldHashes, o as refreshScaffoldManifestFiles, r as hashContent, s as writeScaffoldManifest, t as SCAFFOLD_MANIFEST_FILE } from "./scaffold-manifest-Dyi0voqE.mjs";
-
-export { recordScaffoldManifest };