bsmnt 0.0.0

package/src/mergers/layout-merger.js

@@ -0,0 +1,223 @@
+// src/mergers/layout-merger.js
+
+import path from "node:path";
+import fs from "fs-extra";
+
+/**
+ * Sanity-specific imports to inject into layout.
+ * Only two lightweight components — no dynamic functions (draftMode, headers, etc.)
+ */
+const SANITY_IMPORTS = `import { SanityStudioGuard } from "@/components/sanity/studio-guard"
+import { SanityVisualEditing } from "@/components/sanity/visual-editing"`;
+
+/**
+ * Client component that hides site chrome on /studio routes.
+ * Uses useSelectedLayoutSegment() — a stable Next.js client API.
+ */
+const STUDIO_GUARD_COMPONENT = `"use client"
+
+import { useSelectedLayoutSegment } from "next/navigation"
+
+export function SanityStudioGuard({ children }: { children: React.ReactNode }) {
+  const segment = useSelectedLayoutSegment()
+  if (segment === "studio") return null
+  return <>{children}</>
+}
+`;
+
+/**
+ * Server component that handles Sanity visual editing.
+ * Keeps draftMode() inside its own <Suspense> boundary so the root layout
+ * never calls dynamic functions directly — preserving static rendering.
+ */
+const VISUAL_EDITING_COMPONENT = `import { Suspense } from "react"
+import { draftMode } from "next/headers"
+import { VisualEditing } from "next-sanity/visual-editing"
+import { isSanityConfigured } from "@/lib/integrations/check-integration"
+import { SanityLive } from "@/lib/integrations/sanity/live"
+
+async function VisualEditingInner() {
+  const { isEnabled: isDraftMode } = await draftMode()
+  const sanityConfigured = isSanityConfigured()
+
+  if (!sanityConfigured || !isDraftMode) return null
+
+  return (
+    <>
+      <VisualEditing />
+      <SanityLive />
+    </>
+  )
+}
+
+export function SanityVisualEditing() {
+  return (
+    <Suspense fallback={null}>
+      <VisualEditingInner />
+    </Suspense>
+  )
+}
+`;
+
+/**
+ * Merge Sanity integration into template layout.
+ * The layout itself stays free of dynamic functions (draftMode, headers, etc.)
+ * All dynamic behavior is encapsulated in generated components.
+ *
+ * Strategy:
+ * 1. Inject two imports (SanityStudioGuard, SanityVisualEditing)
+ * 2. Wrap body chrome in <SanityStudioGuard>
+ * 3. Add <SanityVisualEditing /> before </body>
+ * 4. Generate the two component files
+ *
+ * @param {string} templatePath - Path to the template's layout.tsx
+ * @param {object} options - Options from the merge orchestrator
+ * @param {string} options.targetDir - The project root directory
+ * @param {string} options.pathPrefix - Path prefix (e.g., 'src/' or '')
+ * @returns {Promise<{skipped?: boolean, reason?: string, success?: boolean}>}
+ */
+export async function mergeLayout(
+	templatePath,
+	{ targetDir, pathPrefix } = {},
+) {
+	let content = await fs.readFile(templatePath, "utf-8");
+
+	// Skip if already has Sanity integration
+	if (
+		content.includes("SanityStudioGuard") ||
+		content.includes("isSanityConfigured")
+	) {
+		return { skipped: true, reason: "Already has Sanity integration" };
+	}
+
+	// 1. Add Sanity imports after existing imports
+	const importMatches = [...content.matchAll(/^import .+$/gm)];
+	if (importMatches.length > 0) {
+		const lastImport = importMatches[importMatches.length - 1];
+		const insertPos = lastImport.index + lastImport[0].length;
+		content =
+			content.slice(0, insertPos) +
+			"\n" +
+			SANITY_IMPORTS +
+			content.slice(insertPos);
+	}
+
+	// 2. Ensure Suspense is imported from react
+	if (!content.match(/import\s+.*Suspense.*from\s+["']react["']/)) {
+		const reactImportMatch = content.match(
+			/import\s+\{([^}]*)\}\s+from\s+["']react["']/,
+		);
+		if (reactImportMatch) {
+			if (!reactImportMatch[1].includes("Suspense")) {
+				content = content.replace(
+					reactImportMatch[0],
+					reactImportMatch[0].replace(
+						reactImportMatch[1],
+						`${reactImportMatch[1].trim()}, Suspense`,
+					),
+				);
+			}
+		} else {
+			const lastImportMatch = content.match(/^(import\s+.+\n)/gm);
+			if (lastImportMatch) {
+				const lastImport = lastImportMatch[lastImportMatch.length - 1];
+				content = content.replace(
+					lastImport,
+					`${lastImport}import { Suspense } from "react"\n`,
+				);
+			}
+		}
+	}
+
+	// 3. Wrap body chrome in <SanityStudioGuard> and add <SanityVisualEditing />
+	content = content.replace(
+		/(\s*)(<body[^>]*>)([\s\S]*?)(\{children\})([\s\S]*?)(<\/body>)/m,
+		(
+			_match,
+			bodyIndent,
+			bodyOpen,
+			beforeChildren,
+			_childrenExpr,
+			afterChildren,
+			bodyClose,
+		) => {
+			const baseIndent = bodyIndent || "        ";
+			const indent = `${baseIndent}  `;
+			const innerIndent = `${indent}  `;
+
+			const trimmedBefore = beforeChildren.trim();
+			const trimmedAfter = afterChildren.trim();
+			const hasChrome = trimmedBefore.length > 0 || trimmedAfter.length > 0;
+
+			// Preserve relative indentation of chrome content
+			const reindent = (text, targetIndent) => {
+				const lines = text.split("\n").filter((line) => line.trim());
+				if (lines.length === 0) return "";
+				const minIndent = Math.min(
+					...lines
+						.map((line) => line.match(/^(\s*)/)[1].length)
+						.filter((n) => n > 0),
+					Infinity,
+				);
+				return lines
+					.map((line) => {
+						const currentIndent = line.match(/^(\s*)/)[1].length;
+						const relativeIndent = Math.max(
+							0,
+							currentIndent - (minIndent === Infinity ? 0 : minIndent),
+						);
+						return targetIndent + " ".repeat(relativeIndent) + line.trim();
+					})
+					.join("\n");
+			};
+
+			let result = `${baseIndent}${bodyOpen}\n`;
+
+			if (hasChrome && trimmedBefore) {
+				result += `${indent}<Suspense fallback={null}>\n`;
+				result += `${innerIndent}<SanityStudioGuard>\n`;
+				result += reindent(trimmedBefore, `${innerIndent}  `);
+				result += `\n${innerIndent}</SanityStudioGuard>\n`;
+				result += `${indent}</Suspense>\n\n`;
+			}
+
+			result += `${indent}{children}\n`;
+
+			if (hasChrome && trimmedAfter) {
+				result += `\n${indent}<Suspense fallback={null}>\n`;
+				result += `${innerIndent}<SanityStudioGuard>\n`;
+				result += reindent(trimmedAfter, `${innerIndent}  `);
+				result += `\n${innerIndent}</SanityStudioGuard>\n`;
+				result += `${indent}</Suspense>\n`;
+			}
+
+			result += `\n${indent}<SanityVisualEditing />\n${baseIndent}${bodyClose}`;
+			return result;
+		},
+	);
+
+	await fs.writeFile(templatePath, content);
+
+	// 3. Generate component files
+	if (targetDir) {
+		const sanityDir = path.join(
+			targetDir,
+			pathPrefix || "",
+			"components",
+			"sanity",
+		);
+		await fs.ensureDir(sanityDir);
+
+		const guardPath = path.join(sanityDir, "studio-guard.tsx");
+		if (!(await fs.pathExists(guardPath))) {
+			await fs.writeFile(guardPath, STUDIO_GUARD_COMPONENT);
+		}
+
+		const visualEditingPath = path.join(sanityDir, "visual-editing.tsx");
+		if (!(await fs.pathExists(visualEditingPath))) {
+			await fs.writeFile(visualEditingPath, VISUAL_EDITING_COMPONENT);
+		}
+	}
+
+	return { success: true };
+}

package/src/mergers/next-config-merger.js

@@ -0,0 +1,63 @@
+// src/mergers/next-config-merger.js
+import fs from "fs-extra";
+
+const SANITY_PACKAGES =
+	'"@sanity/client", "@sanity/image-url", "@sanity/asset-utils"';
+
+const IMAGES_BLOCK = `images: {
+    remotePatterns: [
+      {
+        protocol: "https",
+        hostname: "cdn.sanity.io",
+      },
+    ],
+  },`;
+
+/**
+ * Merge Sanity-specific config into template next.config.ts
+ * Adds images.remotePatterns for cdn.sanity.io and
+ * experimental.optimizePackageImports for Sanity packages
+ *
+ * @param {string} templatePath - Path to the template's next.config.ts
+ * @returns {Promise<{skipped?: boolean, reason?: string, success?: boolean}>}
+ */
+export async function mergeNextConfig(templatePath) {
+	let content = await fs.readFile(templatePath, "utf-8");
+
+	// Skip if already has Sanity config
+	if (content.includes("cdn.sanity.io")) {
+		return { skipped: true, reason: "Already has Sanity image config" };
+	}
+
+	// Match the NextConfig object opening: `const nextConfig: NextConfig = {`
+	const configObjectPattern = /(const\s+\w+\s*:\s*NextConfig\s*=\s*\{)/;
+
+	// 1. Add images.remotePatterns for Sanity CDN
+	if (!content.includes("remotePatterns")) {
+		content = content.replace(configObjectPattern, `$1\n  ${IMAGES_BLOCK}`);
+	}
+
+	// 2. Add optimizePackageImports for Sanity packages
+	if (content.includes("optimizePackageImports")) {
+		// Already has optimizePackageImports array — prepend Sanity packages
+		content = content.replace(
+			/(optimizePackageImports\s*:\s*\[)/,
+			`$1${SANITY_PACKAGES}, `,
+		);
+	} else if (content.includes("experimental")) {
+		// Has experimental block but no optimizePackageImports — add it inside
+		content = content.replace(
+			/(experimental\s*:\s*\{)/,
+			`$1\n    optimizePackageImports: [${SANITY_PACKAGES}],`,
+		);
+	} else {
+		// No experimental block — add it to the config object
+		content = content.replace(
+			configObjectPattern,
+			`$1\n  experimental: {\n    optimizePackageImports: [${SANITY_PACKAGES}],\n  },`,
+		);
+	}
+
+	await fs.writeFile(templatePath, content);
+	return { success: true };
+}

package/src/mergers/sitemap-merger.js

@@ -0,0 +1,121 @@
+// src/mergers/sitemap-merger.js
+import fs from "fs-extra";
+
+/**
+ * Sanity-specific import to add
+ */
+const SANITY_IMPORT = `import { isSanityConfigured } from "@/lib/integrations/check-integration"`;
+
+/**
+ * Sanity fetch logic to inject before return statement
+ * Uses early return pattern and spread operator for cleaner code
+ */
+const SANITY_FETCH_LOGIC = `
+  // Only fetch Sanity pages if Sanity is configured
+  if (isSanityConfigured()) {
+    try {
+      const sanityModule = await import("@/lib/integrations/sanity/client")
+      const sanityGroq = await import("next-sanity")
+
+      const client = sanityModule?.client
+      const groq = sanityGroq?.groq
+
+      // Skip if client is null (shouldn't happen since we check isSanityConfigured)
+      if (!(client && groq)) return baseRoutes
+
+      type SanityDocument = {
+        slug: { current: string }
+        _updatedAt: string
+        metadata?: { noIndex?: boolean }
+      }
+
+      // Fetch all published pages and articles
+      const pages = (await client.fetch(
+        groq\`*[_type == "page" && defined(slug.current)] {
+          slug,
+          _updatedAt,
+          metadata
+        }\`
+      )) as SanityDocument[]
+
+      const articles = (await client.fetch(
+        groq\`*[_type == "article" && defined(slug.current)] {
+          slug,
+          _updatedAt,
+          metadata
+        }\`
+      )) as SanityDocument[]
+
+      // Add pages to sitemap (exclude noIndex pages)
+      const pageEntries: MetadataRoute.Sitemap = pages
+        .filter((page: SanityDocument) => !page.metadata?.noIndex)
+        .map((page: SanityDocument) => ({
+          url: \`\${APP_BASE_URL}/\${page.slug.current}\`,
+          lastModified: new Date(page._updatedAt),
+          changeFrequency: "weekly" as const,
+          priority: 0.8,
+        }))
+
+      // Add articles to sitemap (exclude noIndex articles)
+      const articleEntries: MetadataRoute.Sitemap = articles
+        .filter((article: SanityDocument) => !article.metadata?.noIndex)
+        .map((article: SanityDocument) => ({
+          url: \`\${APP_BASE_URL}/blog/\${article.slug.current}\`,
+          lastModified: new Date(article._updatedAt),
+          changeFrequency: "weekly" as const,
+          priority: 0.7,
+        }))
+
+      return [...baseRoutes, ...pageEntries, ...articleEntries]
+    } catch (error) {
+      console.error("Error generating sitemap from Sanity:", error)
+      return baseRoutes
+    }
+  }
+
+`;
+
+/**
+ * Merge Sanity integration into template sitemap
+ * Preserves all existing agnostic code (routes, baseRoutes structure)
+ * and injects Sanity-specific fetching logic
+ *
+ * @param {string} templatePath - Path to the template's sitemap.ts
+ * @returns {Promise<{skipped?: boolean, reason?: string, success?: boolean}>}
+ */
+export async function mergeSitemap(templatePath) {
+	let content = await fs.readFile(templatePath, "utf-8");
+
+	// Skip if already has Sanity integration
+	if (content.includes("isSanityConfigured")) {
+		return { skipped: true, reason: "Already has Sanity integration" };
+	}
+
+	// 1. Add Sanity import after existing imports
+	const importMatches = [...content.matchAll(/^import .+$/gm)];
+	if (importMatches.length > 0) {
+		const lastImport = importMatches[importMatches.length - 1];
+		const insertPos = lastImport.index + lastImport[0].length;
+		content =
+			content.slice(0, insertPos) +
+			"\n" +
+			SANITY_IMPORT +
+			content.slice(insertPos);
+	}
+
+	// 2. Add Sanity fetch logic before the final return statement
+	// Find the last "return baseRoutes" or "return [...baseRoutes" pattern
+	const returnMatch = content.match(
+		/(\n)([ \t]*)(return\s+(?:baseRoutes|\[\.\.\.baseRoutes))/m,
+	);
+	if (returnMatch) {
+		const returnIndex = content.indexOf(returnMatch[0]);
+		content =
+			content.slice(0, returnIndex) +
+			SANITY_FETCH_LOGIC +
+			content.slice(returnIndex);
+	}
+
+	await fs.writeFile(templatePath, content);
+	return { success: true };
+}

package/tasks/prd-next-starter-dynamic-layers.md

@@ -0,0 +1,184 @@
+# PRD: Replace Static Templates with next-starter + Dynamic Layers
+
+## Introduction
+
+The CLI currently maintains 4 complete, nearly-identical template copies (default, webgl, webgpu, experiment). Every bug fix, dependency bump, or structural change must be applied 4 times. The `default` template is essentially a stale snapshot of the `basementstudio/next-starter` repo.
+
+This feature replaces the static templates with a single `next-starter` clone as the base, then dynamically overlays technology-specific files and dependencies using a "layers" system — reusing the same smart-merge pattern already proven by the CMS integration system.
+
+## Goals
+
+- Eliminate template duplication by using `basementstudio/next-starter` as the single source of truth
+- Maintain the same user-facing CLI experience (same 4 template choices, same prompt flow)
+- Create a `layers/` system for technology-specific additions (WebGL, WebGPU, Experiment)
+- Reuse the existing merger infrastructure (`src/mergers/`) for layer injection
+- Delete the entire `template/` directory from the repo
+
+## User Stories
+
+### US-001: Clone next-starter as base template
+**Description:** As a developer using the CLI, I want my project to be scaffolded from the latest `next-starter` repo so that I always get the most up-to-date base configuration.
+
+**Acceptance Criteria:**
+- [ ] `create.js` clones from `github:basementstudio/next-starter#main` instead of `github:basementstudio/basement/template/{type}#main`
+- [ ] Selecting "Default" template produces a project identical to cloning next-starter directly
+- [ ] `bun.lock` is deleted after clone (since dependencies will be modified)
+- [ ] Download spinner text updated to reflect new source
+- [ ] Error/troubleshooting messages updated to reference `basementstudio/next-starter`
+- [ ] Typecheck passes
+
+### US-002: Create layer configuration system
+**Description:** As a CLI maintainer, I want technology layers defined in a config file so that adding or modifying layers only requires changing one file.
+
+**Acceptance Criteria:**
+- [ ] `LAYER_CONFIG` export added to `src/mergers/config.js` alongside existing `CMS_CONFIG`
+- [ ] Each layer config defines: `replaceFiles`, `additivePaths`, `dependencies`, `devDependencies`
+- [ ] `getLayerConfig(layer)` helper function exported
+- [ ] Config contains entries for `webgl`, `webgpu`, and `experiment`
+- [ ] `webgpu` is a deps-only layer (empty `replaceFiles` and `additivePaths`)
+- [ ] Dependencies match what's currently in each template's `package.template.json`
+
+### US-003: Implement layer injection function
+**Description:** As the CLI system, I need to overlay layer-specific files on top of the next-starter base so that WebGL/WebGPU/Experiment projects get their unique components.
+
+**Acceptance Criteria:**
+- [ ] `injectLayer(targetDir, layer, spinner)` function added to `src/mergers/index.js`
+- [ ] Function copies additive files from local `layers/{type}/` directory (no tiged needed)
+- [ ] Function replaces files listed in `replaceFiles` (overwrites base version)
+- [ ] Function uses existing `detectPathPrefix()` and `transformPath()` for `src/` directory support
+- [ ] Function returns results object with `replaced`, `copied`, `skipped`, `failed` arrays
+- [ ] `formatMergeResults()` extended to handle `replaced` entries
+- [ ] Skipped layers (type === 'default') produce no errors
+
+### US-004: Extract layer files from templates
+**Description:** As a CLI maintainer, I need the unique files from each template extracted into a `layers/` directory so they can be overlaid on next-starter.
+
+**Acceptance Criteria:**
+- [ ] `layers/webgl/app/page.tsx` contains the WebGL-specific page (DynamicCanvas import)
+- [ ] `layers/webgl/components/webgl/canvas/dynamic.tsx` exists (from template/webgl)
+- [ ] `layers/webgl/components/webgl/canvas/index.tsx` exists (from template/webgl)
+- [ ] `layers/webgl/components/webgl/components/scene/index.tsx` exists (from template/webgl)
+- [ ] `layers/experiment/components/layout/header/index.tsx` exists (custom header with NavigationMenu)
+- [ ] `layers/experiment/components/layout/navigation-menu.tsx` exists
+- [ ] `layers/experiment/lib/constats.ts` exists
+- [ ] `layers/experiment/lib/utils/cn.ts` exists
+- [ ] `layers/webgpu/` directory exists (empty, deps-only layer)
+- [ ] Files are byte-for-byte identical to their template counterparts
+
+### US-005: Integrate layer injection into create flow
+**Description:** As the CLI system, I need the layer injection step wired into the project creation flow so it runs between template download and CMS integration.
+
+**Acceptance Criteria:**
+- [ ] Layer injection runs after next-starter clone, before CMS integration
+- [ ] Layer injection only runs when `type !== 'default'`
+- [ ] Progress spinner shows layer name during injection
+- [ ] Injection results displayed to user (files added/replaced)
+- [ ] Failures produce warnings, not hard errors
+- [ ] CMS integration (Sanity) still works correctly after layer injection
+- [ ] Typecheck passes
+
+### US-006: Config-driven dependency injection
+**Description:** As the CLI system, I need package.json hydration to read layer dependencies from config instead of being hardcoded in create.js.
+
+**Acceptance Criteria:**
+- [ ] Layer dependencies read from `LAYER_CONFIG` and merged into `package.json`
+- [ ] CMS dependencies still injected as before (unchanged)
+- [ ] Animation library dependencies still injected as before (unchanged)
+- [ ] `package.template.json` rename logic simplified (next-starter uses `package.json` directly)
+- [ ] Project name and version still set correctly
+- [ ] Typecheck passes
+
+### US-007: Delete template directory
+**Description:** As a CLI maintainer, I want the `template/` directory removed so there's no duplicated code to maintain.
+
+**Acceptance Criteria:**
+- [ ] `template/default/` deleted
+- [ ] `template/webgl/` deleted
+- [ ] `template/webgpu/` deleted
+- [ ] `template/experiment/` deleted
+- [ ] No remaining references to `template/` paths in source code
+- [ ] No remaining references to `basementstudio/basement/template/` in source code
+
+### US-008: End-to-end verification
+**Description:** As a CLI maintainer, I need to verify all template + CMS + animation combinations work correctly.
+
+**Acceptance Criteria:**
+- [ ] `basement -c test-default -d -no-cms -no-animation -claude -no-hooks` produces a working project
+- [ ] `basement -c test-webgl -webgl -no-cms -no-animation -claude -no-hooks` produces a working project with R3F components
+- [ ] `basement -c test-webgpu -webgpu -no-cms -no-animation -claude -no-hooks` produces a working project with WebGPU deps
+- [ ] `basement -c test-experiment -exp -no-cms -no-animation -claude -no-hooks` produces a working project with experiment header
+- [ ] `basement -c test-sanity -webgl -sanity -gsap -claude -no-hooks` produces a working project with CMS + animation + layer
+- [ ] All generated projects pass `bun install && bun dev` (dev server starts)
+
+## Functional Requirements
+
+- FR-1: The CLI must clone `basementstudio/next-starter#main` as the base for all template types
+- FR-2: When `type !== 'default'`, the CLI must apply the corresponding layer from the local `layers/` directory
+- FR-3: Layer injection must copy additive files without overwriting existing files
+- FR-4: Layer injection must replace files listed in `replaceFiles`, overwriting the base version
+- FR-5: Layer injection must respect `src/` directory structure (using existing `detectPathPrefix`)
+- FR-6: Layer dependencies must be merged into `package.json` from `LAYER_CONFIG`
+- FR-7: CMS integration must continue to work identically after layer injection
+- FR-8: The `bun.lock` file must be deleted after cloning next-starter
+- FR-9: The user-facing prompt flow must remain unchanged (same 4 template choices)
+- FR-10: The `template/` directory must be deleted from the repository
+
+## Non-Goals
+
+- No multi-layer support (combining WebGL + Experiment) — one layer per project
+- No `add-layer` command for existing projects (only `create` flow)
+- No version pinning UI — always clones latest `main`
+- No changes to the CMS integration system (`src/mergers/` for Sanity/BaseHub)
+- No changes to the hooks, plugins, or agent skills systems
+- No new merger functions for layers (layers use simple copy/replace, not smart merge)
+
+## Technical Considerations
+
+- **Reuse existing infrastructure:** `detectPathPrefix()`, `transformPath()`, and `formatMergeResults()` from `src/mergers/index.js` are already built for this pattern
+- **Layer files are local:** Unlike CMS integrations (cloned via tiged from a remote branch), layer files live in the CLI repo's `layers/` directory. No network request needed.
+- **Application order matters:** Layers run before CMS integration. Layers do NOT modify `layout.tsx`, so the Sanity layout merger continues to work on the unmodified base layout.
+- **Package.json format:** `next-starter` uses `package.json` (not `package.template.json`), simplifying hydration logic.
+
+### Files to Modify
+
+| File | Change Type |
+|------|-------------|
+| `src/mergers/config.js` | Add `LAYER_CONFIG`, `getLayerConfig()` |
+| `src/mergers/index.js` | Add `injectLayer()`, extend `formatMergeResults()` |
+| `src/commands/create.js` | Change tiged source, add layer step, config-driven deps |
+
+### Files to Create
+
+| File | Source |
+|------|--------|
+| `layers/webgl/app/page.tsx` | `template/webgl/app/page.tsx` |
+| `layers/webgl/components/webgl/canvas/dynamic.tsx` | `template/webgl/components/webgl/canvas/dynamic.tsx` |
+| `layers/webgl/components/webgl/canvas/index.tsx` | `template/webgl/components/webgl/canvas/index.tsx` |
+| `layers/webgl/components/webgl/components/scene/index.tsx` | `template/webgl/components/webgl/components/scene/index.tsx` |
+| `layers/experiment/components/layout/header/index.tsx` | `template/experiment/components/layout/header/index.tsx` |
+| `layers/experiment/components/layout/navigation-menu.tsx` | `template/experiment/components/layout/navigation-menu.tsx` |
+| `layers/experiment/lib/constats.ts` | `template/experiment/lib/constats.ts` |
+| `layers/experiment/lib/utils/cn.ts` | `template/experiment/lib/utils/cn.ts` |
+
+### Files/Directories to Delete
+
+| Path | Reason |
+|------|--------|
+| `template/default/` | Replaced by next-starter clone |
+| `template/webgl/` | Replaced by `layers/webgl/` |
+| `template/webgpu/` | Replaced by `layers/webgpu/` |
+| `template/experiment/` | Replaced by `layers/experiment/` |
+
+## Success Metrics
+
+- Template directory eliminated (0 duplicated files to maintain)
+- All 4 template types produce working projects with `bun dev`
+- CMS + layer combinations work correctly
+- CLI prompt flow unchanged (invisible to users)
+- Layer addition requires only: adding files to `layers/`, adding config to `LAYER_CONFIG`
+
+## Open Questions
+
+- Should we add a `--starter-ref` CLI flag in a future iteration for version pinning?
+- If next-starter changes its directory structure significantly, should the CLI validate expected paths before applying layers?
+- Should the `experiment` template's `constats.ts` typo be fixed to `constants.ts`?