@decocms/start 1.2.5 → 1.2.7

package/scripts/migrate/analyzers/theme-extractor.ts

@@ -0,0 +1,122 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { MigrationContext } from "../types.ts";
+import { log } from "../types.ts";
+
+export interface ExtractedTheme {
+  /** Raw CSS variable -> hex color map from DEFAULT_THEME */
+  variables: Record<string, string>;
+  /** Font family string (from Theme.tsx or default_theme) */
+  fontFamily: string | null;
+  /** DaisyUI semantic colors derived from the brand palette */
+  daisyUiColors: Record<string, string>;
+}
+
+const DAISYUI_MAPPING: Record<string, string[]> = {
+  "--color-primary": ["--brand-primary-1"],
+  "--color-secondary": ["--brand-secondary-1"],
+  "--color-accent": ["--brand-terciary-1", "--brand-terciary-base"],
+  "--color-neutral": ["--neutral-900", "--neutral-1"],
+  "--color-base-100": ["--neutral-0", "--neutral-50"],
+  "--color-base-200": ["--brand-secondary-50", "--neutral-100"],
+  "--color-base-300": ["--brand-secondary-500", "--neutral-500"],
+  "--color-info": ["--information"],
+  "--color-success": ["--success"],
+  "--color-warning": ["--warning"],
+  "--color-error": ["--error"],
+};
+
+function extractDefaultTheme(sourceDir: string): Record<string, string> | null {
+  const candidates = [
+    "styles/default_theme.ts",
+    "styles/defaultTheme.ts",
+    "sdk/default_theme.ts",
+  ];
+
+  for (const candidate of candidates) {
+    const filePath = path.join(sourceDir, candidate);
+    if (!fs.existsSync(filePath)) continue;
+
+    const content = fs.readFileSync(filePath, "utf-8");
+
+    const vars: Record<string, string> = {};
+    const entryRe = /["'](--.+?)["']\s*:\s*["'](.+?)["']/g;
+    let match: RegExpExecArray | null;
+    while ((match = entryRe.exec(content)) !== null) {
+      vars[match[1]] = match[2];
+    }
+
+    if (Object.keys(vars).length > 0) return vars;
+  }
+
+  return null;
+}
+
+function extractFontFamily(sourceDir: string): string | null {
+  const candidates = [
+    "sections/Theme/Theme.tsx",
+    "sections/theme/Theme.tsx",
+  ];
+
+  for (const candidate of candidates) {
+    const filePath = path.join(sourceDir, candidate);
+    if (!fs.existsSync(filePath)) continue;
+
+    const content = fs.readFileSync(filePath, "utf-8");
+
+    const fontMatch = content.match(
+      /["']--font-family["']\s*,\s*\n?\s*["'](.*?)["']/,
+    );
+    if (fontMatch) {
+      return fontMatch[1].split(",")[0].trim();
+    }
+
+    const fontMatch2 = content.match(
+      /font.*?["']([\w\s]+(?:,\s*[\w\s-]+)*)/i,
+    );
+    if (fontMatch2) {
+      const family = fontMatch2[1].split(",")[0].trim();
+      if (family && family !== "sans-serif") return family;
+    }
+  }
+
+  return null;
+}
+
+function deriveDaisyUiColors(vars: Record<string, string>): Record<string, string> {
+  const result: Record<string, string> = {};
+
+  for (const [daisyKey, sourceKeys] of Object.entries(DAISYUI_MAPPING)) {
+    for (const sourceKey of sourceKeys) {
+      if (vars[sourceKey]) {
+        result[daisyKey] = vars[sourceKey];
+        break;
+      }
+    }
+  }
+
+  return result;
+}
+
+export function extractTheme(ctx: MigrationContext): ExtractedTheme {
+  const vars = extractDefaultTheme(ctx.sourceDir);
+
+  if (!vars) {
+    log(ctx, "No styles/default_theme.ts found — using placeholder theme");
+    return {
+      variables: {},
+      fontFamily: ctx.fontFamily,
+      daisyUiColors: {},
+    };
+  }
+
+  const fontFamily = extractFontFamily(ctx.sourceDir) || ctx.fontFamily;
+  const daisyUiColors = deriveDaisyUiColors(vars);
+
+  log(
+    ctx,
+    `Theme extracted: ${Object.keys(vars).length} variables, ${Object.keys(daisyUiColors).length} DaisyUI colors, font: ${fontFamily || "none"}`,
+  );
+
+  return { variables: vars, fontFamily, daisyUiColors };
+}

package/scripts/migrate/phase-analyze.ts

@@ -7,6 +7,9 @@ import type {
   Platform,
 } from "./types.ts";
 import { log, logPhase } from "./types.ts";
+import { extractSectionMetadata } from "./analyzers/section-metadata.ts";
+import { classifyIslands } from "./analyzers/island-classifier.ts";
+import { inventoryLoaders } from "./analyzers/loader-inventory.ts";
 
 const PATTERN_DETECTORS: Array<[DetectedPattern, RegExp]> = [
   ["preact-hooks", /from\s+["']preact\/hooks["']/],
@@ -39,6 +42,8 @@ const SKIP_DIRS = new Set([
   ".deco",
   ".devcontainer",
   ".vscode",
+  ".claude",
+  ".cursor",
   "_fresh",
   "static",
   ".context",
@@ -46,17 +51,27 @@ const SKIP_DIRS = new Set([
   "src",
   "public",
   ".tanstack",
+  "tests",
+  "bin",
+  "fonts",
+  ".pilot",
 ]);
 
 const SKIP_FILES = new Set([
   "deno.lock",
   ".gitignore",
   "README.md",
+  "AGENTS.md",
   "LICENSE",
   "browserslist",
   "bw_stats.json",
+  "biome.json",
   "package.json",
   "package-lock.json",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb",
+  "account.json",
 ]);
 
 /** Files that are generated and should be deleted */
@@ -66,13 +81,22 @@ const GENERATED_FILES = new Set([
   "fresh.config.ts",
 ]);
 
-/** SDK files that have framework equivalents */
+/** SDK files that have framework equivalents or are scaffolded fresh */
 const SDK_DELETE = new Set([
   "sdk/clx.ts",
   "sdk/useId.ts",
   "sdk/useOffer.ts",
   "sdk/useVariantPossiblities.ts",
   "sdk/usePlatform.tsx",
+  "sdk/signal.ts",
+  "sdk/format.ts",
+]);
+
+/** Component files that are scaffolded fresh (old versions must not overwrite) */
+const COMPONENT_DELETE = new Set([
+  "components/ui/Image.tsx",
+  "components/ui/Picture.tsx",
+  "components/ui/Video.tsx",
 ]);
 
 /** Loaders that depend on deleted admin tooling */
@@ -96,6 +120,7 @@ const ROOT_DELETE = new Set([
   "fresh.config.ts",
   "browserslist",
   "bw_stats.json",
+  "islands.ts",
 ]);
 
 /** Static files that are code/tooling, not assets — should be deleted */
@@ -152,7 +177,7 @@ function categorizeFile(
   if (relPath.startsWith("actions/")) return "action";
   if (relPath.startsWith("routes/")) return "route";
   if (relPath.startsWith("apps/")) return "app";
-  if (relPath.startsWith("static/")) return "static";
+  if (relPath.startsWith("static/") || relPath.startsWith("static-")) return "static";
   if (GENERATED_FILES.has(relPath)) return "generated";
   if (
     relPath === "deno.json" || relPath === "tsconfig.json" ||
@@ -201,7 +226,7 @@ function decideAction(
     };
   }
 
-  // SDK files to delete
+  // SDK files to delete (replaced by scaffolded or framework equivalents)
   if (SDK_DELETE.has(relPath)) {
     return {
       action: "delete",
@@ -209,24 +234,44 @@ function decideAction(
     };
   }
 
+  // Component files replaced by scaffolded versions
+  if (COMPONENT_DELETE.has(relPath)) {
+    return {
+      action: "delete",
+      notes: "Scaffolded fresh from @decocms/apps re-exports",
+    };
+  }
+
   // cart/ directory → delete
   if (relPath.startsWith("sdk/cart/")) {
     return { action: "delete", notes: "Use @decocms/apps cart hooks" };
   }
 
-  // Islands — if the section is a re-export of this island, island becomes section
+  // Islands — classify and route to appropriate target
   if (category === "island") {
-    const sectionPath = relPath.replace("islands/", "sections/");
+    const classification = (record as any).__islandClassification;
+    if (classification?.type === "wrapper") {
+      return { action: "delete", notes: "Island wrapper — imports repointed to component" };
+    }
+    // Standalone islands go to components/, not sections/
+    const componentPath = relPath.replace("islands/", "components/");
     return {
       action: "transform",
-      targetPath: `src/${sectionPath}`,
-      notes: "Island merged into section",
+      targetPath: `src/${componentPath}`,
+      notes: "Standalone island moved to components",
     };
   }
 
-  // Sections that are re-exports of islands → delete (island takes their place)
+  // Sections that re-export from islands/ → delete (island takes their place)
+  // But sections that re-export from components/ or other dirs should be KEPT
   if (category === "section" && isReExp) {
-    return { action: "delete", notes: "Re-export wrapper, island merged" };
+    const target = record.reExportTarget || "";
+    const isIslandReExport = target.includes("islands/") ||
+      target.includes("islands\\");
+    if (isIslandReExport) {
+      return { action: "delete", notes: "Re-export wrapper for island, island merged" };
+    }
+    // Section re-exports from components/ — keep and transform
   }
 
   // Session component → delete (analytics moves to __root.tsx)
@@ -250,6 +295,19 @@ function decideAction(
     return { action: "move", targetPath: publicPath };
   }
 
+  // Non-code root files that shouldn't go into src/
+  const ext = path.extname(relPath);
+  const nonCodeExts = new Set([".md", ".csv", ".json", ".sh", ".lock", ".yml", ".yaml", ".xml", ".html", ".txt", ".log"]);
+  if (!relPath.includes("/") && nonCodeExts.has(ext)) {
+    return { action: "delete", notes: "Root-level non-code file" };
+  }
+
+  // Root-level loose TS/TSX files that are tooling, not app code
+  const rootToolingFiles = new Set(["islands.ts", "order-status.ts", "sync.sh"]);
+  if (!relPath.includes("/") && rootToolingFiles.has(relPath)) {
+    return { action: "delete", notes: "Root-level tooling file" };
+  }
+
   // Everything else → transform into src/
   return { action: "transform", targetPath: `src/${relPath}` };
 }
@@ -266,7 +324,7 @@ function scanDir(
     const relPath = path.relative(baseDir, fullPath);
 
     if (entry.isDirectory()) {
-      if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+      if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".") || entry.name.startsWith("static-")) continue;
       scanDir(fullPath, baseDir, files);
       continue;
     }
@@ -317,15 +375,65 @@ function extractGtmId(sourceDir: string): string | null {
 }
 
 function extractPlatform(sourceDir: string): Platform {
-  const sitePath = path.join(sourceDir, "apps", "site.ts");
-  if (!fs.existsSync(sitePath)) return "custom";
+  const platforms: Platform[] = ["vtex", "shopify", "wake", "vnda", "linx", "nuvemshop"];
+
+  // Strategy 1: Check deno.json imports for platform-specific app imports
+  const denoPath = path.join(sourceDir, "deno.json");
+  if (fs.existsSync(denoPath)) {
+    try {
+      const deno = JSON.parse(fs.readFileSync(denoPath, "utf-8"));
+      const imports = deno.imports || {};
+      for (const p of platforms) {
+        // e.g. "apps/vtex/" or direct app import containing the platform name
+        const hasAppImport = Object.keys(imports).some(
+          (k) => k === `apps/${p}/` || k.includes(`/${p}/mod.ts`) || k.includes(`deco-apps`) && imports[k].includes(`/${p}/`),
+        );
+        const hasAppValue = Object.values(imports).some(
+          (v) => typeof v === "string" && (v as string).includes(`/${p}/`),
+        );
+        if (hasAppImport || hasAppValue) return p;
+      }
+      // Check if the import map value for "apps/" contains a platform hint
+      const appsUrl = imports["apps/"];
+      if (typeof appsUrl === "string") {
+        for (const p of platforms) {
+          // The apps/ URL itself doesn't indicate platform, but let's check apps/vtex.ts
+          const vtexAppPath = path.join(sourceDir, "apps", `${p}.ts`);
+          if (fs.existsSync(vtexAppPath)) return p;
+        }
+      }
+    } catch {}
+  }
 
-  const content = fs.readFileSync(sitePath, "utf-8");
+  // Strategy 2: Check for apps/{platform}.ts file existence
+  for (const p of platforms) {
+    if (fs.existsSync(path.join(sourceDir, "apps", `${p}.ts`))) return p;
+  }
+
+  // Strategy 3: Check apps/site.ts for platform type and default value
+  const sitePath = path.join(sourceDir, "apps", "site.ts");
+  if (fs.existsSync(sitePath)) {
+    const content = fs.readFileSync(sitePath, "utf-8");
+    // Look for platform default in state or props: state.platform || "vtex"
+    const defaultMatch = content.match(/(?:state\.platform|props\.platform)\s*\|\|\s*["'](\w+)["']/);
+    if (defaultMatch) {
+      const p = defaultMatch[1] as Platform;
+      if (platforms.includes(p)) return p;
+    }
+    // Look for platform in the Props type
+    for (const p of platforms) {
+      if (content.includes(`"${p}"`) && (content.includes("Platform") || content.includes("platform"))) {
+        return p;
+      }
+    }
+  }
 
-  // Check for platform in Props or default
-  for (const p of ["vtex", "shopify", "wake", "vnda", "linx", "nuvemshop"] as const) {
-    if (content.includes(`"${p}"`) && content.includes("_platform")) {
-      // This is just detecting what's available, default is usually "custom"
+  // Strategy 4: Check .deco/blocks for platform-specific block files
+  const blocksDir = path.join(sourceDir, ".deco", "blocks");
+  if (fs.existsSync(blocksDir)) {
+    const blockFiles = fs.readdirSync(blocksDir);
+    for (const p of platforms) {
+      if (blockFiles.some((f) => f.includes(`deco-${p}`) || f === `${p}.json`)) return p;
     }
   }
 
@@ -457,4 +565,26 @@ export function analyze(ctx: MigrationContext): void {
   console.log(`\n  Files found: ${ctx.files.length}`);
   console.log(`  By category: ${JSON.stringify(byCategory)}`);
   console.log(`  By action: ${JSON.stringify(byAction)}`);
+
+  // Run analyzers
+  extractSectionMetadata(ctx);
+  classifyIslands(ctx);
+  inventoryLoaders(ctx);
+
+  // Apply island classifications to file records
+  const classMap = new Map(ctx.islandClassifications.map((c) => [c.path, c]));
+  for (const f of ctx.files) {
+    if (f.category !== "island") continue;
+    const classification = classMap.get(f.path);
+    if (!classification) continue;
+
+    if (classification.type === "wrapper") {
+      f.action = "delete";
+      f.notes = "Island wrapper — imports repointed to component";
+    } else {
+      f.action = "transform";
+      f.targetPath = classification.suggestedTarget;
+      f.notes = "Standalone island moved to components";
+    }
+  }
 }

package/scripts/migrate/phase-cleanup.ts

@@ -134,6 +134,73 @@ function moveStaticFiles(ctx: MigrationContext) {
   }
 }
 
+/**
+ * Handle multi-brand static directories (static-cv/, static-lb/, etc.).
+ * The "primary" brand's assets go to public/.
+ */
+function moveMultiBrandStaticFiles(ctx: MigrationContext) {
+  const entries = fs.readdirSync(ctx.sourceDir, { withFileTypes: true });
+  const staticDirs = entries.filter(
+    (e) => e.isDirectory() && e.name.startsWith("static-"),
+  );
+
+  if (staticDirs.length === 0) return;
+
+  // Use the first one as primary (or match by site name)
+  const primaryDir = staticDirs[0];
+  const primaryPath = path.join(ctx.sourceDir, primaryDir.name);
+  const publicDir = path.join(ctx.sourceDir, "public");
+
+  log(ctx, `Found multi-brand static dirs: ${staticDirs.map((d) => d.name).join(", ")}`);
+  log(ctx, `Using ${primaryDir.name} as primary → public/`);
+
+  function copyRecursive(dir: string, base: string) {
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+      const srcPath = path.join(dir, item.name);
+      const relFromBase = path.relative(base, srcPath);
+      const destPath = path.join(publicDir, relFromBase);
+
+      if (item.name === "tailwind.css" || item.name === "adminIcons.ts") continue;
+      // Skip partytown (not needed in Workers)
+      if (item.name === "~partytown" || item.name === "partytown") continue;
+
+      if (item.isDirectory()) {
+        copyRecursive(srcPath, base);
+        continue;
+      }
+
+      if (ctx.dryRun) {
+        log(ctx, `[DRY] Would copy: ${primaryDir.name}/${relFromBase} → public/${relFromBase}`);
+        ctx.movedFiles.push({ from: `${primaryDir.name}/${relFromBase}`, to: `public/${relFromBase}` });
+        continue;
+      }
+
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+      ctx.movedFiles.push({ from: `${primaryDir.name}/${relFromBase}`, to: `public/${relFromBase}` });
+    }
+  }
+
+  copyRecursive(primaryPath, primaryPath);
+
+  // Clean up all static-* dirs (both root and src/)
+  if (!ctx.dryRun) {
+    for (const d of staticDirs) {
+      const rootDir = path.join(ctx.sourceDir, d.name);
+      if (fs.existsSync(rootDir)) {
+        fs.rmSync(rootDir, { recursive: true, force: true });
+        log(ctx, `Deleted: ${d.name}/`);
+      }
+      const srcDir = path.join(ctx.sourceDir, "src", d.name);
+      if (fs.existsSync(srcDir)) {
+        fs.rmSync(srcDir, { recursive: true, force: true });
+        log(ctx, `Deleted: src/${d.name}/`);
+      }
+    }
+  }
+}
+
 function cleanupOldSourceDirs(ctx: MigrationContext) {
   // After transforms, the original top-level dirs have been copied to src/.
   // Delete the old top-level copies if they still exist and src/ has them.
@@ -173,12 +240,66 @@ function cleanupReExportSections(ctx: MigrationContext) {
   }
 }
 
+/** Remove non-code files and directories that shouldn't be under src/ */
+function cleanupJunkFromSrc(ctx: MigrationContext) {
+  const srcDir = path.join(ctx.sourceDir, "src");
+  if (!fs.existsSync(srcDir)) return;
+
+  // Remove dirs that don't belong in src/
+  const junkDirs = ["bin", "fonts", "tests", ".pilot", ".deco"];
+  for (const dir of junkDirs) {
+    const dirPath = path.join(srcDir, dir);
+    if (fs.existsSync(dirPath)) {
+      if (ctx.dryRun) {
+        log(ctx, `[DRY] Would delete junk dir: src/${dir}/`);
+      } else {
+        fs.rmSync(dirPath, { recursive: true, force: true });
+        log(ctx, `Deleted junk from src/: ${dir}/`);
+      }
+    }
+  }
+
+  // Remove static-* dirs from src/
+  if (fs.existsSync(srcDir)) {
+    for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name.startsWith("static-")) {
+        const dirPath = path.join(srcDir, entry.name);
+        if (ctx.dryRun) {
+          log(ctx, `[DRY] Would delete: src/${entry.name}/`);
+        } else {
+          fs.rmSync(dirPath, { recursive: true, force: true });
+          log(ctx, `Deleted from src/: ${entry.name}/`);
+        }
+      }
+    }
+  }
+
+  // Remove non-code root files from src/
+  const junkFiles = [
+    "AGENTS.md", "account.json", "biome.json", "blockedQs.ts", "islands.ts",
+    "lint-changed.sh", "redirects-vtex.csv", "search-urls-cvlb.csv",
+    "search.csv", "sync.sh", "yarn.lock",
+  ];
+  for (const file of junkFiles) {
+    const filePath = path.join(srcDir, file);
+    if (fs.existsSync(filePath)) {
+      if (ctx.dryRun) {
+        log(ctx, `[DRY] Would delete: src/${file}`);
+      } else {
+        fs.unlinkSync(filePath);
+        log(ctx, `Deleted from src/: ${file}`);
+      }
+    }
+  }
+}
+
 export function cleanup(ctx: MigrationContext): void {
   logPhase("Cleanup");
 
-  // 1. Move static → public
-  console.log("  Moving static/ → public/...");
+  // 1. Move static → public (handles static/, static-cv/, static-lb/, etc.)
+  console.log("  Moving static assets → public/...");
   moveStaticFiles(ctx);
+  moveMultiBrandStaticFiles(ctx);
 
   // 2. Delete specific files
   console.log("  Deleting old files...");
@@ -205,6 +326,7 @@ export function cleanup(ctx: MigrationContext): void {
   console.log("  Cleaning up old source dirs...");
   cleanupOldSourceDirs(ctx);
   cleanupReExportSections(ctx);
+  cleanupJunkFromSrc(ctx);
 
   console.log(
     `  Deleted ${ctx.deletedFiles.length} files/dirs, moved ${ctx.movedFiles.length} files`,

package/scripts/migrate/phase-report.ts

@@ -93,25 +93,53 @@ export function report(ctx: MigrationContext): void {
     lines.push("");
   }
 
+  // Analyzer summaries
+  if (ctx.sectionMetas.length > 0) {
+    lines.push("## Section Analysis");
+    lines.push("");
+    const withLoader = ctx.sectionMetas.filter((m) => m.hasLoader).length;
+    const layouts = ctx.sectionMetas.filter((m) => m.isHeader || m.isFooter || m.isTheme).length;
+    const listings = ctx.sectionMetas.filter((m) => m.isListing).length;
+    lines.push(`- **${ctx.sectionMetas.length}** sections analyzed`);
+    lines.push(`- **${withLoader}** have loaders (extracted to \`setup/section-loaders.ts\`)`);
+    lines.push(`- **${layouts}** are layout sections (eager + sync + layout)`);
+    lines.push(`- **${listings}** are listing sections (cache = "listing")`);
+    lines.push("");
+  }
+
+  if (ctx.islandClassifications.length > 0) {
+    const wrappers = ctx.islandClassifications.filter((c) => c.type === "wrapper").length;
+    const standalone = ctx.islandClassifications.filter((c) => c.type === "standalone").length;
+    lines.push("## Island Elimination");
+    lines.push("");
+    lines.push(`- **${ctx.islandClassifications.length}** islands classified`);
+    lines.push(`- **${wrappers}** wrappers (deleted, imports repointed)`);
+    lines.push(`- **${standalone}** standalone (moved to \`src/components/\`)`);
+    lines.push("");
+  }
+
+  if (ctx.loaderInventory.length > 0) {
+    const custom = ctx.loaderInventory.filter((l) => l.isCustom).length;
+    const mapped = ctx.loaderInventory.filter((l) => l.appsEquivalent).length;
+    lines.push("## Loader Inventory");
+    lines.push("");
+    lines.push(`- **${ctx.loaderInventory.length}** loaders inventoried`);
+    lines.push(`- **${mapped}** mapped to \`@decocms/apps\` equivalents`);
+    lines.push(`- **${custom}** custom (included in \`setup/commerce-loaders.ts\`)`);
+    lines.push("");
+  }
+
   // Always-present manual review items
   lines.push("## Always Check (site-specific)");
   lines.push("");
-  lines.push(
-    "- [ ] `FormEmail.tsx` — `invoke.resend.actions.emails.send()` needs new server function pattern",
-  );
-  lines.push(
-    "- [ ] `Slider.tsx` — verify `scriptAsDataURI` pattern works with React",
-  );
-  lines.push(
-    "- [ ] `Theme.tsx` — verify `SiteTheme` mapping to `@decocms/start`",
-  );
-  lines.push("- [ ] DaisyUI v4 → v5 class name changes");
-  lines.push(
-    "- [ ] Tailwind v3 → v4: verify all utility classes still work",
-  );
-  lines.push(
-    "- [ ] Check `src/styles/app.css` theme colors match the original design",
-  );
+  lines.push("- [ ] `src/setup/commerce-loaders.ts` — verify each loader mapping is correct");
+  lines.push("- [ ] `src/setup/section-loaders.ts` — verify extracted loaders work correctly");
+  lines.push("- [ ] `src/hooks/useCart.ts` — wire to actual server functions for your platform");
+  lines.push("- [ ] `src/worker-entry.ts` — verify CSP, proxy, and segment builder");
+  lines.push("- [ ] DaisyUI v4 to v5 class name changes");
+  lines.push("- [ ] Tailwind v3 to v4: verify all utility classes still work");
+  lines.push("- [ ] Check `src/styles/app.css` theme colors match the original design");
+  lines.push("- [ ] Run `npm run generate:blocks` and `npm run generate:schema` after migration");
   lines.push("");
 
   // Known Issues