@see-ms/converter 1.0.0 → 1.1.1

package/dist/cli.mjs

@@ -4,20 +4,90 @@
 import { Command } from "commander";
 import pc4 from "picocolors";
 import * as readline2 from "readline";
-import fs12 from "fs-extra";
-import path14 from "path";
+import fs14 from "fs-extra";
+import path18 from "path";
 
 // src/converter.ts
 import pc3 from "picocolors";
-import path12 from "path";
-import fs10 from "fs-extra";
+import path16 from "path";
 
 // src/filesystem.ts
 import fs from "fs-extra";
-import path from "path";
+import path2 from "path";
 import { glob } from "glob";
 import { execSync } from "child_process";
 import pc from "picocolors";
+
+// src/assets.ts
+import path from "path";
+var RESPONSIVE_VARIANT_RE = /-p-(?:\d+(?:x\d+q\d+)?)(?=\.[^.]+$)/i;
+function isResponsiveImageVariant(filePath) {
+  return RESPONSIVE_VARIANT_RE.test(path.basename(filePath));
+}
+function toOriginalImageCandidate(filePath) {
+  return filePath.replace(RESPONSIVE_VARIANT_RE, "");
+}
+function normalizeAssetUrl(value) {
+  try {
+    return decodeURI(value);
+  } catch {
+    return value;
+  }
+}
+function normalizePublicAssetPath(src) {
+  if (!src || /^(https?:)?\/\//i.test(src) || src.startsWith("data:")) {
+    return src;
+  }
+  let normalized = normalizeAssetUrl(src).replace(/^(\.\.\/)+/, "").replace(/^\.\//, "");
+  normalized = toOriginalImageCandidate(normalized);
+  if (normalized.startsWith("/assets/")) {
+    return normalized.replace(/\/\.\.\//g, "/");
+  }
+  return `/assets/${normalized.replace(/^\/+/, "")}`;
+}
+function normalizeImageSeedPath(imageSrc) {
+  if (!imageSrc) return "";
+  if (/^(https?:)?\/\//i.test(imageSrc) || imageSrc.startsWith("data:")) return imageSrc;
+  const [pathPart] = imageSrc.split(/[?#]/);
+  const decoded = normalizeAssetUrl(pathPart).replace(/^(\.\.\/)+/, "").replace(/^\.\//, "");
+  const withoutLeadingSlash = decoded.replace(/^\/+/, "");
+  const withoutAssetsPrefix = withoutLeadingSlash.replace(/^assets\/images\//, "images/");
+  const imageIndex = withoutAssetsPrefix.indexOf("images/");
+  const imagePath = imageIndex >= 0 ? withoutAssetsPrefix.slice(imageIndex) : `images/${path.basename(withoutAssetsPrefix)}`;
+  return `/${toOriginalImageCandidate(imagePath)}`;
+}
+function mediaLookupKeys(value) {
+  if (!value) return [];
+  const decoded = normalizeAssetUrl(value);
+  const withoutLeadingSlash = decoded.replace(/^\/+/, "");
+  const withoutAssetsPrefix = withoutLeadingSlash.replace(/^assets\/images\//, "images/");
+  const withoutImagesPrefix = withoutAssetsPrefix.replace(/^images\//, "");
+  const original = toOriginalImageCandidate(withoutImagesPrefix);
+  const basename = path.basename(original);
+  const basenameHyphenated = basename.replace(/\s+/g, "-");
+  return Array.from(/* @__PURE__ */ new Set([
+    decoded,
+    withoutLeadingSlash,
+    withoutAssetsPrefix,
+    withoutImagesPrefix,
+    original,
+    basename,
+    basenameHyphenated,
+    `/images/${withoutImagesPrefix}`,
+    `images/${withoutImagesPrefix}`,
+    `/images/${original}`,
+    `images/${original}`,
+    `/assets/images/${withoutImagesPrefix}`,
+    `assets/images/${withoutImagesPrefix}`,
+    `/assets/images/${original}`,
+    `assets/images/${original}`
+  ]));
+}
+function isLikelyImagePath(value) {
+  return /\.(?:jpe?g|png|gif|webp|avif|svg)(?:[?#].*)?$/i.test(value);
+}
+
+// src/filesystem.ts
 async function scanAssets(webflowDir) {
   const assets = {
     css: [],
@@ -27,47 +97,55 @@ async function scanAssets(webflowDir) {
   };
   const cssFiles = await glob("css/**/*.css", { cwd: webflowDir });
   assets.css = cssFiles;
-  const imageFiles = await glob("images/**/*", { cwd: webflowDir });
-  assets.images = imageFiles;
-  const fontFiles = await glob("fonts/**/*", { cwd: webflowDir });
+  const imageFiles = await glob("images/**/*", { cwd: webflowDir, nodir: true });
+  assets.images = imageFiles.filter((file) => !isResponsiveImageVariant(file));
+  const fontFiles = await glob("fonts/**/*", { cwd: webflowDir, nodir: true });
   assets.fonts = fontFiles;
   const jsFiles = await glob("js/**/*.js", { cwd: webflowDir });
   assets.js = jsFiles;
   return assets;
 }
 async function copyCSSFiles(webflowDir, outputDir, cssFiles) {
-  const targetDir = path.join(outputDir, "assets", "css");
+  const targetDir = path2.join(outputDir, "assets", "css");
   await fs.ensureDir(targetDir);
   for (const file of cssFiles) {
-    const source = path.join(webflowDir, file);
-    const target = path.join(targetDir, path.basename(file));
+    const source = path2.join(webflowDir, file);
+    const relative = path2.relative("css", file);
+    const target = path2.join(targetDir, relative);
+    await fs.ensureDir(path2.dirname(target));
     await fs.copy(source, target);
   }
 }
 async function copyImages(webflowDir, outputDir, imageFiles) {
-  const targetDir = path.join(outputDir, "public", "assets", "images");
+  const targetDir = path2.join(outputDir, "public", "assets", "images");
   await fs.ensureDir(targetDir);
   for (const file of imageFiles) {
-    const source = path.join(webflowDir, file);
-    const target = path.join(targetDir, path.basename(file));
+    const source = path2.join(webflowDir, file);
+    const relative = path2.relative("images", file);
+    const target = path2.join(targetDir, relative);
+    await fs.ensureDir(path2.dirname(target));
     await fs.copy(source, target);
   }
 }
 async function copyFonts(webflowDir, outputDir, fontFiles) {
-  const targetDir = path.join(outputDir, "public", "assets", "fonts");
+  const targetDir = path2.join(outputDir, "public", "assets", "fonts");
   await fs.ensureDir(targetDir);
   for (const file of fontFiles) {
-    const source = path.join(webflowDir, file);
-    const target = path.join(targetDir, path.basename(file));
+    const source = path2.join(webflowDir, file);
+    const relative = path2.relative("fonts", file);
+    const target = path2.join(targetDir, relative);
+    await fs.ensureDir(path2.dirname(target));
     await fs.copy(source, target);
   }
 }
 async function copyJSFiles(webflowDir, outputDir, jsFiles) {
-  const targetDir = path.join(outputDir, "public", "assets", "js");
+  const targetDir = path2.join(outputDir, "public", "assets", "js");
   await fs.ensureDir(targetDir);
   for (const file of jsFiles) {
-    const source = path.join(webflowDir, file);
-    const target = path.join(targetDir, path.basename(file));
+    const source = path2.join(webflowDir, file);
+    const relative = path2.relative("js", file);
+    const target = path2.join(targetDir, relative);
+    await fs.ensureDir(path2.dirname(target));
     await fs.copy(source, target);
   }
 }
@@ -78,26 +156,56 @@ async function copyAllAssets(webflowDir, outputDir, assets) {
   await copyJSFiles(webflowDir, outputDir, assets.js);
 }
 async function findHTMLFiles(webflowDir) {
-  const htmlFiles = await glob("**/*.html", { cwd: webflowDir });
+  const htmlFiles = await glob("**/*.html", { cwd: webflowDir, nodir: true });
   return htmlFiles;
 }
 async function readHTMLFile(webflowDir, fileName) {
-  const filePath = path.join(webflowDir, fileName);
+  const filePath = path2.join(webflowDir, fileName);
   return await fs.readFile(filePath, "utf-8");
 }
-async function writeVueComponent(outputDir, fileName, content) {
-  const pagesDir = path.join(outputDir, "pages");
+async function writeVueComponent(outputDir, fileName, content, target = "nuxt", cssFiles = [], editorEnabled = false) {
+  if (target === "astro-vue") {
+    const componentDir = path2.join(outputDir, "src", "components", "pages");
+    const astroPagesDir = path2.join(outputDir, "src", "pages");
+    const vueName2 = fileName.replace(".html", ".vue");
+    const astroName = fileName.replace(".html", ".astro");
+    const vuePath = path2.join(componentDir, vueName2);
+    const astroPath = path2.join(astroPagesDir, astroName);
+    const relativeVueImport = ensureRelativeImport(path2.relative(path2.dirname(astroPath), vuePath));
+    const cssLinks = [
+      ...cssFiles.map((file) => `/assets/css/${path2.basename(file)}`),
+      "/assets/css/main.css"
+    ].map((href) => `<link rel="stylesheet" href="${href}" />`).join("\n");
+    const editorScript = editorEnabled ? "\n<script>\n  import '../cms-editor';\n</script>\n" : "";
+    await fs.ensureDir(path2.dirname(vuePath));
+    await fs.ensureDir(path2.dirname(astroPath));
+    await fs.writeFile(vuePath, content, "utf-8");
+    await fs.writeFile(astroPath, `---
+import Page from '${relativeVueImport}';
+---
+
+${cssLinks}
+<Page client:only="vue" />
+${editorScript}
+`, "utf-8");
+    return;
+  }
+  const pagesDir = path2.join(outputDir, "pages");
   const vueName = fileName.replace(".html", ".vue");
-  const targetPath = path.join(pagesDir, vueName);
-  await fs.ensureDir(path.dirname(targetPath));
+  const targetPath = path2.join(pagesDir, vueName);
+  await fs.ensureDir(path2.dirname(targetPath));
   await fs.writeFile(targetPath, content, "utf-8");
 }
-async function formatVueFiles(outputDir) {
-  const pagesDir = path.join(outputDir, "pages");
+function ensureRelativeImport(importPath) {
+  const normalized = importPath.split(path2.sep).join("/");
+  return normalized.startsWith(".") ? normalized : `./${normalized}`;
+}
+async function formatVueFiles(outputDir, target = "nuxt") {
+  const pagesDir = target === "astro-vue" ? path2.join(outputDir, "src", "components", "pages") : path2.join(outputDir, "pages");
   try {
     console.log(pc.blue("\n\u2728 Formatting Vue files with Prettier..."));
-    execSync("npx prettier --version", { stdio: "ignore" });
-    execSync(`npx prettier --write "${pagesDir}/**/*.vue"`, {
+    execSync("prettier --version", { stdio: "ignore" });
+    execSync(`prettier --write "${pagesDir}/**/*.vue"`, {
       cwd: outputDir,
       stdio: "inherit"
     });
@@ -109,35 +217,28 @@ async function formatVueFiles(outputDir) {
 
 // src/parser.ts
 import * as cheerio from "cheerio";
-import path2 from "path";
-function normalizeRoute(href) {
-  let route = href.replace(".html", "");
+import path3 from "path";
+function normalizeRoute(href, currentFile) {
+  const [pathPart, suffix = ""] = href.split(/(?=[?#])/);
+  let route = pathPart.replace(/\.html$/i, "");
   if (route === "index" || route === "/index" || route.endsWith("/index")) {
-    return "/";
+    const parent = route.replace(/(^|\/)index$/, "");
+    return `${parent ? parent.startsWith("/") ? parent : `/${parent}` : "/"}${suffix}`;
   }
   if (route === ".." || route === "../" || route === "/.." || route === "../index") {
-    return "/";
+    return `/${suffix}`;
   }
-  route = route.replace(/\.\.\//g, "").replace(/\.\//g, "");
-  const normalized = path2.posix.normalize(route);
+  if (currentFile && !route.startsWith("/")) {
+    route = path3.posix.join(path3.posix.dirname(currentFile.replace(/\\/g, "/")), route);
+  }
+  const normalized = path3.posix.normalize(route);
   if (!normalized.startsWith("/")) {
-    return "/" + normalized;
+    return `/${normalized}${suffix}`;
   }
   if (normalized === "." || normalized === "") {
-    return "/";
-  }
-  return normalized;
-}
-function normalizeAssetPath(src) {
-  if (!src || src.startsWith("http") || src.startsWith("https")) {
-    return src;
-  }
-  let normalized = src.replace(/^(\.\.\/)+/, "").replace(/^\.\//, "");
-  if (normalized.startsWith("/assets/")) {
-    normalized = normalized.replace(/\/\.\.\//g, "/");
-    return normalized;
+    return `/${suffix}`;
   }
-  return `/assets/${normalized}`;
+  return `${normalized}${suffix}`;
 }
 function parseHTML(html, fileName) {
   const $ = cheerio.load(html);
@@ -153,11 +254,15 @@ function parseHTML(html, fileName) {
   $(".global-embed style").each((_, el) => {
     embeddedStyles += $(el).html() + "\n";
   });
+  $(".w-embed > style").each((_, el) => {
+    embeddedStyles += $(el).html() + "\n";
+  });
   $("body > style").each((_, el) => {
     embeddedStyles += $(el).html() + "\n";
   });
   $(".global-embed").remove();
   $("body > style").remove();
+  $(".w-embed > style").remove();
   $("body script").remove();
   const images = [];
   $("img").each((_, el) => {
@@ -184,8 +289,9 @@ function parseHTML(html, fileName) {
     links
   };
 }
-function transformForNuxt(html) {
+function transformForNuxt(html, currentFile, options = {}) {
   const $ = cheerio.load(html);
+  const linkMode = options.linkMode || "nuxt";
   $("html, head, body").each((_, el) => {
     const $el = $(el);
     $el.replaceWith($el.html() || "");
@@ -196,20 +302,23 @@ function transformForNuxt(html) {
     const href = $el.attr("href");
     if (!href) return;
     const isExternal = href.startsWith("http://") || href.startsWith("https://") || href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("#");
-    if (!isExternal) {
-      const route = normalizeRoute(href);
-      $el.attr("to", route);
-      $el.removeAttr("href");
+    if (!isExternal && linkMode === "nuxt") {
+      const route = normalizeRoute(href, currentFile);
       const content = $el.html();
-      const classes = $el.attr("class") || "";
-      $el.replaceWith(`<nuxt-link to="${route}" class="${classes}">${content}</nuxt-link>`);
+      const attrs = { ...$el.attr() };
+      delete attrs.href;
+      attrs.to = route;
+      const attrString = Object.entries(attrs).map(([name, value]) => `${name}="${escapeAttribute(value ?? "")}"`).join(" ");
+      $el.replaceWith(`<nuxt-link ${attrString}>${content}</nuxt-link>`);
+    } else if (!isExternal) {
+      $el.attr("href", normalizeRoute(href, currentFile));
     }
   });
   $("img").each((_, el) => {
     const $el = $(el);
     const src = $el.attr("src");
     if (src) {
-      const normalizedSrc = normalizeAssetPath(src);
+      const normalizedSrc = normalizePublicAssetPath(src);
       $el.attr("src", normalizedSrc);
     }
     $el.removeAttr("srcset");
@@ -217,10 +326,18 @@ function transformForNuxt(html) {
   });
   return $.html();
 }
-function htmlToVueComponent(html, pageName) {
-  return `
-<script setup lang="ts">
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function htmlToVueComponent(html, pageName, componentImports, componentImportBase = "~/components") {
+  let importsSection = "";
+  if (componentImports && componentImports.length > 0) {
+    importsSection = componentImports.map((name) => `import ${name} from '${componentImportBase}/${name}.vue';`).join("\n");
+    html = restoreComponentTags(replaceComponentMarkers(html), componentImports);
+  }
+  return `<script setup lang="ts">
 // Page: ${pageName}
+${importsSection}
 </script>
 
 <template>
@@ -230,6 +347,17 @@ function htmlToVueComponent(html, pageName) {
 </template>
 `;
 }
+function replaceComponentMarkers(html) {
+  return html.replace(/<!--COMPONENT:(\w+)-->/g, "<$1 />");
+}
+function restoreComponentTags(html, componentImports) {
+  let restored = html;
+  for (const name of componentImports) {
+    const lowered = name.toLowerCase();
+    restored = restored.replace(new RegExp(`<${lowered}\\s*><\\/${lowered}>`, "g"), `<${name} />`).replace(new RegExp(`<${lowered}\\s*\\/>`, "g"), `<${name} />`);
+  }
+  return restored;
+}
 function deduplicateStyles(styles) {
   if (!styles.trim()) return "";
   const sections = styles.split(/\/\* From .+ \*\//);
@@ -245,9 +373,9 @@ function deduplicateStyles(styles) {
 
 // src/config-updater.ts
 import fs2 from "fs-extra";
-import path3 from "path";
+import path4 from "path";
 function generateWebflowAssetPlugin(cssFiles) {
-  const webflowFiles = cssFiles.map((file) => `/assets/css/${path3.basename(file)}`);
+  const webflowFiles = cssFiles.map((file) => `/assets/css/${path4.basename(file)}`);
   return `import type { Plugin } from 'vite'
 
 const webflowFiles = [${webflowFiles.map((f) => `'${f}'`).join(", ")}]
@@ -280,20 +408,20 @@ export default webflowURLReset
 `;
 }
 async function writeWebflowAssetPlugin(outputDir, cssFiles) {
-  const utilsDir = path3.join(outputDir, "utils");
+  const utilsDir = path4.join(outputDir, "utils");
   await fs2.ensureDir(utilsDir);
   const content = generateWebflowAssetPlugin(cssFiles);
-  const targetPath = path3.join(utilsDir, "webflow-assets.ts");
+  const targetPath = path4.join(utilsDir, "webflow-assets.ts");
   await fs2.writeFile(targetPath, content, "utf-8");
 }
 async function updateNuxtConfig(outputDir, cssFiles) {
-  const configPath = path3.join(outputDir, "nuxt.config.ts");
+  const configPath = path4.join(outputDir, "nuxt.config.ts");
   const configExists = await fs2.pathExists(configPath);
   if (!configExists) {
     throw new Error("nuxt.config.ts not found in output directory");
   }
   let config = await fs2.readFile(configPath, "utf-8");
-  const cssEntries = cssFiles.map((file) => `    '~/assets/css/${path3.basename(file)}'`);
+  const cssEntries = cssFiles.map((file) => `    '~/assets/css/${path4.basename(file)}'`);
   if (config.includes("css:")) {
     config = config.replace(
       /css:\s*\[/,
@@ -313,9 +441,9 @@ ${cssEntries.join(",\n")}
 }
 async function writeEmbeddedStyles(outputDir, styles) {
   if (!styles.trim()) return;
-  const cssDir = path3.join(outputDir, "assets", "css");
+  const cssDir = path4.join(outputDir, "assets", "css");
   await fs2.ensureDir(cssDir);
-  const mainCssPath = path3.join(cssDir, "main.css");
+  const mainCssPath = path4.join(cssDir, "main.css");
   const exists = await fs2.pathExists(mainCssPath);
   if (exists) {
     const existing = await fs2.readFile(mainCssPath, "utf-8");
@@ -329,7 +457,7 @@ ${styles}`, "utf-8");
   }
 }
 async function addStrapiUrlToConfig(outputDir, strapiUrl = "http://localhost:1337") {
-  const configPath = path3.join(outputDir, "nuxt.config.ts");
+  const configPath = path4.join(outputDir, "nuxt.config.ts");
   const configExists = await fs2.pathExists(configPath);
   if (!configExists) {
     throw new Error("nuxt.config.ts not found in output directory");
@@ -367,9 +495,18 @@ async function addStrapiUrlToConfig(outputDir, strapiUrl = "http://localhost:133
 
 // src/editor-integration.ts
 import fs3 from "fs-extra";
-import path4 from "path";
+import path5 from "path";
+function getPageCollections(manifest) {
+  if (!manifest) return {};
+  return Object.fromEntries(
+    Object.entries(manifest.pages).map(([pageName, page]) => [
+      pageName,
+      Object.entries(page.collections || {}).filter(([, collection]) => collection.storage !== "page-repeatable").map(([collectionName]) => collectionName)
+    ])
+  );
+}
 async function createEditorContentComposable(outputDir) {
-  const composablesDir = path4.join(outputDir, "composables");
+  const composablesDir = path5.join(outputDir, "composables");
   await fs3.ensureDir(composablesDir);
   const composableContent = `/**
  * Global state for editor content in preview mode
@@ -468,21 +605,25 @@ export function useEditorContent(pageName?: string) {
   };
 }
 `;
-  const composablePath = path4.join(composablesDir, "useEditorContent.ts");
+  const composablePath = path5.join(composablesDir, "useEditorContent.ts");
   await fs3.writeFile(composablePath, composableContent, "utf-8");
 }
-async function createStrapiContentComposable(outputDir) {
-  const composablesDir = path4.join(outputDir, "composables");
+async function createStrapiContentComposable(outputDir, manifest) {
+  const composablesDir = path5.join(outputDir, "composables");
   await fs3.ensureDir(composablesDir);
+  const pageCollections = JSON.stringify(getPageCollections(manifest), null, 2);
   const composableContent = `/**
  * Composable to fetch content from Strapi based on CMS manifest
  * Integrates with editor state for preview mode
  */
 
+const PAGE_COLLECTIONS: Record<string, string[]> = ${pageCollections};
+
 export function useStrapiContent(pageName: string) {
   const config = useRuntimeConfig();
   const strapiUrl = config.public.strapiUrl || 'http://localhost:1337';
   const editorContent = useEditorContent(pageName);
+  const collectionNames = PAGE_COLLECTIONS[pageName] || [];
 
   // Helper to transform Strapi image objects to URL strings
   const transformStrapiImages = (data: any, baseUrl: string): any => {
@@ -541,6 +682,25 @@ export function useStrapiContent(pageName: string) {
     }
   );
 
+  const collectionFetches = collectionNames.map((collectionName) =>
+    useFetch<any>(
+      \`\${strapiUrl}/api/\${collectionName}\`,
+      {
+        key: \`strapi-\${pageName}-collection-\${collectionName}\`,
+        query: {
+          populate: '*',
+        },
+        transform: (response) => {
+          const data = response?.data || response || [];
+          if (Array.isArray(data)) {
+            return data.map((item) => transformStrapiImages(item, strapiUrl));
+          }
+          return transformStrapiImages(data, strapiUrl);
+        },
+      }
+    )
+  );
+
   // Initialize editor state with Strapi data when fetched
   // This runs in both normal AND preview mode to ensure initial content is available
   watch(
@@ -558,12 +718,25 @@ export function useStrapiContent(pageName: string) {
   // In preview mode: use editor state
   // In normal mode: use Strapi data (and sync to editor state)
   const content = computed(() => {
+    const collections = Object.fromEntries(
+      collectionNames.map((collectionName, index) => [
+        collectionName,
+        collectionFetches[index]?.data.value || []
+      ])
+    );
+
     if (editorContent.isPreviewMode.value) {
       // Use editor state in preview mode
-      return editorContent.getPageContent(pageName);
+      return {
+        ...editorContent.getPageContent(pageName),
+        ...collections,
+      };
     } else {
       // Use Strapi data in normal mode
-      return strapiData.value || editorContent.getPageContent(pageName);
+      return {
+        ...(strapiData.value || editorContent.getPageContent(pageName)),
+        ...collections,
+      };
     }
   });
 
@@ -572,11 +745,11 @@ export function useStrapiContent(pageName: string) {
   };
 }
 `;
-  const composablePath = path4.join(composablesDir, "useStrapiContent.ts");
+  const composablePath = path5.join(composablesDir, "useStrapiContent.ts");
   await fs3.writeFile(composablePath, composableContent, "utf-8");
 }
 async function createEditorPlugin(outputDir) {
-  const pluginsDir = path4.join(outputDir, "plugins");
+  const pluginsDir = path5.join(outputDir, "plugins");
   await fs3.ensureDir(pluginsDir);
   const pluginContent = `/**
  * CMS Editor Overlay Plugin
@@ -585,6 +758,8 @@ async function createEditorPlugin(outputDir) {
 
 /**
  * Disable Lenis smooth scroll to allow native scrolling in edit mode
+ * Note: The primary approach is to conditionally render <VueLenis> in the layout.
+ * This function serves as a fallback for existing projects that haven't been updated.
  */
 function disableLenisInEditMode() {
   try {
@@ -592,28 +767,48 @@ function disableLenisInEditMode() {
     const lenisInstances = [
       (window as any).lenis,
       (window as any).__lenis,
-      document.querySelector('.lenis'),
+      (window as any).Lenis,
     ];
 
     for (const lenis of lenisInstances) {
+      if (lenis && typeof lenis.stop === 'function') {
+        lenis.stop();
+      }
       if (lenis && typeof lenis.destroy === 'function') {
         lenis.destroy();
         return;
       }
     }
 
-    // Check for Vue Lenis component instances
-    const lenisElements = document.querySelectorAll('[data-lenis], .lenis');
-    if (lenisElements.length > 0) {
-      // Try to find and destroy via data attributes or component instances
-      lenisElements.forEach((el: any) => {
-        if (el.__lenis && typeof el.__lenis.destroy === 'function') {
-          el.__lenis.destroy();
+    // Check for Vue Lenis component instances via refs
+    // VueLenis stores the instance in the component's exposed properties
+    const lenisElements = document.querySelectorAll('[data-lenis], .lenis, [data-lenis-prevent]');
+    lenisElements.forEach((el: any) => {
+      // Try various ways Vue Lenis might store the instance
+      const possibleInstances = [
+        el.__lenis,
+        el._lenis,
+        el.$lenis,
+        el.__vue__?.exposed?.lenis,
+        el.__vueParentComponent?.exposed?.lenis,
+      ];
+
+      for (const instance of possibleInstances) {
+        if (instance && typeof instance.stop === 'function') {
+          instance.stop();
         }
-      });
-    }
+        if (instance && typeof instance.destroy === 'function') {
+          instance.destroy();
+          return;
+        }
+      }
+    });
+
+    // Also remove lenis-related classes from html/body that might affect scrolling
+    document.documentElement.classList.remove('lenis', 'lenis-smooth');
+    document.body.classList.remove('lenis', 'lenis-smooth');
   } catch (error) {
-    // Silently fail - Lenis may not be present
+    // Silently fail - Lenis may not be present or already disabled via layout
   }
 }
 
@@ -747,11 +942,11 @@ export default defineNuxtPlugin(async (nuxtApp) => {
   });
 });
 `;
-  const pluginPath = path4.join(pluginsDir, "cms-editor.client.ts");
+  const pluginPath = path5.join(pluginsDir, "cms-editor.client.ts");
   await fs3.writeFile(pluginPath, pluginContent, "utf-8");
 }
 async function addEditorDependency(outputDir) {
-  const packageJsonPath = path4.join(outputDir, "package.json");
+  const packageJsonPath = path5.join(outputDir, "package.json");
   if (await fs3.pathExists(packageJsonPath)) {
     const packageJson = await fs3.readJson(packageJsonPath);
     if (!packageJson.dependencies) {
@@ -762,7 +957,7 @@ async function addEditorDependency(outputDir) {
   }
 }
 async function createSaveEndpoint(outputDir) {
-  const serverDir = path4.join(outputDir, "server", "api", "cms");
+  const serverDir = path5.join(outputDir, "server", "api", "cms");
   await fs3.ensureDir(serverDir);
   const endpointContent = `/**
  * API endpoint for saving CMS changes
@@ -824,7 +1019,7 @@ export default defineEventHandler(async (event) => {
     }
 
     // Load manifest to understand field mappings
-    const manifestPath = path.join(process.cwd(), 'cms-manifest.json');
+    const manifestPath = path.join(process.cwd(), 'public', 'cms-manifest.json');
     let manifest;
     try {
       const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
@@ -959,11 +1154,11 @@ export default defineEventHandler(async (event) => {
   }
 });
 `;
-  const endpointPath = path4.join(serverDir, "save.post.ts");
+  const endpointPath = path5.join(serverDir, "save.post.ts");
   await fs3.writeFile(endpointPath, endpointContent, "utf-8");
 }
 async function createStrapiBootstrap(outputDir) {
-  const strapiBootstrapDir = path4.join(outputDir, "strapi-bootstrap");
+  const strapiBootstrapDir = path5.join(outputDir, "strapi-bootstrap");
   await fs3.ensureDir(strapiBootstrapDir);
   const bootstrapContent = `/**
  * Strapi Bootstrap File
@@ -1078,7 +1273,7 @@ export default {
   },
 };
 `;
-  const bootstrapPath = path4.join(strapiBootstrapDir, "index.ts");
+  const bootstrapPath = path5.join(strapiBootstrapDir, "index.ts");
   await fs3.writeFile(bootstrapPath, bootstrapContent, "utf-8");
   const readmeContent = `# Strapi Bootstrap File
 
@@ -1128,12 +1323,12 @@ If you prefer to set permissions manually:
 - Only affects the "Public" role (unauthenticated users)
 - Safe to run multiple times (idempotent)
 `;
-  const readmePath = path4.join(strapiBootstrapDir, "README.md");
+  const readmePath = path5.join(strapiBootstrapDir, "README.md");
   await fs3.writeFile(readmePath, readmeContent, "utf-8");
   console.log("  \u2713 Generated Strapi bootstrap file");
 }
 async function createPublishEndpoint(outputDir) {
-  const serverDir = path4.join(outputDir, "server", "api", "cms");
+  const serverDir = path5.join(outputDir, "server", "api", "cms");
   await fs3.ensureDir(serverDir);
   const endpointContent = `/**
  * API endpoint for batch publishing CMS changes
@@ -1195,7 +1390,7 @@ export default defineEventHandler(async (event) => {
     }
 
     // Load manifest to understand field mappings
-    const manifestPath = path.join(process.cwd(), 'cms-manifest.json');
+    const manifestPath = path.join(process.cwd(), 'public', 'cms-manifest.json');
     let manifest;
     try {
       const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
@@ -1352,13 +1547,335 @@ export default defineEventHandler(async (event) => {
   }
 });
 `;
-  const endpointPath = path4.join(serverDir, "publish.post.ts");
+  const endpointPath = path5.join(serverDir, "publish.post.ts");
   await fs3.writeFile(endpointPath, endpointContent, "utf-8");
 }
+async function createAstroStrapiContentComposable(outputDir, manifest) {
+  const composablesDir = path5.join(outputDir, "src", "composables");
+  await fs3.ensureDir(composablesDir);
+  const pageCollections = JSON.stringify(getPageCollections(manifest), null, 2);
+  const content = `import { computed, reactive, ref, onMounted } from 'vue';
+
+const PAGE_COLLECTIONS: Record<string, string[]> = ${pageCollections};
+
+const editorState = reactive<{
+  content: Record<string, Record<string, any>>;
+  hasChanges: Record<string, boolean>;
+}>({
+  content: {},
+  hasChanges: {},
+});
+
+function getStrapiUrl() {
+  return import.meta.env.PUBLIC_STRAPI_URL || 'http://localhost:1337';
+}
+
+function transformStrapiImages(data: any, baseUrl: string): any {
+  if (!data || typeof data !== 'object') return data;
+  if (Array.isArray(data)) return data.map((item) => transformStrapiImages(item, baseUrl));
+  if ('url' in data && ('mime' in data || 'formats' in data)) {
+    return data.url.startsWith('http') ? data.url : \`\${baseUrl}\${data.url}\`;
+  }
+
+  const transformed: Record<string, any> = {};
+  for (const [key, value] of Object.entries(data)) {
+    transformed[key] = transformStrapiImages(value, baseUrl);
+  }
+  return transformed;
+}
+
+export function useStrapiContent(pageName: string) {
+  const strapiUrl = getStrapiUrl();
+  const strapiData = ref<Record<string, any>>({});
+  const isPreviewMode = typeof window !== 'undefined' && new URLSearchParams(window.location.search).get('preview') === 'true';
+  const collectionNames = PAGE_COLLECTIONS[pageName] || [];
+
+  function initializePageContent(page: string, content: Record<string, any>) {
+    if (!editorState.content[page]) {
+      editorState.content[page] = { ...content };
+    }
+  }
+
+  function getPageContent(page: string) {
+    return editorState.content[page] || {};
+  }
+
+  function updateField(page: string, fieldName: string, value: any) {
+    if (!editorState.content[page]) editorState.content[page] = {};
+    editorState.content[page][fieldName] = value;
+    editorState.hasChanges[page] = true;
+  }
+
+  onMounted(async () => {
+    try {
+      const response = await fetch(\`\${strapiUrl}/api/\${pageName}?populate=*\`);
+      if (!response.ok) return;
+      const json = await response.json();
+      const data = transformStrapiImages(json?.data || json, strapiUrl);
+      const collections = Object.fromEntries(
+        await Promise.all(collectionNames.map(async (collectionName) => {
+          const collectionResponse = await fetch(\`\${strapiUrl}/api/\${collectionName}?populate=*\`);
+          if (!collectionResponse.ok) return [collectionName, []];
+          const collectionJson = await collectionResponse.json();
+          const collectionData = collectionJson?.data || collectionJson || [];
+          return [
+            collectionName,
+            Array.isArray(collectionData)
+              ? collectionData.map((item) => transformStrapiImages(item, strapiUrl))
+              : transformStrapiImages(collectionData, strapiUrl)
+          ];
+        }))
+      );
+      strapiData.value = { ...(data || {}), ...collections };
+      initializePageContent(pageName, strapiData.value);
+    } catch (error) {
+      console.error('[SeeMS] Failed to fetch Strapi content', error);
+    }
+
+    (window as any).__editorState = {
+      ...editorState,
+      getPageContent,
+      updateField,
+      initializePageContent,
+    };
+  });
+
+  const content = computed(() => {
+    return isPreviewMode ? getPageContent(pageName) : (strapiData.value || getPageContent(pageName));
+  });
+
+  return { content };
+}
+`;
+  await fs3.writeFile(path5.join(composablesDir, "useStrapiContent.ts"), content, "utf-8");
+}
+async function createAstroEditorClient(outputDir) {
+  const srcDir = path5.join(outputDir, "src");
+  await fs3.ensureDir(srcDir);
+  const content = `/**
+ * Astro client entry for the SeeMS inline editor.
+ */
+async function initSeeMSEditor() {
+  const params = new URLSearchParams(window.location.search);
+  if (params.get('preview') !== 'true') return;
+
+  const {
+    initEditor,
+    createAuthManager,
+    showLoginModal,
+    createDraftStorage,
+    createURLStateManager,
+    createManifestLoader,
+    createNavigationGuard,
+    getCurrentPageFromRoute,
+    createToolbar,
+  } = await import('@see-ms/editor-overlay');
+
+  const strapiUrl = import.meta.env.PUBLIC_STRAPI_URL || 'http://localhost:1337';
+  const urlState = createURLStateManager();
+  urlState.setState({ preview: true });
+
+  const authManager = createAuthManager({
+    strapiUrl,
+    storageKey: 'cms_editor_token',
+  });
+  const draftStorage = createDraftStorage();
+  const manifestLoader = createManifestLoader();
+
+  try {
+    await manifestLoader.load();
+  } catch (error) {
+    console.error('[CMS Editor] Failed to load manifest:', error);
+    return;
+  }
+
+  let currentPage = getCurrentPageFromRoute();
+  if (!currentPage) {
+    currentPage = manifestLoader.getPageFromRoute(window.location.pathname);
+  }
+  if (!currentPage) {
+    console.error('[CMS Editor] Could not determine current page');
+    return;
+  }
+
+  let token = authManager.getToken();
+  if (!token || !await authManager.verifyToken(token)) {
+    try {
+      token = await showLoginModal(authManager);
+    } catch {
+      urlState.clearPreviewMode();
+      return;
+    }
+  }
+
+  const navigationGuard = createNavigationGuard({
+    showToast: true,
+    toastMessage: 'Navigation disabled in edit mode',
+  });
+  navigationGuard.enable();
+
+  const editor = initEditor({
+    apiEndpoint: '/api/cms/save',
+    authToken: token,
+    richText: true,
+    manifestLoader,
+    draftStorage,
+    currentPage,
+  });
+
+  await editor.enable();
+
+  const toolbar = await createToolbar(editor, {
+    draftStorage,
+    urlState,
+    navigationGuard,
+    manifestLoader,
+    currentPage,
+  });
+  document.body.appendChild(toolbar);
+}
+
+if (document.readyState === 'loading') {
+  document.addEventListener('DOMContentLoaded', initSeeMSEditor, { once: true });
+} else {
+  initSeeMSEditor();
+}
+`;
+  await fs3.writeFile(path5.join(srcDir, "cms-editor.ts"), content, "utf-8");
+}
+async function createAstroSaveEndpoint(outputDir) {
+  const endpointDir = path5.join(outputDir, "src", "pages", "api", "cms");
+  await fs3.ensureDir(endpointDir);
+  await fs3.writeFile(path5.join(endpointDir, "save.ts"), astroEndpointContent(false), "utf-8");
+  await fs3.writeFile(path5.join(endpointDir, "publish.ts"), astroEndpointContent(true), "utf-8");
+}
+function astroEndpointContent(batchPublish) {
+  return `import type { APIRoute } from 'astro';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const prerender = false;
+
+const strapiUrl = import.meta.env.PUBLIC_STRAPI_URL || 'http://localhost:1337';
+
+function json(status: number, body: unknown) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+async function verifyToken(token: string) {
+  const adminResponse = await fetch(\`\${strapiUrl}/admin/users/me\`, {
+    headers: { Authorization: \`Bearer \${token}\` },
+  });
+  if (adminResponse.ok) return { user: await adminResponse.json(), isAdminToken: true };
+
+  const userResponse = await fetch(\`\${strapiUrl}/api/users/me\`, {
+    headers: { Authorization: \`Bearer \${token}\` },
+  });
+  if (userResponse.ok) return { user: await userResponse.json(), isAdminToken: false };
+
+  throw new Error('Invalid or expired token');
+}
+
+function loadManifest() {
+  const manifestPath = path.join(process.cwd(), 'public', 'cms-manifest.json');
+  return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+}
+
+function filterFields(pageConfig: any, fields: Record<string, any>) {
+  const data: Record<string, any> = {};
+  for (const [fieldName, value] of Object.entries(fields || {})) {
+    if (pageConfig?.fields?.[fieldName]) data[fieldName] = value;
+  }
+  return data;
+}
+
+async function writePage(page: string, fields: Record<string, any>, token: string, isAdminToken: boolean, publish: boolean) {
+  const manifest = loadManifest();
+  const pageConfig = manifest.pages[page];
+  if (!pageConfig) throw new Error(\`Page "\${page}" not found in manifest\`);
+  const data = filterFields(pageConfig, fields);
+
+  if (isAdminToken) {
+    const endpoint = \`\${strapiUrl}/content-manager/single-types/api::\${page}.\${page}\`;
+    const update = await fetch(endpoint, {
+      method: 'PUT',
+      headers: { Authorization: \`Bearer \${token}\`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+    });
+    if (!update.ok) throw new Error(await update.text());
+
+    if (publish) {
+      const publishResponse = await fetch(\`\${endpoint}/actions/publish\`, {
+        method: 'POST',
+        headers: { Authorization: \`Bearer \${token}\`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+      });
+      if (!publishResponse.ok) throw new Error(await publishResponse.text());
+    }
+    return;
+  }
+
+  const update = await fetch(\`\${strapiUrl}/api/\${page}\`, {
+    method: 'PUT',
+    headers: { Authorization: \`Bearer \${token}\`, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ data }),
+  });
+  if (!update.ok) throw new Error(await update.text());
+
+  if (publish) {
+    const publishResponse = await fetch(\`\${strapiUrl}/api/\${page}/publish\`, {
+      method: 'POST',
+      headers: { Authorization: \`Bearer \${token}\`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({}),
+    });
+    if (!publishResponse.ok) throw new Error(await publishResponse.text());
+  }
+}
+
+export const POST: APIRoute = async ({ request }) => {
+  const authHeader = request.headers.get('authorization');
+  if (!authHeader?.startsWith('Bearer ')) {
+    return json(401, { success: false, message: 'Missing authorization header' });
+  }
+
+  const token = authHeader.slice(7);
+  try {
+    const { user, isAdminToken } = await verifyToken(token);
+    const body = await request.json();
+${batchPublish ? `    const pages = Array.isArray(body.pages) ? body.pages : [];
+    const results = await Promise.allSettled(
+      pages.map(({ page, fields }: any) => writePage(page, fields, token, isAdminToken, true))
+    );
+    const failed = results
+      .map((result, index) => ({ result, page: pages[index]?.page }))
+      .filter(({ result }) => result.status === 'rejected')
+      .map(({ result, page }) => ({ page, error: result.status === 'rejected' ? result.reason?.message : 'Unknown error' }));
+    return json(200, {
+      success: failed.length === 0,
+      message: \`Published \${pages.length - failed.length} of \${pages.length} pages\`,
+      failed,
+      user,
+    });` : `    if (!body.page || !body.fields) {
+      return json(400, { success: false, message: 'Missing page or fields' });
+    }
+    await writePage(body.page, body.fields, token, isAdminToken, body.isDraft === false);
+    return json(200, { success: true, message: 'Changes saved successfully', page: body.page, isDraft: body.isDraft !== false, user });`}
+  } catch (error: any) {
+    return json(error.message === 'Invalid or expired token' ? 401 : 500, {
+      success: false,
+      message: error.message || 'Failed to save CMS changes',
+    });
+  }
+};
+`;
+}
 
 // src/boilerplate.ts
 import fs4 from "fs-extra";
-import path5 from "path";
+import path6 from "path";
 import { execSync as execSync2 } from "child_process";
 import pc2 from "picocolors";
 function isGitHubURL(source) {
@@ -1368,7 +1885,7 @@ async function cloneFromGitHub(repoUrl, outputDir) {
   console.log(pc2.blue("  Cloning from GitHub..."));
   try {
     execSync2(`git clone ${repoUrl} ${outputDir}`, { stdio: "inherit" });
-    const gitDir = path5.join(outputDir, ".git");
+    const gitDir = path6.join(outputDir, ".git");
     await fs4.remove(gitDir);
     console.log(pc2.green("  \u2713 Boilerplate cloned successfully"));
   } catch (error) {
@@ -1383,30 +1900,88 @@ async function copyFromLocal(sourcePath, outputDir) {
   }
   await fs4.copy(sourcePath, outputDir, {
     filter: (src) => {
-      const name = path5.basename(src);
+      const name = path6.basename(src);
       return !["node_modules", ".nuxt", ".output", ".git", "dist"].includes(name);
     }
   });
   console.log(pc2.green("  \u2713 Boilerplate copied successfully"));
 }
-async function setupBoilerplate(boilerplateSource, outputDir) {
+async function setupBoilerplate(boilerplateSource, outputDir, target = "nuxt") {
   if (!boilerplateSource) {
-    console.log(pc2.blue("\n\u{1F4E6} Creating minimal Nuxt structure..."));
+    console.log(pc2.blue(`
+\u{1F4E6} Creating minimal ${target === "astro-vue" ? "Astro + Vue" : "Nuxt"} structure...`));
     await fs4.ensureDir(outputDir);
-    await fs4.ensureDir(path5.join(outputDir, "pages"));
-    await fs4.ensureDir(path5.join(outputDir, "assets"));
-    await fs4.ensureDir(path5.join(outputDir, "public"));
-    await fs4.ensureDir(path5.join(outputDir, "utils"));
-    const configPath = path5.join(outputDir, "nuxt.config.ts");
+    await fs4.ensureDir(target === "astro-vue" ? path6.join(outputDir, "src", "pages") : path6.join(outputDir, "pages"));
+    await fs4.ensureDir(path6.join(outputDir, "assets"));
+    await fs4.ensureDir(path6.join(outputDir, "public"));
+    await fs4.ensureDir(path6.join(outputDir, "utils"));
+    const configPath = path6.join(outputDir, target === "astro-vue" ? "astro.config.mjs" : "nuxt.config.ts");
     const configExists = await fs4.pathExists(configPath);
     if (!configExists) {
-      const basicConfig = `export default defineNuxtConfig({
+      const basicConfig = target === "astro-vue" ? `import { defineConfig } from 'astro/config';
+import vue from '@astrojs/vue';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export default defineConfig({
+  integrations: [vue()],
+  vite: {
+    resolve: {
+      alias: {
+        '~': path.dirname(fileURLToPath(import.meta.url)),
+      },
+    },
+  },
+});
+` : `export default defineNuxtConfig({
   devtools: { enabled: true },
   css: [],
 })
 `;
       await fs4.writeFile(configPath, basicConfig, "utf-8");
     }
+    const packageJsonPath = path6.join(outputDir, "package.json");
+    const packageJsonExists = await fs4.pathExists(packageJsonPath);
+    if (!packageJsonExists) {
+      const packageName = path6.basename(outputDir) || (target === "astro-vue" ? "see-ms-astro-site" : "see-ms-nuxt-site");
+      await fs4.writeJson(packageJsonPath, target === "astro-vue" ? {
+        name: packageName,
+        private: true,
+        type: "module",
+        scripts: {
+          dev: "astro dev",
+          build: "astro build",
+          preview: "astro preview"
+        },
+        dependencies: {
+          "@astrojs/vue": "^5.0.0",
+          astro: "^5.0.0",
+          vue: "^3.5.14"
+        },
+        devDependencies: {
+          typescript: "^5.8.3"
+        }
+      } : {
+        name: packageName,
+        private: true,
+        type: "module",
+        scripts: {
+          dev: "nuxt dev",
+          build: "nuxt build",
+          generate: "nuxt generate",
+          preview: "nuxt preview",
+          postinstall: "nuxt prepare"
+        },
+        dependencies: {
+          nuxt: "^3.17.4",
+          vue: "^3.5.14",
+          "vue-router": "^4.5.1"
+        },
+        devDependencies: {
+          typescript: "^5.8.3"
+        }
+      }, { spaces: 2 });
+    }
     console.log(pc2.green("  \u2713 Structure created"));
     return;
   }
@@ -1424,15 +1999,95 @@ async function setupBoilerplate(boilerplateSource, outputDir) {
 
 // src/manifest.ts
 import fs6 from "fs-extra";
-import path7 from "path";
+import path9 from "path";
 
 // src/detector.ts
 import * as cheerio2 from "cheerio";
 import fs5 from "fs-extra";
-import path6 from "path";
-function cleanClassName(className) {
-  return className.split(" ").filter((cls) => !cls.startsWith("c-") && !cls.startsWith("w-")).filter((cls) => cls.length > 0).join(" ");
-}
+import path8 from "path";
+import { glob as glob2 } from "glob";
+
+// src/routes.ts
+import path7 from "path";
+function htmlPathToPageId(htmlPath) {
+  const withoutExt = htmlPath.replace(/\.html$/i, "");
+  return withoutExt.replace(/[\\/]/g, "-");
+}
+function htmlPathToRoute(htmlPath) {
+  const normalized = htmlPath.replace(/\\/g, "/").replace(/\.html$/i, "");
+  if (normalized === "index" || normalized.endsWith("/index")) {
+    const parent = normalized.replace(/(^|\/)index$/, "");
+    return parent ? `/${parent}` : "/";
+  }
+  return `/${normalized}`;
+}
+function htmlPathToVuePath(htmlPath) {
+  return htmlPath.replace(/\.html$/i, ".vue");
+}
+function getPageRouteInfo(htmlPath) {
+  return {
+    sourcePath: htmlPath,
+    pageId: htmlPathToPageId(htmlPath),
+    route: htmlPathToRoute(htmlPath),
+    outputPath: path7.posix.join("pages", htmlPathToVuePath(htmlPath).replace(/\\/g, "/"))
+  };
+}
+
+// src/detector.ts
+var TEXT_SELECTORS = [
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "p",
+  "span",
+  "li",
+  "blockquote",
+  "figcaption",
+  "label",
+  "td",
+  "th",
+  "dt",
+  "dd",
+  "cite",
+  "q"
+  // div is NOT included here - handled separately to only detect text-only divs
+];
+var IGNORE_PATTERNS = [
+  ".sr-only",
+  ".visually-hidden",
+  '[aria-hidden="true"]',
+  "script",
+  "style",
+  "noscript",
+  "template"
+];
+var DECORATIVE_CLASS_PATTERNS = [
+  "icon",
+  "arrow",
+  "pagination",
+  "breadcrumb",
+  "loader",
+  "spinner",
+  "skeleton",
+  "placeholder"
+];
+function isCollectionClass(className, customClasses) {
+  if (!customClasses || customClasses.length === 0) return false;
+  const normalizedName = className.toLowerCase().replace(/-/g, "_");
+  for (const customClass of customClasses) {
+    const normalizedCustom = customClass.toLowerCase().replace(/-/g, "_");
+    if (normalizedName === normalizedCustom || normalizedName.includes(normalizedCustom)) {
+      return true;
+    }
+  }
+  return false;
+}
+function cleanClassName(className) {
+  return className.split(" ").filter((cls) => !cls.startsWith("c-") && !cls.startsWith("w-")).filter((cls) => cls.length > 0).join(" ");
+}
 function getPrimaryClass(classAttr) {
   if (!classAttr) return null;
   const cleaned = cleanClassName(classAttr);
@@ -1446,22 +2101,6 @@ function getPrimaryClass(classAttr) {
     // Normalize for field name
   };
 }
-function getContextModifier(_$, $el) {
-  let $current = $el.parent();
-  let depth = 0;
-  while ($current.length > 0 && depth < 5) {
-    const classes = $current.attr("class");
-    if (classes) {
-      const ccClass = classes.split(" ").find((c) => c.startsWith("cc-"));
-      if (ccClass) {
-        return ccClass.replace("cc-", "").replace(/-/g, "_");
-      }
-    }
-    $current = $current.parent();
-    depth++;
-  }
-  return null;
-}
 function isDecorativeImage(_$, $img) {
   const $parent = $img.parent();
   const parentClass = $parent.attr("class") || "";
@@ -1482,9 +2121,136 @@ function isDecorativeImage(_$, $img) {
 }
 function isInsideButton($, el) {
   const $el = $(el);
-  const $button = $el.closest("button, a, NuxtLink, .c_button, .c_icon_button");
+  const $button = $el.closest("button, a, NuxtLink, nuxt-link, .c_button, .c_icon_button");
   return $button.length > 0;
 }
+function shouldIgnoreElement(_$, $el, options = {}) {
+  if ($el.attr("data-cms-ignore") !== void 0) return true;
+  for (const pattern of IGNORE_PATTERNS) {
+    if ($el.is(pattern)) return true;
+    if ($el.closest(pattern).length > 0) return true;
+  }
+  for (const selector of options.ignoreSelectors || []) {
+    if ($el.is(selector)) return true;
+    if ($el.closest(selector).length > 0) return true;
+  }
+  const className = $el.attr("class") || "";
+  for (const ignoredClass of options.ignoreClasses || []) {
+    if (className.split(/\s+/).includes(ignoredClass)) return true;
+  }
+  for (const pattern of DECORATIVE_CLASS_PATTERNS) {
+    if (className.toLowerCase().includes(pattern)) return true;
+  }
+  return false;
+}
+function isEditableLeaf($el) {
+  if ($el.children().length > 0) {
+    return false;
+  }
+  const text = $el.text().trim();
+  if (text.length === 0) {
+    return false;
+  }
+  return true;
+}
+var globalFieldIndex = 0;
+function resetGlobalFieldIndex() {
+  globalFieldIndex = 0;
+}
+function generateFieldName(_$, $el, elementType, _index) {
+  const dataCms = $el.attr("data-cms");
+  if (dataCms) return dataCms.replace(/-/g, "_");
+  const id = $el.attr("id");
+  if (id) return id.replace(/-/g, "_");
+  const ariaLabel = $el.attr("aria-label");
+  if (ariaLabel) return ariaLabel.replace(/[^a-zA-Z0-9]+/g, "_").toLowerCase();
+  const classInfo = getPrimaryClass($el.attr("class"));
+  if (classInfo && !classInfo.fieldName.startsWith("w_") && !classInfo.fieldName.startsWith("c_")) {
+    return classInfo.fieldName;
+  }
+  const $parent = $el.parent();
+  const parentClassInfo = getPrimaryClass($parent.attr("class"));
+  if (parentClassInfo && !parentClassInfo.fieldName.startsWith("w_") && !parentClassInfo.fieldName.startsWith("c_")) {
+    return `${parentClassInfo.fieldName}_${elementType}`;
+  }
+  const $section = $el.closest('section, [class*="section"], [class*="hero"], [class*="cta"], [class*="about"]').first();
+  const sectionClassInfo = getPrimaryClass($section.attr("class"));
+  if (sectionClassInfo && $section.length > 0) {
+    return `${sectionClassInfo.fieldName}_${elementType}`;
+  }
+  const text = $el.text().trim();
+  if (text.length > 0 && text.length < 50) {
+    const words = text.split(/\s+/).slice(0, 3);
+    const contentName = words.join("_").toLowerCase().replace(/[^a-z0-9_]/g, "");
+    if (contentName.length > 2 && contentName.length < 30) {
+      return `${elementType}_${contentName}`;
+    }
+  }
+  return `${elementType}_${globalFieldIndex++}`;
+}
+function buildUniqueSelector($, $el) {
+  const tag = ($el.prop("tagName") || "div").toLowerCase();
+  const id = $el.attr("id");
+  if (id) {
+    const selector = `#${id}`;
+    if ($(selector).length === 1) return selector;
+  }
+  const dataCms = $el.attr("data-cms");
+  if (dataCms) {
+    const selector = `[data-cms="${dataCms}"]`;
+    if ($(selector).length === 1) return selector;
+  }
+  const className = $el.attr("class");
+  if (className) {
+    const classes = className.split(" ").filter((c) => c.length > 2 && !c.startsWith("w-"));
+    for (const cls of classes) {
+      const selector = `.${cls}`;
+      if ($(selector).length === 1) return selector;
+    }
+    for (const cls of classes) {
+      const selector = `${tag}.${cls}`;
+      if ($(selector).length === 1) return selector;
+    }
+    for (let i = 2; i <= Math.min(classes.length, 3); i++) {
+      const combo = classes.slice(0, i).map((c) => `.${c}`).join("");
+      if ($(combo).length === 1) return combo;
+    }
+  }
+  return buildFullPath($, $el);
+}
+function buildFullPath(_$, $el) {
+  const parts = [];
+  let current = $el;
+  while (current.length && current.prop("tagName")) {
+    const tag = (current.prop("tagName") || "").toLowerCase();
+    if (!tag || tag === "html" || tag === "body") break;
+    const $parent = current.parent();
+    const $siblings = $parent.children(tag);
+    let part = tag;
+    if ($siblings.length > 1) {
+      const index = $siblings.index(current) + 1;
+      part = `${tag}:nth-of-type(${index})`;
+    }
+    parts.unshift(part);
+    current = $parent;
+    if (parts.length >= 4) break;
+  }
+  return parts.join(" > ");
+}
+function determineFieldType($el, tagName) {
+  const dataCmsType = $el.attr("data-cms-type");
+  if (dataCmsType) return dataCmsType;
+  const hasFormatting = $el.find("strong, em, b, i, br, a").length > 0;
+  const innerHTML = $el.html() || "";
+  const hasHtmlTags = /<[^>]+>/.test(innerHTML);
+  if (hasFormatting || hasHtmlTags) {
+    return "rich";
+  }
+  if (tagName === "a" || tagName === "nuxt-link" || $el.is("NuxtLink")) {
+    return "link";
+  }
+  return "plain";
+}
 function extractTemplateFromVue(vueContent) {
   const templateMatch = vueContent.match(/<template>([\s\S]*?)<\/template>/);
   if (!templateMatch) {
@@ -1492,27 +2258,68 @@ function extractTemplateFromVue(vueContent) {
   }
   return templateMatch[1];
 }
-function detectEditableFields(templateHtml) {
+function detectEditableFields(templateHtml, options = {}) {
   const $ = cheerio2.load(templateHtml);
   const detectedFields = {};
   const detectedCollections = {};
+  const { collectionClasses, collectionMin = 2, universalDetection = true } = options;
+  resetGlobalFieldIndex();
   const collectionElements = /* @__PURE__ */ new Set();
-  const processedCollectionClasses = /* @__PURE__ */ new Set();
+  const processedElements = /* @__PURE__ */ new Set();
+  const usedFieldNames = /* @__PURE__ */ new Set();
+  const getUniqueFieldName = (baseName) => {
+    let name = baseName;
+    let counter = 1;
+    while (usedFieldNames.has(name)) {
+      name = `${baseName}_${counter++}`;
+    }
+    usedFieldNames.add(name);
+    return name;
+  };
+  $("[data-cms]").each((_, el) => {
+    const $el = $(el);
+    if (shouldIgnoreElement($, $el, options)) return;
+    const fieldName = $el.attr("data-cms").replace(/-/g, "_");
+    const tagName = ($el.prop("tagName") || "div").toLowerCase();
+    const fieldType = determineFieldType($el, tagName);
+    const selector = buildUniqueSelector($, $el);
+    detectedFields[getUniqueFieldName(fieldName)] = {
+      selector,
+      type: fieldType,
+      editable: true,
+      source: "attribute"
+    };
+    processedElements.add(el);
+  });
   const potentialCollections = /* @__PURE__ */ new Map();
-  $("[class]").each((_, el) => {
-    const primaryClass = getPrimaryClass($(el).attr("class"));
-    if (primaryClass && (primaryClass.fieldName.includes("card") || primaryClass.fieldName.includes("item") || primaryClass.fieldName.includes("post") || primaryClass.fieldName.includes("feature")) && !primaryClass.fieldName.includes("image") && !primaryClass.fieldName.includes("inner")) {
-      if (!potentialCollections.has(primaryClass.fieldName)) {
-        potentialCollections.set(primaryClass.fieldName, []);
-      }
-      potentialCollections.get(primaryClass.fieldName)?.push(el);
+  $("[data-cms-collection]").each((_, el) => {
+    const $el = $(el);
+    const collectionName = $el.attr("data-cms-collection");
+    const normalizedName = collectionName.replace(/-/g, "_");
+    if (!potentialCollections.has(normalizedName)) {
+      potentialCollections.set(normalizedName, []);
     }
+    potentialCollections.get(normalizedName)?.push(el);
   });
+  if (collectionClasses && collectionClasses.length > 0) {
+    $("[class]").each((_, el) => {
+      const primaryClass = getPrimaryClass($(el).attr("class"));
+      if (!primaryClass) return;
+      if (primaryClass.fieldName.includes("image")) return;
+      if (primaryClass.fieldName.includes("inner")) return;
+      if (primaryClass.fieldName.includes("wrapper") && !primaryClass.fieldName.includes("card")) return;
+      if (isCollectionClass(primaryClass.fieldName, collectionClasses)) {
+        if (!potentialCollections.has(primaryClass.fieldName)) {
+          potentialCollections.set(primaryClass.fieldName, []);
+        }
+        potentialCollections.get(primaryClass.fieldName)?.push(el);
+      }
+    });
+  }
   potentialCollections.forEach((elements, className) => {
-    if (elements.length >= 2) {
+    if (elements.length >= collectionMin) {
       const $first = $(elements[0]);
       const collectionFields = {};
-      processedCollectionClasses.add(className);
       elements.forEach((el) => {
         collectionElements.add(el);
         $(el).find("*").each((_, child) => {
@@ -1527,36 +2334,35 @@ function detectEditableFields(templateHtml) {
         const $parent = $img.parent();
         const parentClassInfo = getPrimaryClass($parent.attr("class"));
         if (parentClassInfo && parentClassInfo.fieldName.includes("image")) {
-          collectionFields.image = `.${parentClassInfo.selector}`;
+          collectionFields.image = { selector: `.${parentClassInfo.selector}`, type: "image", attribute: "src" };
+          return false;
+        } else {
+          collectionFields.image = { selector: "img", type: "image", attribute: "src" };
           return false;
         }
       });
-      $first.find("div").each((_, el) => {
+      $first.find('[class*="tag"]').not('[class*="container"]').first().each((_, el) => {
         const classInfo = getPrimaryClass($(el).attr("class"));
-        if (classInfo && classInfo.fieldName.includes("tag") && !classInfo.fieldName.includes("container")) {
-          collectionFields.tag = `.${classInfo.selector}`;
-          return false;
+        if (classInfo) {
+          collectionFields.tag = { selector: `.${classInfo.selector}`, type: "plain" };
         }
       });
       $first.find("h1, h2, h3, h4, h5, h6").first().each((_, el) => {
         const classInfo = getPrimaryClass($(el).attr("class"));
-        if (classInfo) {
-          collectionFields.title = `.${classInfo.selector}`;
-        }
+        const selector = classInfo ? `.${classInfo.selector}` : el.tagName?.toLowerCase() || "h2";
+        collectionFields.title = { selector, type: "plain" };
       });
       $first.find("p").first().each((_, el) => {
         const classInfo = getPrimaryClass($(el).attr("class"));
-        if (classInfo) {
-          collectionFields.description = `.${classInfo.selector}`;
-        }
+        const selector = classInfo ? `.${classInfo.selector}` : "p";
+        collectionFields.description = { selector, type: "plain" };
       });
-      $first.find("a, NuxtLink").not(".c_button, .c_icon_button").each((_, el) => {
+      $first.find("a, NuxtLink, nuxt-link").not(".c_button, .c_icon_button").first().each((_, el) => {
         const $link = $(el);
         const linkText = $link.text().trim();
         if (linkText) {
           const classInfo = getPrimaryClass($link.attr("class"));
-          collectionFields.link = classInfo ? `.${classInfo.selector}` : "a";
-          return false;
+          collectionFields.link = { selector: classInfo ? `.${classInfo.selector}` : "a", type: "link", attribute: "href" };
         }
       });
       if (Object.keys(collectionFields).length > 0) {
@@ -1571,103 +2377,102 @@ function detectEditableFields(templateHtml) {
       }
     }
   });
-  const $body = $("body");
-  $body.find("h1, h2, h3, h4, h5, h6").each((index, el) => {
-    if (collectionElements.has(el)) return;
-    const $el = $(el);
-    const text = $el.text().trim();
-    const classInfo = getPrimaryClass($el.attr("class"));
-    if (text) {
-      let fieldName;
-      let selector;
-      if (classInfo && !classInfo.fieldName.startsWith("heading_")) {
-        fieldName = classInfo.fieldName;
-        selector = `.${classInfo.selector}`;
-      } else {
-        const $parent = $el.closest('[class*="header"], [class*="hero"], [class*="cta"]').first();
-        const parentClassInfo = getPrimaryClass($parent.attr("class"));
-        const modifier = getContextModifier($, $el);
-        if (parentClassInfo) {
-          fieldName = modifier ? `${modifier}_${parentClassInfo.fieldName}` : parentClassInfo.fieldName;
-          selector = classInfo ? `.${classInfo.selector}` : `.${parentClassInfo.selector}`;
-        } else if (modifier) {
-          fieldName = `${modifier}_heading`;
-          selector = classInfo ? `.${classInfo.selector}` : el.tagName.toLowerCase();
-        } else {
-          fieldName = `heading_${index}`;
-          selector = classInfo ? `.${classInfo.selector}` : el.tagName.toLowerCase();
-        }
-      }
-      detectedFields[fieldName] = {
+  if (universalDetection) {
+    const $body = $("body");
+    let textIndex = 0;
+    let imageIndex = 0;
+    let linkIndex = 0;
+    const allTextSelectors = [...TEXT_SELECTORS, "div"].join(", ");
+    $body.find(allTextSelectors).each((_, el) => {
+      if (collectionElements.has(el)) return;
+      if (processedElements.has(el)) return;
+      const $el = $(el);
+      if (shouldIgnoreElement($, $el, options)) return;
+      const tagName = ($el.prop("tagName") || "div").toLowerCase();
+      if (tagName === "a" || tagName === "nuxt-link" || $el.is("NuxtLink")) return;
+      if (isInsideButton($, el)) return;
+      if (!isEditableLeaf($el)) return;
+      const fieldName = generateFieldName($, $el, tagName, textIndex++);
+      const fieldType = determineFieldType($el, tagName);
+      const selector = buildUniqueSelector($, $el);
+      detectedFields[getUniqueFieldName(fieldName)] = {
         selector,
-        type: "plain",
-        editable: true
-      };
-    }
-  });
-  $body.find("p").each((_index, el) => {
-    if (collectionElements.has(el)) return;
-    const $el = $(el);
-    const text = $el.text().trim();
-    const classInfo = getPrimaryClass($el.attr("class"));
-    if (text && text.length > 20 && classInfo) {
-      const hasFormatting = $el.find("strong, em, b, i, a, NuxtLink").length > 0;
-      detectedFields[classInfo.fieldName] = {
-        selector: `.${classInfo.selector}`,
-        type: hasFormatting ? "rich" : "plain",
-        editable: true
+        type: fieldType,
+        editable: true,
+        source: "auto"
       };
-    }
-  });
-  $body.find("img").each((_index, el) => {
-    if (collectionElements.has(el)) return;
-    if (isInsideButton($, el)) return;
-    const $el = $(el);
-    if (isDecorativeImage($, $el)) return;
-    const $parent = $el.parent();
-    const parentClassInfo = getPrimaryClass($parent.attr("class"));
-    if (parentClassInfo) {
-      const fieldName = parentClassInfo.fieldName.includes("image") ? parentClassInfo.fieldName : `${parentClassInfo.fieldName}_image`;
-      detectedFields[fieldName] = {
-        selector: `.${parentClassInfo.selector}`,
+      processedElements.add(el);
+    });
+    $body.find("img").each((_, el) => {
+      if (collectionElements.has(el)) return;
+      if (processedElements.has(el)) return;
+      const $el = $(el);
+      if (shouldIgnoreElement($, $el, options)) return;
+      if (isDecorativeImage($, $el)) return;
+      const fieldName = generateFieldName($, $el, "image", imageIndex++);
+      const selector = buildUniqueSelector($, $el);
+      detectedFields[getUniqueFieldName(fieldName)] = {
+        selector,
         type: "image",
-        editable: true
+        editable: true,
+        source: "auto",
+        attribute: "src"
       };
-    }
-  });
-  $body.find("NuxtLink.c_button, a.c_button, .c_button").each((_index, el) => {
-    if (collectionElements.has(el)) return;
-    const $el = $(el);
-    const text = $el.contents().filter(function() {
-      return this.type === "text" || this.type === "tag" && this.name === "div";
-    }).first().text().trim();
-    if (text && text.length > 2) {
-      const $parent = $el.closest('[class*="cta"]').first();
-      const parentClassInfo = getPrimaryClass($parent.attr("class"));
-      const fieldName = parentClassInfo ? `${parentClassInfo.fieldName}_button_text` : "button_text";
-      detectedFields[fieldName] = {
-        selector: `.c_button`,
+      processedElements.add(el);
+    });
+    $body.find("a, NuxtLink, nuxt-link").each((_, el) => {
+      if (collectionElements.has(el)) return;
+      if (processedElements.has(el)) return;
+      const $el = $(el);
+      if (shouldIgnoreElement($, $el, options)) return;
+      const hasOnlyImage = $el.children().length === 1 && $el.find("img").length === 1;
+      const linkText = $el.text().trim();
+      if (!hasOnlyImage && (!linkText || linkText.length < 2)) return;
+      const fieldName = generateFieldName($, $el, "link", linkIndex++);
+      const selector = buildUniqueSelector($, $el);
+      detectedFields[getUniqueFieldName(fieldName)] = {
+        selector,
+        type: "link",
+        editable: true,
+        source: "auto",
+        attribute: "href"
+      };
+      processedElements.add(el);
+    });
+    $body.find('button, .c_button, [class*="button"]').each((_, el) => {
+      if (collectionElements.has(el)) return;
+      if (processedElements.has(el)) return;
+      const $el = $(el);
+      if (shouldIgnoreElement($, $el, options)) return;
+      const text = $el.clone().children().remove().end().text().trim();
+      if (!text || text.length < 2) return;
+      const fieldName = generateFieldName($, $el, "button", textIndex++);
+      const selector = buildUniqueSelector($, $el);
+      detectedFields[getUniqueFieldName(fieldName)] = {
+        selector,
         type: "plain",
-        editable: true
+        editable: true,
+        source: "auto"
       };
-    }
-  });
+      processedElements.add(el);
+    });
+  }
   return {
     fields: detectedFields,
     collections: detectedCollections
   };
 }
-async function analyzeVuePages(pagesDir) {
+async function analyzeVuePages(pagesDir, options = {}) {
   const results = {};
-  const vueFiles = await fs5.readdir(pagesDir);
+  const vueFiles = await glob2("**/*.vue", { cwd: pagesDir, nodir: true });
   for (const file of vueFiles) {
     if (file.endsWith(".vue")) {
-      const filePath = path6.join(pagesDir, file);
+      const filePath = path8.join(pagesDir, file);
       const content = await fs5.readFile(filePath, "utf-8");
       const template = extractTemplateFromVue(content);
       if (template) {
-        const pageName = file.replace(".vue", "");
-        results[pageName] = detectEditableFields(template);
+        const pageName = htmlPathToPageId(file.replace(/\.vue$/i, ".html"));
+        results[pageName] = detectEditableFields(template, options);
       }
     }
   }
@@ -1675,49 +2480,190 @@ async function analyzeVuePages(pagesDir) {
 }
 
 // src/manifest.ts
-async function generateManifest(pagesDir) {
-  const analyzed = await analyzeVuePages(pagesDir);
+async function generateManifest(pagesDir, options = {}) {
+  const collectionItemSelectors = options.sharedComponents?.filter((component) => component.role === "collection-item").map((component) => component.selector) || [];
+  const detectionOptions = {
+    collectionClasses: options.collectionClasses,
+    ignoreSelectors: [
+      ...options.ignoreSelectors || [],
+      ...collectionItemSelectors
+    ],
+    ignoreClasses: options.ignoreClasses
+  };
+  const componentDetectionOptions = {
+    collectionClasses: options.collectionClasses,
+    ignoreSelectors: options.ignoreSelectors,
+    ignoreClasses: options.ignoreClasses
+  };
+  const analyzed = await analyzeVuePages(pagesDir, detectionOptions);
   const pages = {};
   for (const [pageName, detection] of Object.entries(analyzed)) {
+    let collections = detection.collections;
+    if (options.collectionNames && Object.keys(options.collectionNames).length > 0) {
+      collections = {};
+      for (const [collectionKey, collection] of Object.entries(detection.collections)) {
+        let newName = collectionKey;
+        for (const [className, displayName] of Object.entries(options.collectionNames)) {
+          const normalizedClassName = className.replace(/-/g, "_");
+          if (collectionKey.includes(normalizedClassName) || collectionKey === normalizedClassName) {
+            newName = displayName;
+            break;
+          }
+        }
+        collections[newName] = collection;
+      }
+    }
     pages[pageName] = {
       fields: detection.fields,
-      collections: detection.collections,
+      collections,
       meta: {
-        route: pageName === "index" ? "/" : `/${pageName}`
+        route: options.pageRoutes?.[pageName] || (pageName === "index" ? "/" : `/${pageName}`)
       }
     };
   }
   const manifest = {
     version: "1.0",
-    pages
+    pages,
+    global: options.sharedComponents && options.sharedComponents.length > 0 ? {
+      components: Object.fromEntries(
+        options.sharedComponents.map((component) => [component.name, component])
+      )
+    } : void 0,
+    providers: {
+      [options.provider || "strapi"]: {
+        version: "1"
+      }
+    }
   };
+  if (options.sharedComponents?.length && options.componentsDir) {
+    const globalFields = {};
+    const components = manifest.global?.components || {};
+    for (const component of options.sharedComponents) {
+      const componentPath = path9.join(options.componentsDir, `${component.name}.vue`);
+      if (!await fs6.pathExists(componentPath)) continue;
+      const content = await fs6.readFile(componentPath, "utf-8");
+      const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/);
+      if (!templateMatch) continue;
+      const detection = detectEditableFields(templateMatch[1], componentDetectionOptions);
+      const prefixedFields = Object.fromEntries(
+        Object.entries(detection.fields).map(([fieldName, field]) => [
+          `${component.name}_${fieldName}`,
+          field
+        ])
+      );
+      const collectionFields = Object.fromEntries(
+        Object.entries(detection.fields).map(([fieldName, field]) => [
+          fieldName,
+          {
+            selector: field.selector,
+            type: field.type,
+            attribute: field.attribute
+          }
+        ])
+      );
+      const contentMode = component.contentMode || "shared-global";
+      const role = component.role || "shared-section";
+      components[component.name] = {
+        ...component,
+        role,
+        contentMode,
+        fields: role === "collection-item" ? detection.fields : prefixedFields
+      };
+      if (role === "collection-item") {
+        for (const pageId of component.pages || []) {
+          if (!manifest.pages[pageId]) continue;
+          const collectionName = resolveCollectionName(component.collectionName || toCollectionName(component.name), pageId);
+          manifest.pages[pageId].collections = {
+            ...manifest.pages[pageId].collections,
+            [collectionName]: {
+              selector: component.selector,
+              fields: collectionFields,
+              componentName: component.name,
+              storage: component.collectionStorage || "collection-type"
+            }
+          };
+        }
+      } else if (contentMode === "per-page") {
+        for (const pageId of component.pages || []) {
+          if (!manifest.pages[pageId]) continue;
+          manifest.pages[pageId].fields = {
+            ...manifest.pages[pageId].fields,
+            ...prefixedFields
+          };
+        }
+      } else if (contentMode === "shared-global" || contentMode === "auto") {
+        Object.assign(globalFields, prefixedFields);
+      }
+    }
+    if (manifest.global) {
+      manifest.global.components = components;
+      if (Object.keys(globalFields || {}).length > 0) {
+        manifest.global.fields = globalFields;
+      }
+    }
+  }
   return manifest;
 }
+function toCollectionName(name) {
+  const base = name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+  if (base.endsWith("s")) return base;
+  return `${base}s`;
+}
+function resolveCollectionName(collectionName, pageId) {
+  return collectionName === pageId ? `${collectionName}_items` : collectionName;
+}
 async function writeManifest(outputDir, manifest) {
   const manifestContent = JSON.stringify(manifest, null, 2);
-  const manifestPath = path7.join(outputDir, "cms-manifest.json");
-  await fs6.writeFile(manifestPath, manifestContent, "utf-8");
-  const publicDir = path7.join(outputDir, "public");
+  const publicDir = path9.join(outputDir, "public");
   await fs6.ensureDir(publicDir);
-  const publicManifestPath = path7.join(publicDir, "cms-manifest.json");
+  const publicManifestPath = path9.join(publicDir, "cms-manifest.json");
   await fs6.writeFile(publicManifestPath, manifestContent, "utf-8");
 }
 
 // src/vue-transformer.ts
 import * as cheerio3 from "cheerio";
 import fs7 from "fs-extra";
-import path8 from "path";
+import path10 from "path";
+import { glob as glob3 } from "glob";
+function isSafeToEmpty($el) {
+  return $el.children().length === 0;
+}
 function replaceWithBinding(_$, $el, fieldName, type) {
   if (type === "image") {
-    const $img = $el.find("img").first();
-    if ($img.length) {
-      $img.attr(":src", `content.${fieldName}`);
-      $img.removeAttr("src");
+    if ($el.is("img")) {
+      $el.attr(":src", `content.${fieldName}`);
+      $el.removeAttr("src");
+    } else {
+      const $img = $el.find("img").first();
+      if ($img.length) {
+        $img.attr(":src", `content.${fieldName}`);
+        $img.removeAttr("src");
+      }
+    }
+  } else if (type === "link") {
+    const $link = $el.is("a") || $el.is("NuxtLink") || $el.is("nuxt-link") ? $el : $el.find("a, NuxtLink, nuxt-link").first();
+    if ($link.length) {
+      const isNuxtLink = $link.is("NuxtLink") || $link.is("nuxt-link");
+      $link.attr(isNuxtLink ? ":to" : ":href", `content.${fieldName}?.url`);
+      $link.attr(":target", `content.${fieldName}?.newTab ? '_blank' : undefined`);
+      $link.removeAttr("href");
+      if (isNuxtLink) $link.removeAttr("to");
+      $link.removeAttr("target");
+      if (isSafeToEmpty($link)) {
+        $link.empty();
+        $link.text(`{{ content.${fieldName}?.text }}`);
+      }
     }
   } else if (type === "rich") {
+    if (!isSafeToEmpty($el)) {
+      return;
+    }
     $el.attr("v-html", `content.${fieldName}`);
     $el.empty();
   } else {
+    if (!isSafeToEmpty($el)) {
+      return;
+    }
     $el.empty();
     $el.text(`{{ content.${fieldName} }}`);
   }
@@ -1726,21 +2672,43 @@ function transformCollection($, collectionName, collection) {
   const $items = $(collection.selector);
   if ($items.length === 0) return;
   const $first = $items.first();
+  if (collection.componentName) {
+    $first.replaceWith(`<!--COLLECTION_COMPONENT:${collection.componentName}:${collectionName}-->`);
+    $items.slice(1).remove();
+    return;
+  }
   $first.attr("v-for", `(item, index) in content.${collectionName}`);
   $first.attr(":key", "index");
-  Object.entries(collection.fields).forEach(([fieldName, selector]) => {
+  Object.entries(collection.fields).forEach(([fieldName, fieldConfig]) => {
+    const selector = typeof fieldConfig === "string" ? fieldConfig : fieldConfig.selector || fieldConfig;
+    const fieldType = typeof fieldConfig === "object" ? fieldConfig.type : void 0;
     const $fieldEl = $first.find(selector);
     if ($fieldEl.length) {
-      if (fieldName === "image") {
-        const $img = $fieldEl.find("img").first();
-        if ($img.length) {
-          $img.attr(":src", "item.image");
-          $img.removeAttr("src");
+      const isImage = fieldType === "image" || fieldName === "image" || fieldName.includes("image");
+      const isLink = fieldType === "link" || fieldName === "link" || fieldName === "url";
+      if (isImage) {
+        if ($fieldEl.is("img")) {
+          $fieldEl.attr(":src", `item.${fieldName}`);
+          $fieldEl.removeAttr("src");
+        } else {
+          const $img = $fieldEl.find("img").first();
+          if ($img.length) {
+            $img.attr(":src", `item.${fieldName}`);
+            $img.removeAttr("src");
+          }
+        }
+      } else if (isLink) {
+        const $link = $fieldEl.is("a") || $fieldEl.is("NuxtLink") || $fieldEl.is("nuxt-link") ? $fieldEl : $fieldEl.find("a, NuxtLink, nuxt-link").first();
+        if ($link.length) {
+          const isNuxtLink = $link.is("NuxtLink") || $link.is("nuxt-link");
+          $link.attr(isNuxtLink ? ":to" : ":href", `item.${fieldName}?.url`);
+          $link.attr(":target", `item.${fieldName}?.newTab ? '_blank' : undefined`);
+          $link.removeAttr("href");
+          $link.removeAttr("target");
+          $link.removeAttr("to");
+          $link.empty();
+          $link.text(`{{ item.${fieldName}?.text }}`);
         }
-      } else if (fieldName === "link") {
-        $fieldEl.attr(":to", "item.link");
-        $fieldEl.removeAttr("to");
-        $fieldEl.removeAttr("href");
       } else {
         $fieldEl.empty();
         $fieldEl.text(`{{ item.${fieldName} }}`);
@@ -1749,7 +2717,7 @@ function transformCollection($, collectionName, collection) {
   });
   $items.slice(1).remove();
 }
-async function transformVueToReactive(vueFilePath, pageName, manifest) {
+async function transformVueToReactive(vueFilePath, pageName, manifest, options = {}) {
   const pageManifest = manifest.pages[pageName];
   if (!pageManifest) return;
   const vueContent = await fs7.readFile(vueFilePath, "utf-8");
@@ -1759,7 +2727,8 @@ async function transformVueToReactive(vueFilePath, pageName, manifest) {
   }
   const templateMatch = vueContent.match(/<template>([\s\S]*?)<\/template>/);
   if (!templateMatch) return;
-  const templateContent = templateMatch[1];
+  const componentNames = Object.keys(manifest.global?.components || {});
+  const templateContent = maskComponentTags(templateMatch[1], componentNames);
   const $ = cheerio3.load(templateContent, { xmlMode: false });
   if (pageManifest.collections) {
     Object.entries(pageManifest.collections).forEach(([collectionName, collection]) => {
@@ -1785,8 +2754,19 @@ async function transformVueToReactive(vueFilePath, pageName, manifest) {
   if (wrapperDivMatch) {
     transformedTemplate = wrapperDivMatch[1].trim();
   }
+  const perPageComponentNames = componentNames.filter((name) => {
+    const component = manifest.global?.components?.[name];
+    return component?.contentMode === "per-page" && component.pages.includes(pageName);
+  });
+  transformedTemplate = restoreCollectionComponentTags(transformedTemplate);
+  transformedTemplate = restoreComponentTags2(transformedTemplate, componentNames, perPageComponentNames);
+  const explicitImports = options.target === "astro-vue" ? [
+    `import { useStrapiContent } from '~/src/composables/useStrapiContent';`,
+    ...componentNames.map((name) => `import ${name} from '~/components/${name}.vue';`)
+  ].join("\n") : "";
   const scriptSetup = `<script setup lang="ts">
 // Auto-generated reactive content from Strapi
+${explicitImports}
 const { content } = useStrapiContent('${pageName}');
 </script>`;
   const finalTemplate = transformedTemplate.split("\n").map((line) => "  " + line).join("\n");
@@ -1798,29 +2778,129 @@ ${finalTemplate}
 `;
   await fs7.writeFile(vueFilePath, newVueContent, "utf-8");
 }
-async function transformAllVuePages(pagesDir, manifest) {
-  const vueFiles = await fs7.readdir(pagesDir);
+async function transformSharedComponentsToReactive(componentsDir, manifest, options = {}) {
+  const components = manifest.global?.components || {};
+  for (const [componentName, component] of Object.entries(components)) {
+    const fields = component.fields || {};
+    if (Object.keys(fields).length === 0) continue;
+    const filePath = path10.join(componentsDir, `${componentName}.vue`);
+    if (!await fs7.pathExists(filePath)) continue;
+    const vueContent = await fs7.readFile(filePath, "utf-8");
+    const templateMatch = vueContent.match(/<template>([\s\S]*?)<\/template>/);
+    if (!templateMatch) continue;
+    const $ = cheerio3.load(templateMatch[1], { xmlMode: false });
+    const isCollectionItem = component.role === "collection-item";
+    const isPerPage = component.contentMode === "per-page";
+    const contentSource = isCollectionItem ? "item" : isPerPage ? "componentContent" : "content";
+    Object.entries(fields).forEach(([fieldName, field]) => {
+      const originalName = fieldName.startsWith(`${componentName}_`) ? fieldName.slice(componentName.length + 1) : fieldName;
+      const selector = field.selector;
+      $(selector).each((_, el) => {
+        replaceWithBinding($, $(el), fieldName, field.type);
+      });
+      if (originalName !== fieldName) {
+        $(selector).each((_, el) => {
+          replaceWithBinding($, $(el), fieldName, field.type);
+        });
+      }
+    });
+    let transformedTemplate = $.html();
+    const bodyMatch = transformedTemplate.match(/<body>([\s\S]*)<\/body>/);
+    if (bodyMatch) transformedTemplate = bodyMatch[1];
+    transformedTemplate = transformedTemplate.replace(/<\/?html[^>]*>/gi, "").replace(/<head><\/head>/gi, "").trim();
+    for (const fieldName of Object.keys(fields)) {
+      transformedTemplate = transformedTemplate.replaceAll(`content.${fieldName}`, `${contentSource}.${fieldName}`);
+    }
+    const importLine = !isCollectionItem && !isPerPage && options.target === "astro-vue" ? `import { useStrapiContent } from '~/src/composables/useStrapiContent';
+` : "";
+    const contentSetup = isCollectionItem ? `defineProps<{ item: Record<string, any> }>();` : isPerPage ? `const props = defineProps<{ content: Record<string, any> }>();
+const componentContent = props.content || {};` : `const { content } = useStrapiContent('global');`;
+    const scriptSetup = `<script setup lang="ts">
+${importLine}${contentSetup}
+</script>`;
+    await fs7.writeFile(filePath, `${scriptSetup}
+
+<template>
+${transformedTemplate}
+</template>
+`, "utf-8");
+  }
+}
+function restoreComponentTags2(html, componentNames, perPageComponentNames = []) {
+  let restored = html;
+  for (const name of componentNames) {
+    const lowered = name.toLowerCase();
+    const tag = perPageComponentNames.includes(name) ? `<${name} :content="content" />` : `<${name} />`;
+    restored = restored.replace(new RegExp(`<!--COMPONENT:${name}-->`, "g"), tag).replace(new RegExp(`<${lowered}\\s*><\\/${lowered}>`, "g"), tag).replace(new RegExp(`<${lowered}\\s*\\/>`, "g"), tag);
+  }
+  return restored;
+}
+function restoreCollectionComponentTags(html) {
+  return html.replace(
+    /<!--COLLECTION_COMPONENT:(\w+):([\w-]+)-->/g,
+    (_match, componentName, collectionName) => `<${componentName} v-for="(item, index) in content.${collectionName}" :key="index" :item="item" />`
+  );
+}
+function maskComponentTags(html, componentNames) {
+  let masked = html;
+  for (const name of componentNames) {
+    masked = masked.replace(new RegExp(`<${name}\\s*\\/>`, "g"), `<!--COMPONENT:${name}-->`).replace(new RegExp(`<${name}\\s*>\\s*<\\/${name}>`, "g"), `<!--COMPONENT:${name}-->`);
+  }
+  return masked;
+}
+async function transformAllVuePages(pagesDir, manifest, options = {}) {
+  const vueFiles = await glob3("**/*.vue", { cwd: pagesDir, nodir: true });
   for (const file of vueFiles) {
     if (file.endsWith(".vue")) {
-      const pageName = file.replace(".vue", "");
-      const vueFilePath = path8.join(pagesDir, file);
-      await transformVueToReactive(vueFilePath, pageName, manifest);
+      const pageName = htmlPathToPageId(file.replace(/\.vue$/i, ".html"));
+      const vueFilePath = path10.join(pagesDir, file);
+      await transformVueToReactive(vueFilePath, pageName, manifest, options);
     }
   }
 }
 
 // src/transformer.ts
+var LINK_COMPONENT_SCHEMA = {
+  collectionName: "components_shared_links",
+  info: {
+    displayName: "Link",
+    icon: "link",
+    description: "A link with URL and text"
+  },
+  options: {},
+  attributes: {
+    url: {
+      type: "string",
+      required: true
+    },
+    text: {
+      type: "string",
+      required: true
+    },
+    newTab: {
+      type: "boolean",
+      default: false
+    }
+  }
+};
 function mapFieldTypeToStrapi(fieldType) {
+  if (fieldType === "link") {
+    return {
+      type: "component",
+      isComponent: true,
+      component: "shared.link"
+    };
+  }
   const typeMap = {
     plain: "string",
     rich: "richtext",
     html: "richtext",
     image: "media",
-    link: "string",
+    icon: "media",
     email: "email",
     phone: "string"
   };
-  return typeMap[fieldType] || "string";
+  return { type: typeMap[fieldType] || "string" };
 }
 function pluralize(word) {
   if (word.endsWith("s") || word.endsWith("x") || word.endsWith("z") || word.endsWith("ch") || word.endsWith("sh")) {
@@ -1837,12 +2917,21 @@ function pluralize(word) {
 function pageToStrapiSchema(pageName, fields) {
   const attributes = {};
   for (const [fieldName, field] of Object.entries(fields)) {
-    attributes[fieldName] = {
-      type: mapFieldTypeToStrapi(field.type),
-      required: field.required || false
-    };
-    if (field.default) {
-      attributes[fieldName].default = field.default;
+    const strapiType = mapFieldTypeToStrapi(field.type);
+    if (strapiType.isComponent) {
+      attributes[fieldName] = {
+        type: "component",
+        component: strapiType.component,
+        repeatable: false
+      };
+    } else {
+      attributes[fieldName] = {
+        type: strapiType.type,
+        required: field.required || false
+      };
+      if (field.default && typeof field.default === "string") {
+        attributes[fieldName].default = field.default;
+      }
     }
   }
   const displayName = pageName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
@@ -1864,20 +2953,44 @@ function pageToStrapiSchema(pageName, fields) {
 }
 function collectionToStrapiSchema(collectionName, collection) {
   const attributes = {};
-  for (const [fieldName, _selector] of Object.entries(collection.fields)) {
-    let type = "string";
-    if (fieldName === "image" || fieldName.includes("image")) {
-      type = "media";
-    } else if (fieldName === "description" || fieldName === "content") {
-      type = "richtext";
-    } else if (fieldName === "link" || fieldName === "url") {
-      type = "string";
-    } else if (fieldName === "title" || fieldName === "tag") {
-      type = "string";
-    }
-    attributes[fieldName] = {
-      type
-    };
+  for (const [fieldName, fieldConfig] of Object.entries(collection.fields)) {
+    let fieldType;
+    if (typeof fieldConfig === "object" && fieldConfig !== null && "type" in fieldConfig) {
+      fieldType = fieldConfig.type;
+    }
+    if (fieldType) {
+      const strapiType = mapFieldTypeToStrapi(fieldType);
+      if (strapiType.isComponent) {
+        attributes[fieldName] = {
+          type: "component",
+          component: strapiType.component,
+          repeatable: false
+        };
+      } else {
+        attributes[fieldName] = {
+          type: strapiType.type
+        };
+      }
+    } else {
+      let type = "string";
+      if (fieldName === "image" || fieldName.includes("image")) {
+        type = "media";
+      } else if (fieldName === "description" || fieldName === "content") {
+        type = "richtext";
+      } else if (fieldName === "link" || fieldName === "url") {
+        attributes[fieldName] = {
+          type: "component",
+          component: "shared.link",
+          repeatable: false
+        };
+        continue;
+      } else if (fieldName === "title" || fieldName === "tag") {
+        type = "string";
+      }
+      attributes[fieldName] = {
+        type
+      };
+    }
   }
   const displayName = collectionName.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
   const kebabCaseName = collectionName.replace(/_/g, "-");
@@ -1896,6 +3009,37 @@ function collectionToStrapiSchema(collectionName, collection) {
     attributes
   };
 }
+function hasLinkFields(manifest) {
+  for (const page of Object.values(manifest.pages)) {
+    if (page.fields) {
+      for (const field of Object.values(page.fields)) {
+        if (field.type === "link") return true;
+      }
+    }
+    if (page.collections) {
+      for (const collection of Object.values(page.collections)) {
+        for (const fieldConfig of Object.values(collection.fields)) {
+          if (typeof fieldConfig === "object" && fieldConfig !== null) {
+            if (fieldConfig.type === "link") return true;
+          }
+        }
+      }
+    }
+  }
+  if (manifest.global?.fields) {
+    for (const field of Object.values(manifest.global.fields)) {
+      if (field.type === "link") return true;
+    }
+  }
+  if (manifest.global?.components) {
+    for (const component of Object.values(manifest.global.components)) {
+      for (const field of Object.values(component.fields || {})) {
+        if (field.type === "link") return true;
+      }
+    }
+  }
+  return false;
+}
 function manifestToSchemas(manifest) {
   const schemas = {};
   for (const [pageName, page] of Object.entries(manifest.pages)) {
@@ -1908,16 +3052,22 @@ function manifestToSchemas(manifest) {
       }
     }
   }
+  if (manifest.global?.fields && Object.keys(manifest.global.fields).length > 0) {
+    schemas["global"] = pageToStrapiSchema("global", manifest.global.fields);
+  }
   return schemas;
 }
+function getLinkComponentSchema(manifest) {
+  return hasLinkFields(manifest) ? LINK_COMPONENT_SCHEMA : null;
+}
 
 // src/schema-writer.ts
 import fs8 from "fs-extra";
-import path9 from "path";
+import path11 from "path";
 async function writeStrapiSchema(outputDir, name, schema) {
-  const schemasDir = path9.join(outputDir, "cms-schemas");
+  const schemasDir = path11.join(outputDir, "cms-schemas");
   await fs8.ensureDir(schemasDir);
-  const schemaPath = path9.join(schemasDir, `${name}.json`);
+  const schemaPath = path11.join(schemasDir, `${name}.json`);
   await fs8.writeFile(schemaPath, JSON.stringify(schema, null, 2), "utf-8");
 }
 async function writeAllSchemas(outputDir, schemas) {
@@ -1925,8 +3075,14 @@ async function writeAllSchemas(outputDir, schemas) {
     await writeStrapiSchema(outputDir, name, schema);
   }
 }
+async function writeLinkComponentSchema(outputDir) {
+  const componentsDir = path11.join(outputDir, "cms-schemas", "components", "shared");
+  await fs8.ensureDir(componentsDir);
+  const schemaPath = path11.join(componentsDir, "link.json");
+  await fs8.writeFile(schemaPath, JSON.stringify(LINK_COMPONENT_SCHEMA, null, 2), "utf-8");
+}
 async function createStrapiReadme(outputDir) {
-  const readmePath = path9.join(outputDir, "cms-schemas", "README.md");
+  const readmePath = path11.join(outputDir, "cms-schemas", "README.md");
   const content = `# CMS Schemas
 
 Auto-generated Strapi content type schemas from your Webflow export.
@@ -2001,7 +3157,17 @@ const { data } = await $fetch('http://localhost:1337/api/portfolio-cards')
 
 // src/content-extractor.ts
 import * as cheerio4 from "cheerio";
-import path10 from "path";
+function extractLinkValue($element) {
+  const href = $element.attr("href") || $element.attr("to") || "";
+  const text = $element.text().trim();
+  const target = $element.attr("target");
+  const newTab = target === "_blank";
+  return {
+    url: href,
+    text,
+    newTab: newTab || void 0
+  };
+}
 function extractContentFromHTML(html, _pageName, pageManifest) {
   const $ = cheerio4.load(html);
   const content = {
@@ -2016,6 +3182,11 @@ function extractContentFromHTML(html, _pageName, pageManifest) {
         if (field.type === "image") {
           const src = element.attr("src") || element.find("img").attr("src") || "";
           content.fields[fieldName] = src;
+        } else if (field.type === "link") {
+          const linkElement = element.is("a") || element.is("NuxtLink") || element.is("nuxt-link") ? element : element.find("a, NuxtLink, nuxt-link").first();
+          if (linkElement.length > 0) {
+            content.fields[fieldName] = extractLinkValue(linkElement);
+          }
         } else {
           const text = element.text().trim();
           content.fields[fieldName] = text;
@@ -2030,15 +3201,19 @@ function extractContentFromHTML(html, _pageName, pageManifest) {
       collectionElements.each((_, elem) => {
         const item = {};
         const $elem = $(elem);
-        for (const [fieldName, fieldSelector] of Object.entries(collection.fields)) {
+        for (const [fieldName, fieldConfig] of Object.entries(collection.fields)) {
+          const fieldSelector = typeof fieldConfig === "string" ? fieldConfig : fieldConfig.selector || fieldConfig;
+          const fieldType = typeof fieldConfig === "object" ? fieldConfig.type : void 0;
           const fieldElement = $elem.find(fieldSelector).first();
           if (fieldElement.length > 0) {
-            if (fieldName === "image" || fieldName.includes("image")) {
+            if (fieldType === "image" || fieldName === "image" || fieldName.includes("image")) {
               const src = fieldElement.attr("src") || fieldElement.find("img").attr("src") || "";
               item[fieldName] = src;
-            } else if (fieldName === "link" || fieldName === "url") {
-              const href = fieldElement.attr("href") || "";
-              item[fieldName] = href;
+            } else if (fieldType === "link" || fieldName === "link" || fieldName === "url") {
+              const linkElement = fieldElement.is("a") || fieldElement.is("NuxtLink") || fieldElement.is("nuxt-link") ? fieldElement : fieldElement.find("a, NuxtLink, nuxt-link").first();
+              if (linkElement.length > 0) {
+                item[fieldName] = extractLinkValue(linkElement);
+              }
             } else {
               const text = fieldElement.text().trim();
               item[fieldName] = text;
@@ -2067,16 +3242,23 @@ function extractAllContent(htmlFiles, manifest) {
       extractedContent.pages[pageName] = content;
     }
   }
-  return extractedContent;
+  if (manifest.global?.fields) {
+    const firstPage = Object.keys(manifest.pages)[0];
+    const firstHtml = firstPage ? htmlFiles.get(firstPage) : void 0;
+    if (firstHtml) {
+      extractedContent.global = extractContentFromHTML(firstHtml, "global", {
+        fields: manifest.global.fields,
+        collections: {}
+      });
+    }
+  }
+  return { ...extractedContent, manifest };
 }
 function normalizeImagePath(imageSrc) {
-  if (!imageSrc) return "";
-  if (imageSrc.startsWith("/")) return imageSrc;
-  const filename = path10.basename(imageSrc);
-  if (imageSrc.includes("images/")) {
-    return `/images/${filename}`;
-  }
-  return `/${filename}`;
+  return normalizeImageSeedPath(imageSrc);
+}
+function isLinkValue(value) {
+  return typeof value === "object" && value !== null && "url" in value && "text" in value;
 }
 function formatForStrapi(extracted) {
   const seedData = {};
@@ -2084,7 +3266,9 @@ function formatForStrapi(extracted) {
     if (Object.keys(content.fields).length > 0) {
       const formattedFields = {};
       for (const [fieldName, value] of Object.entries(content.fields)) {
-        if (fieldName.includes("image") || fieldName.includes("bg")) {
+        if (isLinkValue(value)) {
+          formattedFields[fieldName] = value;
+        } else if (fieldName.includes("image") || fieldName.includes("img") || fieldName.includes("bg") || isLikelyImagePath(value)) {
           formattedFields[fieldName] = normalizeImagePath(value);
         } else {
           formattedFields[fieldName] = value;
@@ -2096,7 +3280,9 @@ function formatForStrapi(extracted) {
       const formattedItems = items.map((item) => {
         const formattedItem = {};
         for (const [fieldName, value] of Object.entries(item)) {
-          if (fieldName === "image" || fieldName.includes("image")) {
+          if (isLinkValue(value)) {
+            formattedItem[fieldName] = value;
+          } else if (fieldName === "image" || fieldName.includes("image") || fieldName.includes("img") || isLikelyImagePath(value)) {
             formattedItem[fieldName] = normalizeImagePath(value);
           } else {
             formattedItem[fieldName] = value;
@@ -2107,20 +3293,33 @@ function formatForStrapi(extracted) {
       seedData[collectionName] = formattedItems;
     }
   }
+  if (extracted.global && Object.keys(extracted.global.fields).length > 0) {
+    const formattedFields = {};
+    for (const [fieldName, value] of Object.entries(extracted.global.fields)) {
+      if (isLinkValue(value)) {
+        formattedFields[fieldName] = value;
+      } else if (fieldName.includes("image") || fieldName.includes("img") || fieldName.includes("bg") || isLikelyImagePath(value)) {
+        formattedFields[fieldName] = normalizeImagePath(value);
+      } else {
+        formattedFields[fieldName] = value;
+      }
+    }
+    seedData.global = formattedFields;
+  }
   return seedData;
 }
 
 // src/seed-writer.ts
 import fs9 from "fs-extra";
-import path11 from "path";
+import path12 from "path";
 async function writeSeedData(outputDir, seedData) {
-  const seedDir = path11.join(outputDir, "cms-seed");
+  const seedDir = path12.join(outputDir, "cms-seed");
   await fs9.ensureDir(seedDir);
-  const seedPath = path11.join(seedDir, "seed-data.json");
+  const seedPath = path12.join(seedDir, "seed-data.json");
   await fs9.writeJson(seedPath, seedData, { spaces: 2 });
 }
 async function createSeedReadme(outputDir) {
-  const readmePath = path11.join(outputDir, "cms-seed", "README.md");
+  const readmePath = path12.join(outputDir, "cms-seed", "README.md");
   const content = `# CMS Seed Data
 
 Auto-extracted content from your Webflow export, ready to seed into Strapi.
@@ -2179,20 +3378,589 @@ When seeding Strapi, these images will be uploaded to Strapi's media library.
   await fs9.writeFile(readmePath, content, "utf-8");
 }
 
+// src/component-extractor.ts
+import * as cheerio5 from "cheerio";
+import * as crypto from "crypto";
+import fs10 from "fs-extra";
+import path13 from "path";
+import { glob as glob4 } from "glob";
+var COMPONENT_NAME_PATTERNS = {
+  TheNav: [/nav/i, /navbar/i, /navigation/i, /header.*nav/i, /main.*menu/i],
+  TheFooter: [/footer/i, /site.*footer/i],
+  TheHeader: [/header/i, /site.*header/i, /page.*header/i],
+  TheSidebar: [/sidebar/i, /side.*bar/i, /aside/i]
+};
+var DEFAULT_MIN_SECTION_SIZE = 200;
+async function parseAllPages(inputDir, options = {}) {
+  const pages = [];
+  const htmlFiles = await glob4("**/*.html", { cwd: inputDir, nodir: true });
+  for (const file of htmlFiles) {
+    if (!file.endsWith(".html")) continue;
+    const filePath = path13.join(inputDir, file);
+    const html = await fs10.readFile(filePath, "utf-8");
+    const $ = cheerio5.load(html);
+    const pageName = htmlPathToPageId(file);
+    const sections = extractSections($, options.minSectionSize ?? DEFAULT_MIN_SECTION_SIZE);
+    pages.push({
+      name: pageName,
+      filePath,
+      sourcePath: file,
+      $,
+      sections
+    });
+  }
+  return pages;
+}
+function extractSections($, minSectionSize) {
+  const sections = [];
+  const seen = /* @__PURE__ */ new Set();
+  let $container = $("body");
+  const $bodyChildren = $container.children();
+  if ($bodyChildren.length === 1 && $bodyChildren.first().is("div")) {
+    const $wrapper = $bodyChildren.first();
+    if ($wrapper.children().length > 1) {
+      $container = $wrapper;
+    }
+  }
+  $container.children().each((_, el) => {
+    const $element = $(el);
+    const tagName = ($element.prop("tagName") || "").toLowerCase();
+    if (["script", "style", "link", "meta", "noscript", "template"].includes(tagName)) {
+      return;
+    }
+    const className = $element.attr("class") || "";
+    if (className.includes("global-embed") || className.includes("globalembed")) {
+      return;
+    }
+    const html = $.html($element);
+    const elementId = getElementIdentifier($, $element);
+    if (seen.has(elementId)) return;
+    seen.add(elementId);
+    const fingerprint = createFingerprint($, $element);
+    const exactFingerprint = createExactFingerprint(html);
+    const suggestedName = suggestComponentName($element);
+    const semanticName = ["TheNav", "TheFooter", "TheHeader", "TheSidebar", "Nav", "Footer", "Header", "Sidebar"].includes(suggestedName);
+    if (!semanticName && html.length < minSectionSize) return;
+    const uniqueSelector = buildUniqueSelector2($, $element);
+    sections.push({
+      selector: uniqueSelector,
+      fingerprint,
+      exactFingerprint,
+      $element,
+      html,
+      suggestedName
+    });
+  });
+  return sections;
+}
+function createExactFingerprint(html) {
+  const normalized = html.replace(/\s*data-w-id="[^"]*"/g, "").replace(/\s*data-wf-page="[^"]*"/g, "").replace(/\s*data-wf-site="[^"]*"/g, "").replace(/\s+/g, " ").trim();
+  return crypto.createHash("md5").update(normalized).digest("hex").substring(0, 12);
+}
+function getElementIdentifier(_$, $element) {
+  const tag = $element.prop("tagName")?.toLowerCase() || "div";
+  const className = $element.attr("class") || "";
+  const id = $element.attr("id") || "";
+  return `${tag}#${id}.${className}`;
+}
+function createFingerprint($, $element) {
+  const structure = getStructure($, $element);
+  return crypto.createHash("md5").update(structure).digest("hex").substring(0, 12);
+}
+function getStructure($, $element, depth = 0) {
+  if (depth > 10) return "";
+  const tag = $element.prop("tagName")?.toLowerCase() || "div";
+  const classNames = normalizeClasses($element.attr("class") || "");
+  let structure = `${tag}`;
+  if (classNames) {
+    structure += `.${classNames}`;
+  }
+  const children = [];
+  $element.children().each((_, child) => {
+    const $child = $(child);
+    const childStructure = getStructure($, $child, depth + 1);
+    if (childStructure) {
+      children.push(childStructure);
+    }
+  });
+  if (children.length > 0) {
+    const childCounts = countIdentical(children);
+    const compressedChildren = childCounts.map(({ item, count }) => count > 1 ? `${item}*${count}` : item).join(",");
+    structure += `[${compressedChildren}]`;
+  }
+  return structure;
+}
+function normalizeClasses(classes) {
+  return classes.split(/\s+/).filter((c) => {
+    if (c.startsWith("w-")) return false;
+    if (c.match(/^(p|m|pt|pb|pl|pr|px|py|mt|mb|ml|mr|mx|my)-\d/)) return false;
+    return c.length > 0;
+  }).sort().join(".");
+}
+function countIdentical(items) {
+  const result = [];
+  for (const item of items) {
+    const last = result[result.length - 1];
+    if (last && last.item === item) {
+      last.count++;
+    } else {
+      result.push({ item, count: 1 });
+    }
+  }
+  return result;
+}
+function suggestComponentName($element) {
+  const tag = $element.prop("tagName")?.toLowerCase() || "";
+  const className = $element.attr("class") || "";
+  const id = $element.attr("id") || "";
+  if (tag === "nav") return "TheNav";
+  if (tag === "footer") return "TheFooter";
+  if (tag === "header") return "TheHeader";
+  if (tag === "aside") return "TheSidebar";
+  const normalizedClassName = className.replace(/\bc-/g, "");
+  const searchText = `${className} ${normalizedClassName} ${id}`.toLowerCase();
+  for (const [name, patterns] of Object.entries(COMPONENT_NAME_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (pattern.test(searchText)) {
+        return name;
+      }
+    }
+  }
+  const primaryClass = className.split(" ").find((c) => !c.startsWith("w-") && c.length > 2);
+  if (primaryClass) {
+    const cleanName = primaryClass.replace(/^c-/, "");
+    return pascalCase(cleanName);
+  }
+  return "SharedSection";
+}
+function pascalCase(str) {
+  if (/^[A-Z][A-Za-z0-9]*$/.test(str)) {
+    return str;
+  }
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function buildUniqueSelector2($, $element) {
+  const tag = $element.prop("tagName")?.toLowerCase() || "div";
+  const id = $element.attr("id");
+  const className = $element.attr("class");
+  if (id) {
+    return `#${id}`;
+  }
+  if (className) {
+    const primaryClasses = className.split(" ").filter((c) => !c.startsWith("w-") && c.length > 2).slice(0, 2);
+    if (primaryClasses.length > 0) {
+      const selector = `${tag}.${primaryClasses.join(".")}`;
+      if ($(selector).length === 1) {
+        return selector;
+      }
+      return `.${primaryClasses.join(".")}`;
+    }
+  }
+  const $parent = $element.parent();
+  const siblings = $parent.children(tag);
+  if (siblings.length > 1) {
+    const index = siblings.index($element) + 1;
+    return `${tag}:nth-child(${index})`;
+  }
+  return tag;
+}
+function findSharedSections(pages, options = {}) {
+  const fingerprintMap = /* @__PURE__ */ new Map();
+  const match = options.match || "exact";
+  for (const page of pages) {
+    for (const section of page.sections) {
+      const fingerprint = match === "structure" ? section.fingerprint : section.exactFingerprint;
+      const existing = fingerprintMap.get(fingerprint) || [];
+      existing.push({ section, page });
+      fingerprintMap.set(fingerprint, existing);
+    }
+  }
+  const sharedComponents = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const occurrences of fingerprintMap.values()) {
+    const uniquePages = new Set(occurrences.map((o) => o.page.name));
+    if (occurrences.length < (options.minOccurrences ?? 2)) continue;
+    if (uniquePages.size < (options.minPages ?? options.minOccurrences ?? 2)) continue;
+    const template = occurrences[0];
+    let name = template.section.suggestedName;
+    if (options.include?.length && !options.include.some((item) => name.toLowerCase().includes(item.toLowerCase()))) {
+      const semanticNames = ["TheNav", "TheFooter", "TheHeader", "TheSidebar"];
+      if (!semanticNames.includes(name)) continue;
+    }
+    if (options.exclude?.some((item) => name.toLowerCase().includes(item.toLowerCase()))) continue;
+    let counter = 1;
+    while (usedNames.has(name)) {
+      name = `${template.section.suggestedName}${counter++}`;
+    }
+    usedNames.add(name);
+    const confidence = getComponentConfidence(name, uniquePages.size, pages.length);
+    sharedComponents.push({
+      name,
+      selector: template.section.selector,
+      pages: [...uniquePages],
+      html: template.section.html,
+      fingerprint: template.section.fingerprint,
+      confidence,
+      reason: confidence === "high" ? "Semantic or repeated site-wide section" : match === "exact" ? "Exact repeated HTML section" : "Repeated section with matching DOM structure"
+    });
+  }
+  return sharedComponents;
+}
+function getComponentConfidence(name, pageCount, totalPages) {
+  const semanticNames = ["thenav", "thefooter", "theheader", "nav", "footer", "header"];
+  if (semanticNames.includes(name.toLowerCase())) return "high";
+  if (pageCount === totalPages || pageCount >= 3) return "medium";
+  return "low";
+}
+function createVueComponent(component) {
+  let html = component.html;
+  html = html.replace(/\s*data-w-id="[^"]*"/g, "");
+  html = html.replace(/\s*data-wf-page="[^"]*"/g, "");
+  html = html.replace(/\s*data-wf-site="[^"]*"/g, "");
+  html = sanitizeVueComponentHtml(html);
+  return `<script setup lang="ts">
+/**
+ * ${component.name} Component
+ * Shared across pages: ${component.pages.join(", ")}
+ *
+ * To make content editable, add fields to the 'global' section in cms-manifest.json
+ */
+const { content } = useStrapiContent('global')
+</script>
+
+<template>
+${html}
+</template>
+
+<style scoped>
+/* Component-specific styles if needed */
+</style>
+`;
+}
+function sanitizeVueComponentHtml(html) {
+  const $ = cheerio5.load(html);
+  $("script, style").remove();
+  $("img").each((_, el) => {
+    const $el = $(el);
+    const src = $el.attr("src");
+    if (src) {
+      $el.attr("src", normalizePublicAssetPath(src));
+    }
+    $el.removeAttr("srcset");
+    $el.removeAttr("sizes");
+  });
+  return $.html();
+}
+function replaceWithComponent($, selector, componentName) {
+  const $element = $(selector);
+  if ($element.length > 0) {
+    $element.replaceWith(`<!--COMPONENT:${componentName}-->`);
+  }
+}
+async function writeComponents(outputDir, components) {
+  const componentsDir = path13.join(outputDir, "components");
+  await fs10.ensureDir(componentsDir);
+  const sharedComponents = [];
+  for (const component of components) {
+    const vueContent = createVueComponent(component);
+    const filePath = path13.join(componentsDir, `${component.name}.vue`);
+    await fs10.writeFile(filePath, vueContent, "utf-8");
+    sharedComponents.push({
+      name: component.name,
+      selector: component.selector,
+      pages: component.pages,
+      confidence: component.confidence,
+      reason: component.reason,
+      role: component.role || "shared-section",
+      collectionName: component.collectionName,
+      collectionStorage: component.collectionStorage,
+      contentMode: component.contentMode || "shared-global"
+      // Fields will be detected separately
+    });
+  }
+  return sharedComponents;
+}
+async function extractSharedComponents(inputDir, outputDir, options = {}) {
+  const pages = await parseAllPages(inputDir, options);
+  if (pages.length < 2) {
+    return [];
+  }
+  const rules = (options.rules || []).map((rule) => ({
+    ...rule,
+    minOccurrences: rule.minOccurrences ?? options.minOccurrences,
+    minPages: rule.minPages ?? options.minPages
+  }));
+  const ruleSections = findRuleSections(pages, rules);
+  const sharedSections = [...ruleSections, ...findSharedSections(pages, options)];
+  if (sharedSections.length === 0) {
+    return [];
+  }
+  const componentsToWrite = sharedSections.filter((component) => meetsConfidence(component.confidence, options.writeConfidence || "medium"));
+  const components = await writeComponents(outputDir, componentsToWrite);
+  return components;
+}
+function findRuleSections(pages, rules) {
+  const components = [];
+  for (const rule of rules) {
+    const occurrences = [];
+    for (const page of pages) {
+      const $elements = page.$(rule.selector);
+      if ($elements.length === 0) continue;
+      $elements.each((index, element) => {
+        if (rule.role !== "collection-item" && index > 0) return false;
+        occurrences.push({ page, html: page.$.html(element) });
+        return void 0;
+      });
+    }
+    const uniquePages = new Set(occurrences.map(({ page }) => page.name));
+    if (occurrences.length < (rule.minOccurrences ?? 2)) continue;
+    if (uniquePages.size < (rule.minPages ?? rule.minOccurrences ?? 2)) continue;
+    components.push({
+      name: pascalCase(rule.name),
+      selector: rule.selector,
+      pages: [...uniquePages],
+      html: occurrences[0].html,
+      fingerprint: crypto.createHash("md5").update(occurrences[0].html).digest("hex").substring(0, 12),
+      confidence: "high",
+      reason: "User-defined component rule",
+      role: rule.role || "shared-section",
+      collectionName: rule.collectionName || toCollectionName2(rule.name),
+      collectionStorage: rule.collectionStorage || "collection-type",
+      contentMode: rule.contentMode || "auto"
+    });
+  }
+  return components;
+}
+function toCollectionName2(name) {
+  const base = name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+  if (base.endsWith("s")) return base;
+  return `${base}s`;
+}
+function meetsConfidence(confidence, minimum) {
+  const rank = { low: 1, medium: 2, high: 3 };
+  return rank[confidence] >= rank[minimum];
+}
+
+// src/converter.ts
+import * as cheerio6 from "cheerio";
+
+// src/analyzer.ts
+import path14 from "path";
+import fs11 from "fs-extra";
+async function analyzeWebflowExport(inputDir, config = {}) {
+  const inputExists = await fs11.pathExists(inputDir);
+  if (!inputExists) {
+    throw new Error(`Input directory not found: ${inputDir}`);
+  }
+  const [assets, htmlFiles] = await Promise.all([
+    scanAssets(inputDir),
+    findHTMLFiles(inputDir)
+  ]);
+  const pages = htmlFiles.sort().map(getPageRouteInfo);
+  const warnings = [];
+  if (pages.length === 0) {
+    warnings.push("No HTML pages were found in the input directory.");
+  }
+  const componentConfig = config.components || {};
+  const parsedPages = await parseAllPages(inputDir, {
+    minSectionSize: componentConfig.minSectionSize
+  });
+  const componentCandidates = findSharedSections(parsedPages, {
+    match: componentConfig.match,
+    minOccurrences: componentConfig.minOccurrences,
+    minPages: componentConfig.minPages,
+    include: componentConfig.include,
+    exclude: componentConfig.exclude,
+    rules: componentConfig.rules
+  }).map((component) => ({
+    name: component.name,
+    selector: component.selector,
+    pages: component.pages,
+    confidence: component.confidence,
+    reason: component.reason
+  }));
+  return {
+    inputDir,
+    pages,
+    assets,
+    componentCandidates,
+    warnings
+  };
+}
+function createConversionReport(input) {
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stages: input.stages,
+    pages: input.analysis.pages.map((page) => ({
+      source: page.sourcePath,
+      pageId: page.pageId,
+      route: page.route,
+      output: page.outputPath
+    })),
+    assets: {
+      css: input.analysis.assets.css.length,
+      images: input.analysis.assets.images.length,
+      fonts: input.analysis.assets.fonts.length,
+      js: input.analysis.assets.js.length,
+      preservedStructure: true
+    },
+    components: input.components.map((component) => ({
+      name: component.name,
+      selector: component.selector,
+      pages: component.pages,
+      confidence: component.confidence,
+      reason: component.reason
+    })),
+    cms: {
+      provider: input.provider,
+      fields: input.fields,
+      collections: input.collections,
+      schemas: input.schemas,
+      seedPages: input.seedPages
+    },
+    warnings: [...input.analysis.warnings, ...input.warnings || []]
+  };
+}
+async function writeConversionReport(outputDir, report) {
+  const jsonPath = path14.join(outputDir, "see-ms-report.json");
+  const mdPath = path14.join(outputDir, "see-ms-report.md");
+  await fs11.writeFile(jsonPath, JSON.stringify(report, null, 2), "utf-8");
+  await fs11.writeFile(mdPath, renderReportMarkdown(report), "utf-8");
+}
+function renderReportMarkdown(report) {
+  const lines = [
+    "# SeeMS Conversion Report",
+    "",
+    `Generated: ${report.generatedAt}`,
+    "",
+    "## Stages",
+    report.stages.map((stage) => `- ${stage}`).join("\n") || "- none",
+    "",
+    "## Pages",
+    ...report.pages.map((page) => `- ${page.source} -> ${page.output} (${page.route}, id: ${page.pageId})`),
+    "",
+    "## Assets",
+    `- CSS: ${report.assets.css}`,
+    `- Images: ${report.assets.images}`,
+    `- Fonts: ${report.assets.fonts}`,
+    `- JS: ${report.assets.js}`,
+    `- Preserved folder structure: ${report.assets.preservedStructure ? "yes" : "no"}`,
+    "",
+    "## Components",
+    ...report.components.length ? report.components.map((component) => `- ${component.name} (${component.confidence || "unknown"}): ${component.pages.join(", ")}`) : ["- none"],
+    "",
+    "## CMS",
+    `- Provider: ${report.cms.provider}`,
+    `- Editable fields: ${report.cms.fields}`,
+    `- Collections: ${report.cms.collections}`,
+    `- Schemas: ${report.cms.schemas}`,
+    `- Seeded pages: ${report.cms.seedPages}`,
+    "",
+    "## Warnings",
+    ...report.warnings.length ? report.warnings.map((warning) => `- ${warning}`) : ["- none"],
+    ""
+  ];
+  return lines.join("\n");
+}
+
+// src/config.ts
+import fs12 from "fs-extra";
+import path15 from "path";
+var DEFAULT_SEEMS_CONFIG = {
+  target: "nuxt",
+  cms: { provider: "strapi", strapi: { scaffold: false, packageManager: "npm", install: true } },
+  components: {
+    enabled: true,
+    match: "structure",
+    minOccurrences: 2,
+    minPages: 2,
+    minSectionSize: 200,
+    writeConfidence: "medium",
+    include: ["nav", "header", "footer"],
+    exclude: [],
+    rules: []
+  },
+  ignore: {
+    selectors: [],
+    classes: []
+  },
+  editor: {
+    enabled: true,
+    previewParam: "preview"
+  },
+  assets: {
+    excludeResponsiveVariants: true
+  }
+};
+function mergeConfig(base = {}, override = {}) {
+  return {
+    ...base,
+    ...override,
+    cms: {
+      ...base.cms,
+      ...override.cms,
+      strapi: { ...base.cms?.strapi, ...override.cms?.strapi }
+    },
+    components: { ...base.components, ...override.components },
+    ignore: { ...base.ignore, ...override.ignore },
+    editor: { ...base.editor, ...override.editor },
+    assets: { ...base.assets, ...override.assets },
+    collections: override.collections ?? base.collections,
+    fields: { ...base.fields, ...override.fields }
+  };
+}
+async function loadSeeMSConfig(configPath) {
+  if (!configPath) return {};
+  const absolutePath = path15.resolve(configPath);
+  if (!await fs12.pathExists(absolutePath)) {
+    throw new Error(`Config file not found: ${absolutePath}`);
+  }
+  if (absolutePath.endsWith(".json")) {
+    return JSON.parse(await fs12.readFile(absolutePath, "utf-8"));
+  }
+  const content = await fs12.readFile(absolutePath, "utf-8");
+  const objectMatch = content.match(/export\s+default\s+(\{[\s\S]*\})\s*(?:satisfies\s+\w+)?\s*;?\s*$/) || content.match(/const\s+\w+(?::\s*[\w<>]+)?\s*=\s*(\{[\s\S]*\})\s*;\s*export\s+default\s+\w+\s*;?\s*$/);
+  if (!objectMatch) {
+    throw new Error("see-ms config must export an object literal or be JSON");
+  }
+  return Function(`"use strict"; return (${objectMatch[1]});`)();
+}
+async function writeSeeMSConfig(outputDir, config) {
+  const target = path15.join(outputDir, "see-ms.config.ts");
+  const content = `import type { SeeMSConfig } from "@see-ms/types";
+
+const config: SeeMSConfig = ${JSON.stringify(config, null, 2)};
+
+export default config;
+`;
+  await fs12.writeFile(target, content, "utf-8");
+}
+function normalizeConfig(config = {}) {
+  return mergeConfig(DEFAULT_SEEMS_CONFIG, config);
+}
+
 // src/converter.ts
 async function convertWebflowExport(options) {
   const { inputDir, outputDir, boilerplate } = options;
-  console.log(pc3.cyan("\u{1F680} Starting Webflow to Nuxt conversion..."));
+  const loadedConfig = options.configPath ? await loadSeeMSConfig(options.configPath) : {};
+  const config = normalizeConfig(mergeConfig(loadedConfig, options.config || {}));
+  const target = options.target || config.target || "nuxt";
+  const provider = options.cmsBackend || config.cms?.provider || "strapi";
+  const editorEnabled = options.editor ?? config.editor?.enabled ?? true;
+  const shouldGenerateContent = options.generateContent !== false;
+  const collectionClasses = options.collectionClasses || config.collections?.map((collection) => collection.className);
+  const collectionNames = options.collectionNames || Object.fromEntries(
+    (config.collections || []).map((collection) => [collection.className, collection.name || collection.className])
+  );
+  console.log(pc3.cyan(`\u{1F680} Starting Webflow to ${target === "astro-vue" ? "Astro + Vue" : "Nuxt"} conversion...`));
   console.log(pc3.dim(`Input: ${inputDir}`));
   console.log(pc3.dim(`Output: ${outputDir}`));
   try {
-    await setupBoilerplate(boilerplate, outputDir);
-    const inputExists = await fs10.pathExists(inputDir);
-    if (!inputExists) {
-      throw new Error(`Input directory not found: ${inputDir}`);
-    }
+    const analysis = await analyzeWebflowExport(inputDir, config);
+    await setupBoilerplate(boilerplate, outputDir, target);
+    await writeSeeMSConfig(outputDir, config);
     console.log(pc3.blue("\n\u{1F4C2} Scanning assets..."));
-    const assets = await scanAssets(inputDir);
+    const assets = analysis.assets;
     console.log(pc3.green(`  \u2713 Found ${assets.css.length} CSS files`));
     console.log(pc3.green(`  \u2713 Found ${assets.images.length} images`));
     console.log(pc3.green(`  \u2713 Found ${assets.fonts.length} fonts`));
@@ -2201,19 +3969,62 @@ async function convertWebflowExport(options) {
     await copyAllAssets(inputDir, outputDir, assets);
     console.log(pc3.green("  \u2713 Assets copied successfully"));
     console.log(pc3.blue("\n\u{1F50D} Finding HTML files..."));
-    const htmlFiles = await findHTMLFiles(inputDir);
+    const htmlFiles = analysis.pages.map((page) => page.sourcePath);
     console.log(pc3.green(`  \u2713 Found ${htmlFiles.length} HTML files`));
     const htmlContentMap = /* @__PURE__ */ new Map();
+    const originalHtmlContentMap = /* @__PURE__ */ new Map();
     for (const htmlFile of htmlFiles) {
       const html = await readHTMLFile(inputDir, htmlFile);
-      const pageName = htmlFile.replace(".html", "").replace(/\//g, "-");
+      const pageName = htmlPathToPageId(htmlFile);
       htmlContentMap.set(pageName, html);
+      originalHtmlContentMap.set(pageName, html);
       console.log(pc3.dim(`  Stored: ${pageName} from ${htmlFile}`));
     }
+    console.log(pc3.blue("\n\u{1F9E9} Extracting shared components..."));
+    const sharedComponents = config.components?.enabled === false ? [] : await extractSharedComponents(inputDir, outputDir, {
+      minOccurrences: config.components?.minOccurrences,
+      minPages: config.components?.minPages,
+      minSectionSize: config.components?.minSectionSize,
+      match: config.components?.match,
+      writeConfidence: config.components?.writeConfidence,
+      include: config.components?.include,
+      exclude: config.components?.exclude,
+      rules: config.components?.rules
+    });
+    const pageComponentMap = /* @__PURE__ */ new Map();
+    if (sharedComponents.length > 0) {
+      console.log(pc3.green(`  \u2713 Extracted ${sharedComponents.length} shared components:`));
+      for (const component of sharedComponents) {
+        console.log(pc3.dim(`    - ${component.name} (found in ${component.pages.length} pages)`));
+      }
+      for (const [pageName, html] of htmlContentMap.entries()) {
+        const $ = cheerio6.load(html);
+        let modified = false;
+        const usedComponents = [];
+        for (const component of sharedComponents) {
+          if (component.role === "collection-item") {
+            continue;
+          }
+          if (component.pages.includes(pageName)) {
+            replaceWithComponent($, component.selector, component.name);
+            usedComponents.push(component.name);
+            modified = true;
+          }
+        }
+        if (modified) {
+          const serializedHtml = $.html();
+          htmlContentMap.set(pageName, serializedHtml);
+          pageComponentMap.set(pageName, usedComponents);
+        }
+      }
+    } else {
+      console.log(pc3.dim("  No shared components detected across pages"));
+    }
     console.log(pc3.blue("\n\u2699\uFE0F  Converting HTML to Vue components..."));
     let allEmbeddedStyles = "";
     for (const htmlFile of htmlFiles) {
-      const html = htmlContentMap.get(htmlFile.replace(".html", "").replace(/\//g, "-"));
+      const pageName = htmlPathToPageId(htmlFile);
+      const html = htmlContentMap.get(pageName);
       const parsed = parseHTML(html, htmlFile);
       if (parsed.embeddedStyles) {
         allEmbeddedStyles += `
@@ -2221,16 +4032,33 @@ async function convertWebflowExport(options) {
 ${parsed.embeddedStyles}
 `;
       }
-      const transformed = transformForNuxt(parsed.htmlContent);
-      const pageName = htmlFile.replace(".html", "").replace(/\//g, "-");
-      const vueComponent = htmlToVueComponent(transformed, pageName);
-      await writeVueComponent(outputDir, htmlFile, vueComponent);
-      console.log(pc3.green(`  \u2713 Created ${htmlFile.replace(".html", ".vue")}`));
+      const transformed = transformForNuxt(parsed.htmlContent, htmlFile, {
+        linkMode: target === "astro-vue" ? "anchor" : "nuxt"
+      });
+      const componentImports = pageComponentMap.get(pageName);
+      const vueComponent = htmlToVueComponent(transformed, pageName, componentImports);
+      await writeVueComponent(outputDir, htmlFile, vueComponent, target, assets.css, editorEnabled);
+      console.log(pc3.green(`  \u2713 Created ${htmlFile.replace(".html", target === "astro-vue" ? ".astro + .vue" : ".vue")}`));
     }
-    await formatVueFiles(outputDir);
+    await formatVueFiles(outputDir, target);
     console.log(pc3.blue("\n\u{1F50D} Analyzing pages for CMS fields..."));
-    const pagesDir = path12.join(outputDir, "pages");
-    const manifest = await generateManifest(pagesDir);
+    const pagesDir = target === "astro-vue" ? path16.join(outputDir, "src", "components", "pages") : path16.join(outputDir, "pages");
+    const pageRoutes = Object.fromEntries(
+      htmlFiles.map((htmlFile) => {
+        const info = getPageRouteInfo(htmlFile);
+        return [info.pageId, info.route];
+      })
+    );
+    const manifest = await generateManifest(pagesDir, {
+      collectionClasses,
+      collectionNames,
+      sharedComponents,
+      componentsDir: path16.join(outputDir, "components"),
+      ignoreSelectors: config.ignore?.selectors,
+      ignoreClasses: config.ignore?.classes,
+      provider,
+      pageRoutes
+    });
     await writeManifest(outputDir, manifest);
     const totalFields = Object.values(manifest.pages).reduce(
       (sum, page) => sum + Object.keys(page.fields || {}).length,
@@ -2243,27 +4071,50 @@ ${parsed.embeddedStyles}
     console.log(pc3.green(`  \u2713 Detected ${totalFields} fields across ${Object.keys(manifest.pages).length} pages`));
     console.log(pc3.green(`  \u2713 Detected ${totalCollections} collections`));
     console.log(pc3.green("  \u2713 Generated cms-manifest.json"));
+    console.log(pc3.blue("\n\u{1F50C} Generating content runtime..."));
+    if (target === "nuxt") {
+      await createEditorContentComposable(outputDir);
+      await createStrapiContentComposable(outputDir, manifest);
+      await addStrapiUrlToConfig(outputDir);
+    } else {
+      await createAstroStrapiContentComposable(outputDir, manifest);
+    }
+    console.log(pc3.green("  \u2713 Content runtime generated"));
     console.log(pc3.blue("\n\u26A1 Transforming Vue files to reactive templates..."));
-    await transformAllVuePages(pagesDir, manifest);
+    await transformAllVuePages(pagesDir, manifest, { target });
+    await transformSharedComponentsToReactive(path16.join(outputDir, "components"), manifest, { target });
     console.log(pc3.green(`  \u2713 Transformed ${Object.keys(manifest.pages).length} pages to use Vue template syntax`));
     console.log(pc3.blue("\n\u{1F4DD} Extracting content from HTML..."));
     console.log(pc3.dim(`  HTML map has ${htmlContentMap.size} entries`));
     console.log(pc3.dim(`  Manifest has ${Object.keys(manifest.pages).length} pages`));
-    const extractedContent = extractAllContent(htmlContentMap, manifest);
-    const seedData = formatForStrapi(extractedContent);
-    await writeSeedData(outputDir, seedData);
-    await createSeedReadme(outputDir);
-    const pagesWithContent = Object.keys(seedData).filter((key) => {
+    let seedData = {};
+    if (shouldGenerateContent) {
+      const extractedContent = extractAllContent(originalHtmlContentMap, manifest);
+      seedData = formatForStrapi(extractedContent);
+      await writeSeedData(outputDir, seedData);
+      await createSeedReadme(outputDir);
+    }
+    const pagesWithContent = Object.keys(manifest.pages).filter((key) => {
       const data = seedData[key];
+      if (!data) return false;
       if (Array.isArray(data)) return data.length > 0;
       return Object.keys(data).length > 0;
     }).length;
-    console.log(pc3.green(`  \u2713 Extracted content from ${pagesWithContent} pages`));
-    console.log(pc3.green(`  \u2713 Generated cms-seed/seed-data.json`));
+    if (shouldGenerateContent) {
+      console.log(pc3.green(`  \u2713 Extracted content from ${pagesWithContent} pages`));
+      console.log(pc3.green(`  \u2713 Generated cms-seed/seed-data.json`));
+    } else {
+      console.log(pc3.dim("  Skipped initial CMS content generation"));
+    }
     console.log(pc3.blue("\n\u{1F4CB} Generating Strapi schemas..."));
     const schemas = manifestToSchemas(manifest);
     await writeAllSchemas(outputDir, schemas);
     await createStrapiReadme(outputDir);
+    const linkSchema = getLinkComponentSchema(manifest);
+    if (linkSchema) {
+      await writeLinkComponentSchema(outputDir);
+      console.log(pc3.dim("  \u2713 Generated shared.link component schema"));
+    }
     console.log(pc3.green(`  \u2713 Generated ${Object.keys(schemas).length} Strapi content types`));
     console.log(pc3.dim("    View schemas in: cms-schemas/"));
     if (allEmbeddedStyles.trim()) {
@@ -2272,34 +4123,55 @@ ${parsed.embeddedStyles}
       await writeEmbeddedStyles(outputDir, dedupedStyles);
       console.log(pc3.green("  \u2713 Embedded styles added to main.css"));
     }
-    console.log(pc3.blue("\n\u{1F527} Generating webflow-assets.ts plugin..."));
-    await writeWebflowAssetPlugin(outputDir, assets.css);
-    console.log(pc3.green("  \u2713 Plugin generated (existing file overwritten)"));
-    console.log(pc3.blue("\n\u2699\uFE0F  Updating nuxt.config.ts..."));
-    try {
-      await updateNuxtConfig(outputDir, assets.css);
-      console.log(pc3.green("  \u2713 Config updated"));
-    } catch (error) {
-      console.log(pc3.yellow("  \u26A0  Could not update nuxt.config.ts automatically"));
-      console.log(pc3.dim("    Please add CSS files manually"));
-    }
-    console.log(pc3.blue("\n\u{1F3A8} Setting up editor overlay..."));
-    await createEditorPlugin(outputDir);
-    await createEditorContentComposable(outputDir);
-    await createStrapiContentComposable(outputDir);
-    await addEditorDependency(outputDir);
-    await createSaveEndpoint(outputDir);
-    await createPublishEndpoint(outputDir);
-    await createStrapiBootstrap(outputDir);
-    await addStrapiUrlToConfig(outputDir);
-    console.log(pc3.green("  \u2713 Editor plugin created"));
-    console.log(pc3.green("  \u2713 Editor content composable created"));
-    console.log(pc3.green("  \u2713 Strapi content composable created"));
-    console.log(pc3.green("  \u2713 Editor dependency added"));
-    console.log(pc3.green("  \u2713 Save endpoint created"));
-    console.log(pc3.green("  \u2713 Publish endpoint created"));
-    console.log(pc3.green("  \u2713 Strapi bootstrap file generated"));
-    console.log(pc3.green("  \u2713 Strapi config added"));
+    if (target === "nuxt") {
+      console.log(pc3.blue("\n\u{1F527} Generating webflow-assets.ts plugin..."));
+      await writeWebflowAssetPlugin(outputDir, assets.css);
+      console.log(pc3.green("  \u2713 Plugin generated (existing file overwritten)"));
+      console.log(pc3.blue("\n\u2699\uFE0F  Updating nuxt.config.ts..."));
+      try {
+        await updateNuxtConfig(outputDir, assets.css);
+        console.log(pc3.green("  \u2713 Config updated"));
+      } catch (error) {
+        console.log(pc3.yellow("  \u26A0  Could not update nuxt.config.ts automatically"));
+        console.log(pc3.dim("    Please add CSS files manually"));
+      }
+    } else {
+      console.log(pc3.dim("\n\u{1F527} Skipped Nuxt asset plugin; Astro pages import CSS directly"));
+    }
+    if (editorEnabled) {
+      console.log(pc3.blue("\n\u{1F3A8} Setting up editor overlay..."));
+      if (target === "nuxt") {
+        await createEditorPlugin(outputDir);
+        await createSaveEndpoint(outputDir);
+        await createPublishEndpoint(outputDir);
+        console.log(pc3.green("  \u2713 Nuxt editor plugin created"));
+        console.log(pc3.green("  \u2713 Nuxt save/publish endpoints created"));
+      } else {
+        await createAstroEditorClient(outputDir);
+        await createAstroSaveEndpoint(outputDir);
+        console.log(pc3.green("  \u2713 Astro editor client created"));
+        console.log(pc3.green("  \u2713 Astro save/publish endpoints created"));
+      }
+      await addEditorDependency(outputDir);
+      await createStrapiBootstrap(outputDir);
+      console.log(pc3.green("  \u2713 Editor dependency added"));
+      console.log(pc3.green("  \u2713 Strapi bootstrap file generated"));
+    } else {
+      console.log(pc3.dim("\n\u{1F3A8} Editor overlay disabled by config"));
+    }
+    const report = createConversionReport({
+      analysis,
+      provider,
+      stages: ["scan", "analyze", "plan", "convert", "cms", ...editorEnabled ? ["editor"] : []],
+      components: sharedComponents,
+      fields: totalFields,
+      collections: totalCollections,
+      schemas: Object.keys(schemas).length,
+      seedPages: pagesWithContent,
+      warnings: []
+    });
+    await writeConversionReport(outputDir, report);
+    console.log(pc3.green("  \u2713 Generated see-ms-report.md and see-ms-report.json"));
     console.log(pc3.green("\n\u2705 Conversion completed successfully!"));
     console.log(pc3.cyan("\n\u{1F4CB} Next steps:"));
     console.log(pc3.dim(`  1. cd ${outputDir}`));
@@ -2318,16 +4190,17 @@ ${parsed.embeddedStyles}
 }
 
 // src/strapi-setup.ts
-import fs11 from "fs-extra";
-import path13 from "path";
-import { glob as glob2 } from "glob";
+import fs13 from "fs-extra";
+import path17 from "path";
+import { glob as glob5 } from "glob";
 import * as readline from "readline";
+import { spawn } from "child_process";
 var ENV_FILE = ".env";
 async function loadConfig(projectDir) {
-  const envPath = path13.join(projectDir, ENV_FILE);
-  if (await fs11.pathExists(envPath)) {
+  const envPath = path17.join(projectDir, ENV_FILE);
+  if (await fs13.pathExists(envPath)) {
     try {
-      const content = await fs11.readFile(envPath, "utf-8");
+      const content = await fs13.readFile(envPath, "utf-8");
       const config = {};
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
@@ -2348,10 +4221,10 @@ async function loadConfig(projectDir) {
   return {};
 }
 async function saveConfig(projectDir, config) {
-  const envPath = path13.join(projectDir, ENV_FILE);
+  const envPath = path17.join(projectDir, ENV_FILE);
   let content = "";
-  if (await fs11.pathExists(envPath)) {
-    content = await fs11.readFile(envPath, "utf-8");
+  if (await fs13.pathExists(envPath)) {
+    content = await fs13.readFile(envPath, "utf-8");
     content = content.split("\n").filter((line) => !line.startsWith("STRAPI_API_TOKEN=") && !line.startsWith("STRAPI_URL=")).join("\n");
     if (content && !content.endsWith("\n")) {
       content += "\n";
@@ -2365,10 +4238,19 @@ async function saveConfig(projectDir, config) {
     content += `STRAPI_API_TOKEN=${config.apiToken}
 `;
   }
-  await fs11.writeFile(envPath, content);
+  await fs13.writeFile(envPath, content);
 }
 async function completeSetup(options) {
   const { projectDir, strapiDir, strapiUrl: optionUrl, apiToken: optionToken, ignoreSavedToken } = options;
+  if (!await fs13.pathExists(strapiDir)) {
+    if (!options.scaffold) {
+      throw new Error(`Strapi directory not found: ${strapiDir}`);
+    }
+    await scaffoldStrapiProject({
+      strapiDir,
+      ...options.scaffoldOptions
+    });
+  }
   const savedConfig = await loadConfig(projectDir);
   const strapiUrl = optionUrl || savedConfig.strapiUrl || "http://localhost:1337";
   console.log("\u{1F680} Starting complete Strapi setup...\n");
@@ -2408,7 +4290,7 @@ async function completeSetup(options) {
   }
   console.log("\u{1F4F8} Step 5: Uploading images...");
   const mediaMap = await uploadAllImages(projectDir, strapiUrl, token);
-  console.log(`\u2713 Uploaded ${Object.keys(mediaMap).length} images
+  console.log(`\u2713 Mapped ${mediaMap.size} media lookup keys
 `);
   console.log("\u{1F4DD} Step 6: Seeding content...");
   await seedContent(projectDir, strapiUrl, token, mediaMap);
@@ -2419,21 +4301,94 @@ async function completeSetup(options) {
   console.log("   2. Check Content Manager - your content should be there!");
   console.log("   3. Connect your Nuxt app to Strapi API");
 }
+async function scaffoldStrapiProject(options) {
+  const {
+    strapiDir,
+    packageManager = "npm",
+    install = true,
+    run = false,
+    gitInit = false,
+    typescript = true
+  } = options;
+  const resolvedDir = path17.resolve(strapiDir);
+  if (await fs13.pathExists(resolvedDir)) {
+    const entries = await fs13.readdir(resolvedDir);
+    if (entries.length > 0) {
+      throw new Error(`Cannot scaffold Strapi into a non-empty directory: ${resolvedDir}`);
+    }
+  }
+  await fs13.ensureDir(path17.dirname(resolvedDir));
+  const args = [
+    "create-strapi@latest",
+    resolvedDir,
+    typescript ? "--typescript" : "--javascript",
+    "--skip-cloud",
+    "--skip-db",
+    "--no-example",
+    install ? "--install" : "--no-install",
+    gitInit ? "--git-init" : "--no-git-init",
+    `--use-${packageManager}`
+  ];
+  if (!run) {
+    args.push("--no-run");
+  }
+  console.log("\u{1F3D7}\uFE0F  Scaffolding Strapi project...");
+  console.log(`   npx ${args.join(" ")}`);
+  await runCommand("npx", args, process.cwd());
+  if (!await fs13.pathExists(path17.join(resolvedDir, "package.json"))) {
+    throw new Error(`Strapi scaffold did not create a project at ${resolvedDir}`);
+  }
+  console.log(`\u2713 Strapi project scaffolded at ${resolvedDir}`);
+}
+function runCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
+      }
+    });
+  });
+}
 async function installSchemas(projectDir, strapiDir) {
-  if (!await fs11.pathExists(strapiDir)) {
+  if (!await fs13.pathExists(strapiDir)) {
     console.error(`   \u2717 Strapi directory not found: ${strapiDir}`);
-    console.error(`   Resolved to: ${path13.resolve(strapiDir)}`);
+    console.error(`   Resolved to: ${path17.resolve(strapiDir)}`);
     throw new Error(`Strapi directory not found: ${strapiDir}`);
   }
-  const packageJsonPath = path13.join(strapiDir, "package.json");
-  if (await fs11.pathExists(packageJsonPath)) {
-    const pkg = await fs11.readJson(packageJsonPath);
+  const packageJsonPath = path17.join(strapiDir, "package.json");
+  if (await fs13.pathExists(packageJsonPath)) {
+    const pkg = await fs13.readJson(packageJsonPath);
     if (!pkg.dependencies?.["@strapi/strapi"]) {
       console.warn(`   \u26A0\uFE0F  Warning: ${strapiDir} may not be a Strapi project`);
     }
   }
-  const schemaDir = path13.join(projectDir, "cms-schemas");
-  const schemaFiles = await glob2("*.json", {
+  const schemaDir = path17.join(projectDir, "cms-schemas");
+  const componentsDir = path17.join(schemaDir, "components");
+  if (await fs13.pathExists(componentsDir)) {
+    const componentFiles = await glob5("**/*.json", {
+      cwd: componentsDir,
+      absolute: false
+    });
+    if (componentFiles.length > 0) {
+      console.log(`   Found ${componentFiles.length} component(s)`);
+      for (const file of componentFiles) {
+        const sourcePath = path17.join(componentsDir, file);
+        const targetPath = path17.join(strapiDir, "src", "components", file);
+        await fs13.ensureDir(path17.dirname(targetPath));
+        await fs13.copy(sourcePath, targetPath);
+        console.log(`   \u2713 Component: ${file}`);
+      }
+    }
+  }
+  const schemaFiles = await glob5("*.json", {
     cwd: schemaDir,
     absolute: false
   });
@@ -2443,42 +4398,42 @@ async function installSchemas(projectDir, strapiDir) {
   }
   console.log(`   Found ${schemaFiles.length} schema file(s)`);
   for (const file of schemaFiles) {
-    const schemaPath = path13.join(schemaDir, file);
-    const schema = await fs11.readJson(schemaPath);
-    const singularName = schema.info?.singularName || path13.basename(file, ".json");
+    const schemaPath = path17.join(schemaDir, file);
+    const schema = await fs13.readJson(schemaPath);
+    const singularName = schema.info?.singularName || path17.basename(file, ".json");
     console.log(`   Installing ${singularName}...`);
     try {
-      const apiPath = path13.join(strapiDir, "src", "api", singularName);
-      const contentTypesPath = path13.join(
+      const apiPath = path17.join(strapiDir, "src", "api", singularName);
+      const contentTypesPath = path17.join(
         apiPath,
         "content-types",
         singularName
       );
-      const targetPath = path13.join(contentTypesPath, "schema.json");
-      await fs11.ensureDir(contentTypesPath);
-      await fs11.ensureDir(path13.join(apiPath, "routes"));
-      await fs11.ensureDir(path13.join(apiPath, "controllers"));
-      await fs11.ensureDir(path13.join(apiPath, "services"));
-      await fs11.writeJson(targetPath, schema, { spaces: 2 });
+      const targetPath = path17.join(contentTypesPath, "schema.json");
+      await fs13.ensureDir(contentTypesPath);
+      await fs13.ensureDir(path17.join(apiPath, "routes"));
+      await fs13.ensureDir(path17.join(apiPath, "controllers"));
+      await fs13.ensureDir(path17.join(apiPath, "services"));
+      await fs13.writeJson(targetPath, schema, { spaces: 2 });
       const routeContent = `import { factories } from '@strapi/strapi';
          export default factories.createCoreRouter('api::${singularName}.${singularName}');
         `;
-      await fs11.writeFile(
-        path13.join(apiPath, "routes", `${singularName}.ts`),
+      await fs13.writeFile(
+        path17.join(apiPath, "routes", `${singularName}.ts`),
         routeContent
       );
       const controllerContent = `import { factories } from '@strapi/strapi';
          export default factories.createCoreController('api::${singularName}.${singularName}');
         `;
-      await fs11.writeFile(
-        path13.join(apiPath, "controllers", `${singularName}.ts`),
+      await fs13.writeFile(
+        path17.join(apiPath, "controllers", `${singularName}.ts`),
         controllerContent
       );
       const serviceContent = `import { factories } from '@strapi/strapi';
          export default factories.createCoreService('api::${singularName}.${singularName}');
         `;
-      await fs11.writeFile(
-        path13.join(apiPath, "services", `${singularName}.ts`),
+      await fs13.writeFile(
+        path17.join(apiPath, "services", `${singularName}.ts`),
         serviceContent
       );
     } catch (error) {
@@ -2561,12 +4516,12 @@ async function getExistingMedia(strapiUrl, apiToken) {
 }
 async function uploadAllImages(projectDir, strapiUrl, apiToken) {
   const mediaMap = /* @__PURE__ */ new Map();
-  const imagesDir = path13.join(projectDir, "public", "assets", "images");
-  if (!await fs11.pathExists(imagesDir)) {
+  const imagesDir = path17.join(projectDir, "public", "assets", "images");
+  if (!await fs13.pathExists(imagesDir)) {
     console.log("   No images directory found");
     return mediaMap;
   }
-  const imageFiles = await glob2("**/*.{jpg,jpeg,png,gif,webp,svg}", {
+  const imageFiles = await glob5("**/*.{jpg,jpeg,png,gif,webp,avif,svg}", {
     cwd: imagesDir,
     absolute: false
   });
@@ -2576,19 +4531,17 @@ async function uploadAllImages(projectDir, strapiUrl, apiToken) {
   let skippedCount = 0;
   console.log(`   Processing ${imageFiles.length} images...`);
   for (const imageFile of imageFiles) {
-    const fileName = path13.basename(imageFile);
+    const fileName = path17.basename(imageFile);
     const existingId = existingMedia.get(fileName);
     if (existingId) {
-      mediaMap.set(`/images/${imageFile}`, existingId);
-      mediaMap.set(imageFile, existingId);
+      addMediaMapEntries(mediaMap, imageFile, existingId);
       skippedCount++;
       continue;
     }
-    const imagePath = path13.join(imagesDir, imageFile);
+    const imagePath = path17.join(imagesDir, imageFile);
     const mediaId = await uploadImage(imagePath, imageFile, strapiUrl, apiToken);
     if (mediaId) {
-      mediaMap.set(`/images/${imageFile}`, mediaId);
-      mediaMap.set(imageFile, mediaId);
+      addMediaMapEntries(mediaMap, imageFile, mediaId);
       uploadedCount++;
       console.log(`   \u2713 ${imageFile}`);
     }
@@ -2598,7 +4551,7 @@ async function uploadAllImages(projectDir, strapiUrl, apiToken) {
 }
 async function uploadImage(filePath, fileName, strapiUrl, apiToken) {
   try {
-    const fileBuffer = await fs11.readFile(filePath);
+    const fileBuffer = await fs13.readFile(filePath);
     const mimeType = getMimeType(fileName);
     const blob = new Blob([fileBuffer], { type: mimeType });
     const formData = new globalThis.FormData();
@@ -2625,30 +4578,31 @@ async function uploadImage(filePath, fileName, strapiUrl, apiToken) {
   }
 }
 function getMimeType(fileName) {
-  const ext = path13.extname(fileName).toLowerCase();
+  const ext = path17.extname(fileName).toLowerCase();
   const mimeTypes = {
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",
     ".png": "image/png",
     ".gif": "image/gif",
     ".webp": "image/webp",
+    ".avif": "image/avif",
     ".svg": "image/svg+xml"
   };
   return mimeTypes[ext] || "application/octet-stream";
 }
 async function seedContent(projectDir, strapiUrl, apiToken, mediaMap) {
-  const seedPath = path13.join(projectDir, "cms-seed", "seed-data.json");
-  if (!await fs11.pathExists(seedPath)) {
+  const seedPath = path17.join(projectDir, "cms-seed", "seed-data.json");
+  if (!await fs13.pathExists(seedPath)) {
     console.log("   No seed data found");
     return;
   }
-  const seedData = await fs11.readJson(seedPath);
-  const schemasDir = path13.join(projectDir, "cms-schemas");
+  const seedData = await fs13.readJson(seedPath);
+  const schemasDir = path17.join(projectDir, "cms-schemas");
   const schemas = /* @__PURE__ */ new Map();
-  const schemaFiles = await glob2("*.json", { cwd: schemasDir });
+  const schemaFiles = await glob5("*.json", { cwd: schemasDir });
   for (const file of schemaFiles) {
-    const schema = await fs11.readJson(path13.join(schemasDir, file));
-    const name = path13.basename(file, ".json");
+    const schema = await fs13.readJson(path17.join(schemasDir, file));
+    const name = path17.basename(file, ".json");
     schemas.set(name, schema);
   }
   let successCount = 0;
@@ -2693,12 +4647,12 @@ function processMediaFields(data, mediaMap) {
   const processed = {};
   for (const [key, value] of Object.entries(data)) {
     if (typeof value === "string") {
-      if (key.includes("image") || key.includes("bg") || value.startsWith("/images/")) {
-        const mediaId = mediaMap.get(value);
+      if (key.includes("image") || key.includes("img") || key.includes("bg") || value.startsWith("/images/") || value.startsWith("images/") || value.startsWith("/assets/images/") || value.startsWith("assets/images/") || isLikelyImagePath(value)) {
+        const mediaId = findMediaId(mediaMap, value);
         if (mediaId) {
           processed[key] = mediaId;
         } else {
-          processed[key] = value;
+          processed[key] = null;
         }
       } else {
         processed[key] = value;
@@ -2709,6 +4663,18 @@ function processMediaFields(data, mediaMap) {
   }
   return processed;
 }
+function addMediaMapEntries(mediaMap, imageFile, mediaId) {
+  for (const key of mediaLookupKeys(imageFile)) {
+    mediaMap.set(key, mediaId);
+  }
+}
+function findMediaId(mediaMap, value) {
+  for (const key of mediaLookupKeys(value)) {
+    const mediaId = mediaMap.get(key);
+    if (mediaId) return mediaId;
+  }
+  return void 0;
+}
 async function createEntry(contentType, data, strapiUrl, apiToken) {
   try {
     const response = await fetch(`${strapiUrl}/api/${contentType}`, {
@@ -2799,77 +4765,452 @@ async function prompt(question) {
     });
   });
 }
-async function confirm(question) {
-  const answer = await prompt(`${question} (y/n): `);
+async function confirm(question, defaultYes = true) {
+  const hint = defaultYes ? "(Y/n)" : "(y/N)";
+  const answer = await prompt(`${question} ${hint}: `);
+  if (answer === "") return defaultYes;
   return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
 }
-program.name("cms").description("SeeMS - Webflow to CMS converter").version("0.1.2");
-program.command("convert").description("Convert Webflow export to Nuxt 3 project").argument("<input>", "Path to Webflow export directory").argument("<output>", "Path to output Nuxt project directory").option(
+function classToCollectionName(className) {
+  let name = className.replace(/^c[-_]/, "").replace(/^cc[-_]/, "").replace(/[-_]card$/, "").replace(/[-_]item$/, "").replace(/[-_]wrapper$/, "");
+  name = name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/-/g, "_").toLowerCase();
+  if (!name.endsWith("s")) {
+    name += "s";
+  }
+  return name;
+}
+function toPackageManager(value) {
+  if (value === "pnpm" || value === "yarn") return value;
+  return "npm";
+}
+async function select(question, choices, defaultValue) {
+  console.log(question);
+  choices.forEach((choice, index2) => {
+    const marker = choice.value === defaultValue ? " default" : "";
+    console.log(pc4.dim(`  ${index2 + 1}. ${choice.label}${marker}`));
+  });
+  const answer = await prompt(pc4.cyan("   > "));
+  if (!answer) return defaultValue;
+  const index = Number(answer) - 1;
+  if (Number.isInteger(index) && choices[index]) return choices[index].value;
+  const direct = choices.find((choice) => choice.value === answer || choice.label.toLowerCase() === answer.toLowerCase());
+  return direct?.value || defaultValue;
+}
+function toProjectTarget(value) {
+  return value === "astro-vue" || value === "astro" ? "astro-vue" : "nuxt";
+}
+async function promptForCollections() {
+  console.log("");
+  console.log(pc4.cyan("\u{1F4CB} Collection Types Configuration"));
+  console.log(pc4.dim("   Collections are repeating items like blog posts, team members, FAQs, etc."));
+  console.log("");
+  const classesInput = await prompt(
+    pc4.white("Enter collection element classes (comma-separated, or press enter to skip):\n") + pc4.dim("   Example: c-blogpost, team-member_card, c-faq-item\n") + pc4.cyan("   > ")
+  );
+  if (!classesInput) {
+    return [];
+  }
+  const classes = classesInput.split(",").map((c) => c.trim()).filter(Boolean);
+  const collections = [];
+  console.log("");
+  console.log(pc4.dim("   Now let's name each collection type:"));
+  console.log("");
+  for (const className of classes) {
+    const suggestedName = classToCollectionName(className);
+    const nameInput = await prompt(
+      pc4.white(`   "${className}" \u2192 Collection name `) + pc4.dim(`(default: ${suggestedName}): `)
+    );
+    collections.push({
+      className,
+      collectionName: nameInput || suggestedName
+    });
+  }
+  return collections;
+}
+async function promptForComponentRules(existing = []) {
+  console.log("");
+  console.log(pc4.cyan("\u{1F9E9} Component Rules"));
+  console.log(pc4.dim("   Add named selectors for reusable blocks you definitely want componentized."));
+  console.log(pc4.dim("   Example: AnnouncementBar = .quantum-zenith-design-system--c-announcement"));
+  console.log("");
+  const rules = [...existing];
+  if (rules.length > 0) {
+    console.log(pc4.dim(`Using ${rules.length} existing component rule(s) from config.`));
+  }
+  const addRules = await confirm(pc4.white("Add a component rule by name and selector?"), false);
+  if (!addRules) return rules;
+  while (true) {
+    const name = await prompt(pc4.cyan("   Component name: "));
+    if (!name) break;
+    const selector = await prompt(pc4.cyan("   CSS selector: "));
+    if (!selector) break;
+    const minPagesInput = await prompt(pc4.cyan("   Minimum pages (2): "));
+    const minPages = Number(minPagesInput) || 2;
+    const role = await select(pc4.cyan("   What kind of component is this?"), [
+      { label: "Shared section/block", value: "shared-section" },
+      { label: "Repeated item rendered with v-for", value: "collection-item" }
+    ], "shared-section");
+    let collectionName;
+    let collectionStorage;
+    if (role === "collection-item") {
+      const suggestedCollection = classToCollectionName(name);
+      const collectionInput = await prompt(
+        pc4.cyan(`   Collection name (${suggestedCollection}): `)
+      );
+      collectionName = collectionInput || suggestedCollection;
+      collectionStorage = await select(pc4.cyan("   How should these repeated items be stored?"), [
+        { label: "Strapi collection type", value: "collection-type" },
+        { label: "Page repeatable field (coming next)", value: "page-repeatable" },
+        { label: "Global repeatable field (coming next)", value: "global-repeatable" }
+      ], "collection-type");
+      if (collectionStorage !== "collection-type") {
+        console.log(pc4.yellow("   Repeatable fields are not fully wired yet; using Strapi collection type for this run."));
+        collectionStorage = "collection-type";
+      }
+    }
+    const contentMode = await select(pc4.cyan("   How should this component's editable content be stored?"), [
+      { label: "Auto/default: shared global for now", value: "auto" },
+      { label: "Shared global content, same everywhere", value: "shared-global" },
+      { label: "Per-page instances, same structure with different content", value: "per-page" }
+    ], "auto");
+    rules.push({
+      name,
+      selector,
+      role,
+      collectionName,
+      collectionStorage,
+      contentMode,
+      minOccurrences: minPages,
+      minPages
+    });
+    const another = await confirm(pc4.white("   Add another component rule?"), false);
+    if (!another) break;
+  }
+  return rules;
+}
+program.name("cms").description("SeeMS - Webflow to CMS converter").version("0.1.3");
+program.command("convert").description("Convert Webflow export to a framework project with CMS integration").argument("[input]", "Path to Webflow export directory").argument("[output]", "Path to output project directory").option("--target <target>", "Output target (nuxt|astro-vue)").option(
   "-b, --boilerplate <source>",
   "Boilerplate source (GitHub URL or local path)"
-).option("-o, --overrides <path>", "Path to overrides JSON file").option("--generate-schemas", "Generate CMS schemas immediately").option(
+).option("-o, --overrides <path>", "Path to overrides JSON file").option("--config <path>", "Path to see-ms config file").option(
   "--cms <type>",
-  "CMS backend type (strapi|contentful|sanity)",
-  "strapi"
-).option("--no-interactive", "Skip interactive prompts").action(async (input, output, options) => {
+  "CMS backend type (strapi|contentful|sanity)"
+).option("--skip-prompts", "Skip interactive prompts (for CI/CD)").option("--collection-classes <classes>", "Comma-separated collection class patterns").option("--no-content", "Skip generating initial CMS content").option("--no-editor", "Skip installing and wiring the inline editor").option("--scaffold-strapi <dir>", "Scaffold a new Strapi project after conversion").option("--strapi-dir <dir>", "Existing Strapi project to set up after conversion").option("--strapi-package-manager <manager>", "Package manager for new Strapi project (npm|pnpm|yarn)", "npm").option("--no-strapi-install", "Scaffold Strapi without installing dependencies").action(async (input, output, options) => {
   try {
+    const skipPrompts = options.skipPrompts || false;
+    if (!input) {
+      if (skipPrompts) throw new Error("Input path is required when --skip-prompts is used");
+      input = await prompt(pc4.cyan("\u{1F4C1} Webflow export directory: "));
+    }
+    if (!output) {
+      if (skipPrompts) throw new Error("Output project directory is required when --skip-prompts is used");
+      const defaultOutput = path18.resolve(process.cwd(), `${path18.basename(path18.resolve(input))}-seems`);
+      const answer = await prompt(pc4.cyan(`\u{1F4C1} Output project directory (${defaultOutput}): `));
+      output = answer || defaultOutput;
+    }
+    console.log("");
+    console.log(pc4.cyan(pc4.bold("\u{1F680} SeeMS Converter")));
+    console.log(pc4.dim(`   Converting: ${input} \u2192 ${output}`));
+    console.log("");
+    const loadedConfig = options.config ? await loadSeeMSConfig(options.config) : {};
+    let collections = (loadedConfig.collections || []).map((collection) => ({
+      className: collection.className,
+      collectionName: collection.name || classToCollectionName(collection.className)
+    }));
+    let generateContent = true;
+    let enableEditor = options.editor !== false && loadedConfig.editor?.enabled !== false;
+    let target = toProjectTarget(options.target || loadedConfig.target);
+    let cmsProvider = options.cms || loadedConfig.cms?.provider || "strapi";
+    let detectComponents = loadedConfig.components?.enabled !== false;
+    let componentMatch = loadedConfig.components?.match || "structure";
+    let componentMinOccurrences = loadedConfig.components?.minOccurrences || 2;
+    let componentMinPages = loadedConfig.components?.minPages || componentMinOccurrences;
+    let componentRules = loadedConfig.components?.rules || [];
+    if (!skipPrompts) {
+      target = toProjectTarget(await select(pc4.cyan("\u{1F3AF} What are you converting to?"), [
+        { label: "Nuxt 3", value: "nuxt" },
+        { label: "Astro + Vue", value: "astro-vue" }
+      ], target));
+      cmsProvider = await select(pc4.cyan("\u{1F9E0} Which CMS provider?"), [
+        { label: "Strapi", value: "strapi" }
+      ], cmsProvider);
+      detectComponents = await confirm(pc4.cyan("Extract shared components from repeated sections?"), detectComponents);
+      if (detectComponents) {
+        componentMatch = await select(pc4.cyan("\u{1F9E9} How strict should component matching be?"), [
+          { label: "Exact repeated HTML blocks", value: "exact" },
+          { label: "Matching DOM structure", value: "structure" }
+        ], componentMatch);
+        componentMinOccurrences = Number(await prompt(pc4.cyan(`Minimum total occurrences (${componentMinOccurrences}): `))) || componentMinOccurrences;
+        componentMinPages = Number(await prompt(pc4.cyan(`Minimum pages (${componentMinPages}): `))) || componentMinPages;
+        componentRules = await promptForComponentRules(componentRules);
+      }
+      if (options.collectionClasses) {
+        const classes = options.collectionClasses.split(",").map((c) => c.trim());
+        collections = classes.map((className) => ({
+          className,
+          collectionName: classToCollectionName(className)
+        }));
+      } else if (collections.length === 0) {
+        collections = await promptForCollections();
+      } else {
+        console.log(pc4.dim(`Using ${collections.length} collection hint(s) from config.`));
+      }
+      console.log("");
+      const previewConfig = normalizeConfig(mergeConfig(loadedConfig, {
+        collections: collections.map((collection) => ({
+          className: collection.className,
+          name: collection.collectionName
+        }))
+      }));
+      const analysis = await analyzeWebflowExport(input, previewConfig);
+      console.log(pc4.cyan("\u{1F50E} Analysis Preview"));
+      console.log(pc4.dim(`  \u2022 Pages: ${analysis.pages.length}`));
+      analysis.pages.slice(0, 8).forEach((page) => {
+        console.log(pc4.dim(`    - ${page.sourcePath} \u2192 ${page.route}`));
+      });
+      if (analysis.pages.length > 8) {
+        console.log(pc4.dim(`    \u2026 ${analysis.pages.length - 8} more`));
+      }
+      console.log(pc4.dim(`  \u2022 Component candidates: ${analysis.componentCandidates.length}`));
+      analysis.componentCandidates.slice(0, 8).forEach((component) => {
+        console.log(pc4.dim(`    - ${component.name} (${component.confidence}) on ${component.pages.length} pages`));
+      });
+      generateContent = await confirm(
+        pc4.white("Generate initial CMS content from HTML?")
+      );
+      enableEditor = await confirm(
+        pc4.white("Install and wire the inline editor overlay?"),
+        true
+      );
+    } else if (options.collectionClasses) {
+      const classes = options.collectionClasses.split(",").map((c) => c.trim());
+      collections = classes.map((className) => ({
+        className,
+        collectionName: classToCollectionName(className)
+      }));
+    }
+    console.log("");
+    console.log(pc4.green("\u2713 Configuration:"));
+    console.log(pc4.dim(`  \u2022 Target: ${target === "astro-vue" ? "Astro + Vue" : "Nuxt 3"}`));
+    console.log(pc4.dim(`  \u2022 CMS: ${cmsProvider}`));
+    console.log(pc4.dim(`  \u2022 Component matching: ${componentMatch}, ${componentMinOccurrences}+ occurrences on ${componentMinPages}+ pages`));
+    if (componentRules.length > 0) {
+      console.log(pc4.dim(`  \u2022 Component rules: ${componentRules.map((rule) => {
+        const role = rule.role || "shared-section";
+        const contentMode = rule.contentMode || "auto";
+        const collection = rule.role === "collection-item" && rule.collectionName ? `, collection: ${rule.collectionName}` : "";
+        return `${rule.name} (${rule.selector}, ${role}, ${contentMode}${collection})`;
+      }).join(", ")}`));
+    }
+    if (collections.length > 0) {
+      console.log(pc4.dim(`  \u2022 Collections: ${collections.map((c) => `${c.className} \u2192 ${c.collectionName}`).join(", ")}`));
+    } else {
+      console.log(pc4.dim("  \u2022 Collections: none (auto-detect disabled)"));
+    }
+    console.log(pc4.dim(`  \u2022 Generate content: ${generateContent}`));
+    console.log(pc4.dim(`  \u2022 Inline editor: ${enableEditor ? "enabled" : "disabled"}`));
+    console.log("");
+    console.log(pc4.blue("\u{1F4E6} Running conversion..."));
+    console.log("");
+    const cliConfig = {
+      target,
+      cms: { provider: cmsProvider },
+      collections: collections.map((collection) => ({
+        className: collection.className,
+        name: collection.collectionName
+      })),
+      editor: {
+        enabled: enableEditor,
+        previewParam: "preview"
+      },
+      components: {
+        ...loadedConfig.components,
+        enabled: detectComponents,
+        match: componentMatch,
+        minOccurrences: componentMinOccurrences,
+        minPages: componentMinPages,
+        rules: componentRules
+      }
+    };
     await convertWebflowExport({
       inputDir: input,
       outputDir: output,
       boilerplate: options.boilerplate,
       overridesPath: options.overrides,
-      generateStrapi: options.generateSchemas,
-      cmsBackend: options.cms
+      configPath: options.config,
+      config: mergeConfig(loadedConfig, cliConfig),
+      generateStrapi: true,
+      cmsBackend: cmsProvider,
+      target,
+      collectionClasses: collections.map((c) => c.className),
+      collectionNames: Object.fromEntries(collections.map((c) => [c.className, c.collectionName])),
+      extractComponents: true,
+      skipPrompts: true,
+      generateContent: generateContent && !options.noContent,
+      editor: enableEditor
     });
-    if (options.interactive && options.cms === "strapi") {
+    console.log(pc4.green("\n\u{1F389} Conversion complete!"));
+    const configStrapi = loadedConfig.cms?.strapi;
+    const requestedStrapiDir = options.scaffoldStrapi || options.strapiDir || configStrapi?.directory;
+    const shouldScaffoldFromConfig = Boolean(configStrapi?.scaffold && requestedStrapiDir);
+    if (cmsProvider === "strapi" && skipPrompts && requestedStrapiDir) {
+      await completeSetup({
+        projectDir: output,
+        strapiDir: requestedStrapiDir,
+        scaffold: Boolean(options.scaffoldStrapi) || shouldScaffoldFromConfig,
+        scaffoldOptions: {
+          strapiDir: requestedStrapiDir,
+          packageManager: toPackageManager(options.strapiPackageManager || configStrapi?.packageManager || "npm"),
+          install: options.strapiInstall !== false && configStrapi?.install !== false,
+          run: false,
+          gitInit: false,
+          typescript: true
+        }
+      });
+    }
+    if (cmsProvider === "strapi" && !skipPrompts) {
       console.log("");
       const shouldSetup = await confirm(
-        pc4.cyan("\u{1F3AF} Would you like to setup Strapi now?")
+        pc4.cyan("\u{1F3AF} Would you like to set up Strapi now?"),
+        false
       );
       if (shouldSetup) {
         const strapiDir = await prompt(
-          pc4.cyan(
-            "\u{1F4C1} Enter path to your Strapi directory (e.g., ./strapi-dev): "
-          )
+          pc4.cyan("\u{1F4C1} Enter path to your Strapi directory: ")
         );
         if (strapiDir) {
-          console.log("");
-          console.log(pc4.cyan("\u{1F680} Starting Strapi setup..."));
-          console.log("");
+          const strapiExists = await fs14.pathExists(strapiDir);
+          const shouldScaffold = !strapiExists ? await confirm(
+            pc4.cyan("That Strapi directory does not exist. Scaffold a new Strapi project there?"),
+            true
+          ) : false;
+          console.log(pc4.cyan("\n\u{1F680} Starting Strapi setup..."));
           try {
             await completeSetup({
               projectDir: output,
-              strapiDir
+              strapiDir,
+              scaffold: shouldScaffold,
+              scaffoldOptions: {
+                strapiDir,
+                packageManager: toPackageManager(options.strapiPackageManager || configStrapi?.packageManager || "npm"),
+                install: options.strapiInstall !== false && configStrapi?.install !== false,
+                run: false,
+                gitInit: false,
+                typescript: true
+              }
             });
           } catch (error) {
             console.error(pc4.red("\n\u274C Strapi setup failed"));
             console.error(pc4.dim("You can run setup manually later with:"));
-            console.error(
-              pc4.dim(`  cms setup-strapi ${output} ${strapiDir}`)
-            );
+            console.error(pc4.dim(`  cms setup-strapi ${output} ${strapiDir}`));
           }
         }
       } else {
-        console.log("");
-        console.log(pc4.dim("\u{1F4A1} You can setup Strapi later with:"));
-        console.log(
-          pc4.dim(`   cms setup-strapi ${output} <strapi-directory>`)
-        );
+        console.log(pc4.dim("\n\u{1F4A1} You can setup Strapi later with:"));
+        console.log(pc4.dim(`   cms setup-strapi ${output} <strapi-directory>`));
       }
     }
   } catch (error) {
-    console.error(pc4.red("Conversion failed"));
+    console.error(pc4.red("\nConversion failed:"));
+    console.error(pc4.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+});
+program.command("analyze").description("Analyze a Webflow export and preview pages, assets, and component candidates").argument("[input]", "Path to Webflow export directory").option("--config <path>", "Path to see-ms config file").action(async (input, options) => {
+  try {
+    if (!input) {
+      input = await prompt(pc4.cyan("\u{1F4C1} Webflow export directory to analyze: "));
+    }
+    const config = options.config ? await loadSeeMSConfig(options.config) : {};
+    const analysis = await analyzeWebflowExport(input, normalizeConfig(config));
+    const report = {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      stages: ["scan", "analyze", "plan"],
+      pages: analysis.pages.map((page) => ({
+        source: page.sourcePath,
+        pageId: page.pageId,
+        route: page.route,
+        output: page.outputPath
+      })),
+      assets: {
+        css: analysis.assets.css.length,
+        images: analysis.assets.images.length,
+        fonts: analysis.assets.fonts.length,
+        js: analysis.assets.js.length,
+        preservedStructure: true
+      },
+      components: analysis.componentCandidates,
+      cms: {
+        provider: config.cms?.provider || "strapi",
+        fields: 0,
+        collections: 0,
+        schemas: 0,
+        seedPages: 0
+      },
+      warnings: analysis.warnings
+    };
+    console.log(renderReportMarkdown(report));
+  } catch (error) {
+    console.error(pc4.red("\nAnalysis failed:"));
+    console.error(pc4.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+});
+program.command("scaffold-strapi").description("Scaffold a new Strapi project for a converted SeeMS site").argument("[strapi-dir]", "Path where the new Strapi project should be created").option("--package-manager <manager>", "Package manager (npm|pnpm|yarn)", "npm").option("--no-install", "Create project files without installing dependencies").option("--run", "Start Strapi after scaffolding").option("--git-init", "Initialize a git repository for the Strapi project").option("--javascript", "Use JavaScript instead of TypeScript").action(async (strapiDir, options) => {
+  try {
+    if (!strapiDir) {
+      strapiDir = await prompt(pc4.cyan("\u{1F4C1} New Strapi project directory: "));
+    }
+    const install = options.install !== false && await confirm(
+      pc4.cyan("Install Strapi dependencies after scaffolding?"),
+      true
+    );
+    await scaffoldStrapiProject({
+      strapiDir,
+      packageManager: toPackageManager(options.packageManager),
+      install,
+      run: Boolean(options.run),
+      gitInit: Boolean(options.gitInit),
+      typescript: !options.javascript
+    });
+  } catch (error) {
+    console.error(pc4.red("Strapi scaffold failed"));
+    console.error(error);
     process.exit(1);
   }
 });
-program.command("setup-strapi").description("Setup Strapi with schemas and seed data").argument("<project-dir>", "Path to converted project directory").argument("<strapi-dir>", "Path to Strapi directory").option("--url <url>", "Strapi URL", "http://localhost:1337").option("--token <token>", "Strapi API token (optional)").option("--new-token", "Ignore saved token and prompt for a new one").action(async (projectDir, strapiDir, options) => {
+program.command("setup-strapi").description("Setup Strapi with schemas and seed data").argument("[project-dir]", "Path to converted project directory").argument("[strapi-dir]", "Path to Strapi directory").option("--url <url>", "Strapi URL", "http://localhost:1337").option("--token <token>", "Strapi API token (optional)").option("--new-token", "Ignore saved token and prompt for a new one").option("--scaffold", "Create the Strapi project if the target directory does not exist").option("--package-manager <manager>", "Package manager for scaffolding (npm|pnpm|yarn)", "npm").option("--no-install", "Scaffold without installing dependencies").action(async (projectDir, strapiDir, options) => {
   try {
+    if (!projectDir) {
+      projectDir = await prompt(pc4.cyan("\u{1F4C1} Converted project directory: "));
+    }
+    if (!strapiDir) {
+      strapiDir = await prompt(pc4.cyan("\u{1F4C1} Strapi directory: "));
+    }
+    const strapiExists = strapiDir ? await fs14.pathExists(strapiDir) : false;
+    const scaffold = Boolean(options.scaffold) || !strapiExists && await confirm(
+      pc4.cyan("That Strapi directory does not exist. Scaffold it now?"),
+      true
+    );
+    const install = options.install !== false && (!scaffold || await confirm(
+      pc4.cyan("Install Strapi dependencies after scaffolding?"),
+      true
+    ));
     await completeSetup({
       projectDir,
       strapiDir,
       strapiUrl: options.url,
       apiToken: options.token,
-      ignoreSavedToken: options.newToken
+      ignoreSavedToken: options.newToken,
+      scaffold,
+      scaffoldOptions: {
+        strapiDir,
+        packageManager: toPackageManager(options.packageManager),
+        install,
+        run: false,
+        gitInit: false,
+        typescript: true
+      }
     });
   } catch (error) {
     console.error(pc4.red("Strapi setup failed"));
@@ -2877,19 +5218,30 @@ program.command("setup-strapi").description("Setup Strapi with schemas and seed
     process.exit(1);
   }
 });
-program.command("generate").description("Generate CMS schemas from manifest").argument("<manifest>", "Path to cms-manifest.json").option("-t, --type <cms>", "CMS type (strapi|contentful|sanity)", "strapi").option("-o, --output <dir>", "Output directory for schemas").action(async (manifestPath, options) => {
+program.command("generate").description("Generate CMS schemas from manifest").argument("[manifest]", "Path to cms-manifest.json").option("-t, --type <cms>", "CMS type (strapi|contentful|sanity)", "strapi").option("-o, --output <dir>", "Output directory for schemas").action(async (manifestPath, options) => {
   try {
+    if (!manifestPath) {
+      manifestPath = await prompt(pc4.cyan("\u{1F4C4} Path to cms-manifest.json: "));
+    }
     console.log(pc4.cyan("\u{1F5C2}\uFE0F  SeeMS Schema Generator"));
     console.log(pc4.dim(`Reading manifest from: ${manifestPath}`));
-    const manifestExists = await fs12.pathExists(manifestPath);
+    const manifestExists = await fs14.pathExists(manifestPath);
     if (!manifestExists) {
       throw new Error(`Manifest file not found: ${manifestPath}`);
     }
-    const manifestContent = await fs12.readFile(manifestPath, "utf-8");
+    const manifestContent = await fs14.readFile(manifestPath, "utf-8");
     const manifest = JSON.parse(manifestContent);
     console.log(pc4.green(`  \u2713 Manifest loaded successfully`));
-    const outputDir = options.output || path14.dirname(manifestPath);
-    if (options.type !== "strapi") {
+    const type = options.type || await select(pc4.cyan("\u{1F9E0} Generate schemas for which CMS?"), [
+      { label: "Strapi", value: "strapi" }
+    ], "strapi");
+    let outputDir = options.output;
+    if (!outputDir) {
+      const defaultOutput = path18.dirname(manifestPath);
+      const answer = await prompt(pc4.cyan(`\u{1F4C1} Schema output directory (${defaultOutput}): `));
+      outputDir = answer || defaultOutput;
+    }
+    if (type !== "strapi") {
       console.log(
         pc4.yellow(
           `\u26A0\uFE0F  Only Strapi is currently supported. Using Strapi schema format.`
@@ -2899,13 +5251,18 @@ program.command("generate").description("Generate CMS schemas from manifest").ar
     console.log(pc4.blue("\n\u{1F4CB} Generating Strapi schemas..."));
     const schemas = manifestToSchemas(manifest);
     await writeAllSchemas(outputDir, schemas);
+    const linkSchema = getLinkComponentSchema(manifest);
+    if (linkSchema) {
+      await writeLinkComponentSchema(outputDir);
+      console.log(pc4.dim("  \u2713 Generated shared.link component"));
+    }
     await createStrapiReadme(outputDir);
     console.log(
       pc4.green(
         `  \u2713 Generated ${Object.keys(schemas).length} Strapi content types`
       )
     );
-    console.log(pc4.dim(`  \u2713 Schemas written to: ${path14.join(outputDir, "cms-schemas")}/`));
+    console.log(pc4.dim(`  \u2713 Schemas written to: ${path18.join(outputDir, "cms-schemas")}/`));
     console.log(pc4.green("\n\u2705 Schema generation completed successfully!"));
   } catch (error) {
     console.error(pc4.red("\n\u274C Schema generation failed:"));