prev-cli 0.24.11 → 0.24.12

package/dist/cli.js

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { parseArgs } from "util";
 import path11 from "path";
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5, rmSync as rmSync3, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5, rmSync as rmSync3, readFileSync as readFileSync6 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/vite/start.ts
@@ -18,7 +18,7 @@ import rehypeHighlight from "rehype-highlight";
 import path8 from "path";
 import os from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
 
 // src/vite/plugins/pages-plugin.ts
 import path2 from "path";
@@ -402,10 +402,89 @@ function entryPlugin(rootDir) {
 // src/vite/previews.ts
 import fg2 from "fast-glob";
 import path4 from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+
+// src/vite/config-parser.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import * as yaml from "js-yaml";
+
+// src/vite/preview-types.ts
+import { z } from "zod";
+var configSchema = z.object({
+  tags: z.union([
+    z.array(z.string()),
+    z.string().transform((s) => [s])
+  ]).optional(),
+  category: z.string().optional(),
+  status: z.enum(["draft", "stable", "deprecated"]).optional(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  order: z.number().optional()
+});
+
+// src/vite/config-parser.ts
+async function parsePreviewConfig(filePath) {
+  if (!existsSync2(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    const parsed = yaml.load(content);
+    const result = configSchema.safeParse(parsed);
+    if (result.success) {
+      return result.data;
+    }
+    console.warn(`Invalid config at ${filePath}:`, result.error.message);
+    return null;
+  } catch (err) {
+    console.warn(`Error parsing config at ${filePath}:`, err);
+    return null;
+  }
+}
+async function parseFlowDefinition(filePath) {
+  if (!existsSync2(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    const parsed = yaml.load(content);
+    if (!parsed.name || !Array.isArray(parsed.steps)) {
+      return null;
+    }
+    return parsed;
+  } catch (err) {
+    console.warn(`Error parsing flow at ${filePath}:`, err);
+    return null;
+  }
+}
+async function parseAtlasDefinition(filePath) {
+  if (!existsSync2(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    const parsed = yaml.load(content);
+    if (!parsed.name || !parsed.hierarchy?.root || !parsed.hierarchy?.areas) {
+      return null;
+    }
+    return parsed;
+  } catch (err) {
+    console.warn(`Error parsing atlas at ${filePath}:`, err);
+    return null;
+  }
+}
+
+// src/vite/previews.ts
+var PREVIEW_TYPE_FOLDERS = ["components", "screens", "flows", "atlas"];
+var TYPE_MAP = {
+  components: "component",
+  screens: "screen",
+  flows: "flow",
+  atlas: "atlas"
+};
 async function scanPreviews(rootDir) {
   const previewsDir = path4.join(rootDir, "previews");
-  if (!existsSync2(previewsDir)) {
+  if (!existsSync3(previewsDir)) {
     return [];
   }
   const entryFiles = await fg2.glob("**/{index.html,App.tsx,App.jsx,index.tsx,index.jsx}", {
@@ -434,7 +513,7 @@ async function scanPreviewFiles(previewDir) {
     ignore: ["node_modules/**", "dist/**"]
   });
   return files.map((file) => {
-    const content = readFileSync2(path4.join(previewDir, file), "utf-8");
+    const content = readFileSync3(path4.join(previewDir, file), "utf-8");
     const ext = path4.extname(file).slice(1);
     return {
       path: file,
@@ -462,6 +541,78 @@ async function buildPreviewConfig(previewDir) {
     tailwind: true
   };
 }
+async function scanPreviewUnits(rootDir) {
+  const previewsDir = path4.join(rootDir, "previews");
+  if (!existsSync3(previewsDir)) {
+    return [];
+  }
+  const units = [];
+  for (const typeFolder of PREVIEW_TYPE_FOLDERS) {
+    const typeDir = path4.join(previewsDir, typeFolder);
+    if (!existsSync3(typeDir))
+      continue;
+    const type = TYPE_MAP[typeFolder];
+    const entries = await fg2.glob("*/", {
+      cwd: typeDir,
+      onlyDirectories: true,
+      deep: 1
+    });
+    for (const entry of entries) {
+      const name = entry.replace(/\/$/, "");
+      const unitDir = path4.join(typeDir, name);
+      const files = await detectUnitFiles(unitDir, type);
+      if (!files.index)
+        continue;
+      const configPath = existsSync3(path4.join(unitDir, "config.yaml")) ? path4.join(unitDir, "config.yaml") : path4.join(unitDir, "config.yml");
+      const config = await parsePreviewConfig(configPath);
+      units.push({
+        type,
+        name,
+        path: unitDir,
+        route: `/_preview/${typeFolder}/${name}`,
+        config,
+        files
+      });
+    }
+  }
+  return units;
+}
+async function detectUnitFiles(unitDir, type) {
+  const allFiles = await fg2.glob("*", { cwd: unitDir });
+  let index;
+  if (type === "flow" || type === "atlas") {
+    index = allFiles.find((f) => f === "index.yaml" || f === "index.yml");
+  } else {
+    const priorities = [
+      "index.tsx",
+      "index.jsx",
+      "index.ts",
+      "index.js",
+      "App.tsx",
+      "App.jsx",
+      "index.html"
+    ];
+    index = priorities.find((p) => allFiles.includes(p));
+  }
+  const result = {
+    index: index || ""
+  };
+  if (type === "screen" && index) {
+    const stateFiles = allFiles.filter((f) => (f.endsWith(".tsx") || f.endsWith(".jsx")) && f !== index).sort();
+    if (stateFiles.length > 0) {
+      result.states = stateFiles;
+    }
+  }
+  if (type === "component") {
+    if (allFiles.includes("schema.ts")) {
+      result.schema = "schema.ts";
+    }
+  }
+  if (allFiles.includes("docs.mdx") || allFiles.includes("README.mdx")) {
+    result.docs = allFiles.find((f) => f.endsWith(".mdx"));
+  }
+  return result;
+}
 
 // src/preview-runtime/build.ts
 import { build } from "esbuild";
@@ -578,7 +729,7 @@ async function buildPreviewHtml(config) {
 }
 
 // src/vite/plugins/previews-plugin.ts
-import { existsSync as existsSync3, mkdirSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
 import path5 from "path";
 var VIRTUAL_MODULE_ID2 = "virtual:prev-previews";
 var RESOLVED_VIRTUAL_MODULE_ID2 = "\x00" + VIRTUAL_MODULE_ID2;
@@ -596,12 +747,39 @@ function previewsPlugin(rootDir) {
     },
     async load(id) {
       if (id === RESOLVED_VIRTUAL_MODULE_ID2) {
-        const previews = await scanPreviews(rootDir);
-        return `export const previews = ${JSON.stringify(previews)};`;
+        const units = await scanPreviewUnits(rootDir);
+        const legacyPreviews = await scanPreviews(rootDir);
+        return `
+// Multi-type preview units
+export const previewUnits = ${JSON.stringify(units)};
+
+// Legacy flat previews (backwards compatibility)
+export const previews = ${JSON.stringify(legacyPreviews)};
+
+// Filtering helpers
+export function getByType(type) {
+  return previewUnits.filter(u => u.type === type);
+}
+
+export function getByTags(tags) {
+  return previewUnits.filter(u =>
+    u.config?.tags?.some(t => tags.includes(t))
+  );
+}
+
+export function getByCategory(category) {
+  return previewUnits.filter(u => u.config?.category === category);
+}
+
+export function getByStatus(status) {
+  return previewUnits.filter(u => u.config?.status === status);
+}
+`;
       }
     },
     handleHotUpdate({ file, server }) {
-      if (file.includes("/previews/") && /\.(html|tsx|ts|jsx|js|css)$/.test(file)) {
+      const previewsPath = path5.sep + "previews" + path5.sep;
+      if ((file.includes(previewsPath) || file.includes("/previews/")) && /\.(html|tsx|ts|jsx|js|css|yaml|yml|mdx)$/.test(file)) {
         const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID2);
         if (mod) {
           server.moduleGraph.invalidateModule(mod);
@@ -616,10 +794,10 @@ function previewsPlugin(rootDir) {
       const targetDir = path5.join(distDir, "_preview");
       const previewsDir = path5.join(rootDir, "previews");
       const oldPreviewsDir = path5.join(distDir, "previews");
-      if (existsSync3(oldPreviewsDir)) {
+      if (existsSync4(oldPreviewsDir)) {
         rmSync(oldPreviewsDir, { recursive: true });
       }
-      if (existsSync3(targetDir)) {
+      if (existsSync4(targetDir)) {
         rmSync(targetDir, { recursive: true });
       }
       const previews = await scanPreviews(rootDir);
@@ -758,15 +936,15 @@ function validateConfig(raw) {
   return config;
 }
 // src/config/loader.ts
-import { readFileSync as readFileSync3, existsSync as existsSync4, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync5, writeFileSync as writeFileSync3 } from "fs";
 import path6 from "path";
-import yaml from "js-yaml";
+import yaml2 from "js-yaml";
 function findConfigFile(rootDir) {
   const yamlPath = path6.join(rootDir, ".prev.yaml");
   const ymlPath = path6.join(rootDir, ".prev.yml");
-  if (existsSync4(yamlPath))
+  if (existsSync5(yamlPath))
     return yamlPath;
-  if (existsSync4(ymlPath))
+  if (existsSync5(ymlPath))
     return ymlPath;
   return null;
 }
@@ -776,8 +954,8 @@ function loadConfig(rootDir) {
     return defaultConfig;
   }
   try {
-    const content = readFileSync3(configPath, "utf-8");
-    const raw = yaml.load(content);
+    const content = readFileSync4(configPath, "utf-8");
+    const raw = yaml2.load(content);
     return validateConfig(raw);
   } catch (error) {
     console.warn(`Warning: Failed to parse ${configPath}:`, error);
@@ -786,7 +964,7 @@ function loadConfig(rootDir) {
 }
 function saveConfig(rootDir, config) {
   const configPath = findConfigFile(rootDir) || path6.join(rootDir, ".prev.yaml");
-  const content = yaml.dump(config, {
+  const content = yaml2.dump(config, {
     indent: 2,
     lineWidth: -1,
     quotingType: '"',
@@ -898,6 +1076,12 @@ function getDebugCollector() {
 }
 
 // src/vite/config.ts
+var TYPE_SINGULAR = {
+  components: "component",
+  screens: "screen",
+  flows: "flow",
+  atlas: "atlas"
+};
 function createFriendlyLogger() {
   const logger = createLogger("info", { allowClearScreen: false });
   const hiddenPatterns = [
@@ -955,9 +1139,9 @@ function findCliRoot2() {
   let dir = path8.dirname(fileURLToPath2(import.meta.url));
   for (let i = 0;i < 10; i++) {
     const pkgPath = path8.join(dir, "package.json");
-    if (existsSync5(pkgPath)) {
+    if (existsSync6(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         if (pkg.name === "prev-cli") {
           return dir;
         }
@@ -972,7 +1156,7 @@ function findCliRoot2() {
 }
 function findNodeModules(cliRoot2) {
   const localNodeModules = path8.join(cliRoot2, "node_modules");
-  if (existsSync5(path8.join(localNodeModules, "react"))) {
+  if (existsSync6(path8.join(localNodeModules, "react"))) {
     return localNodeModules;
   }
   let dir = cliRoot2;
@@ -980,7 +1164,7 @@ function findNodeModules(cliRoot2) {
     const parent = path8.dirname(dir);
     if (parent === dir)
       break;
-    if (path8.basename(parent) === "node_modules" && existsSync5(path8.join(parent, "react"))) {
+    if (path8.basename(parent) === "node_modules" && existsSync6(path8.join(parent, "react"))) {
       return parent;
     }
     dir = parent;
@@ -1064,8 +1248,8 @@ async function createViteConfig(options) {
                 return next();
               }
               const indexPath = path8.join(srcRoot2, "theme/index.html");
-              if (existsSync5(indexPath)) {
-                server.transformIndexHtml(req.url, readFileSync4(indexPath, "utf-8")).then((html) => {
+              if (existsSync6(indexPath)) {
+                server.transformIndexHtml(req.url, readFileSync5(indexPath, "utf-8")).then((html) => {
                   res.setHeader("Content-Type", "text/html");
                   res.end(html);
                 }).catch(next);
@@ -1093,34 +1277,110 @@ async function createViteConfig(options) {
             const urlPath = req.url?.split("?")[0] || "";
             if (urlPath === "/_preview-runtime") {
               const templatePath = path8.join(srcRoot2, "preview-runtime/template.html");
-              if (existsSync5(templatePath)) {
-                const html = readFileSync4(templatePath, "utf-8");
+              if (existsSync6(templatePath)) {
+                const html = readFileSync5(templatePath, "utf-8");
                 res.setHeader("Content-Type", "text/html");
                 res.end(html);
                 return;
               }
             }
             if (urlPath.startsWith("/_preview-config/")) {
-              const previewName = decodeURIComponent(urlPath.slice("/_preview-config/".length));
+              const pathAfterConfig = decodeURIComponent(urlPath.slice("/_preview-config/".length));
               const previewsDir = path8.join(rootDir, "previews");
-              const previewDir = path8.resolve(previewsDir, previewName);
-              if (!previewDir.startsWith(previewsDir)) {
-                res.statusCode = 403;
-                res.end("Forbidden");
-                return;
-              }
-              if (existsSync5(previewDir)) {
-                try {
-                  const config2 = await buildPreviewConfig(previewDir);
-                  res.setHeader("Content-Type", "application/json");
-                  res.end(JSON.stringify(config2));
+              const multiTypeMatch = pathAfterConfig.match(/^(components|screens|flows|atlas)\/(.+)$/);
+              if (multiTypeMatch) {
+                const [, type, name] = multiTypeMatch;
+                const configPathYaml = path8.join(previewsDir, type, name, "index.yaml");
+                const configPathYml = path8.join(previewsDir, type, name, "index.yml");
+                const configPath = existsSync6(configPathYaml) ? configPathYaml : configPathYml;
+                if (!configPath.startsWith(previewsDir)) {
+                  res.statusCode = 403;
+                  res.end("Forbidden");
                   return;
-                } catch (err) {
-                  console.error("Error building preview config:", err);
-                  res.statusCode = 500;
-                  res.end(JSON.stringify({ error: String(err) }));
+                }
+                if (existsSync6(configPath)) {
+                  try {
+                    if (type === "flows") {
+                      const flow = await parseFlowDefinition(configPath);
+                      if (flow) {
+                        res.setHeader("Content-Type", "application/json");
+                        res.end(JSON.stringify(flow));
+                        return;
+                      }
+                    } else if (type === "atlas") {
+                      const atlas = await parseAtlasDefinition(configPath);
+                      if (atlas) {
+                        res.setHeader("Content-Type", "application/json");
+                        res.end(JSON.stringify(atlas));
+                        return;
+                      }
+                    } else {
+                      const previewDir = path8.join(previewsDir, type, name);
+                      const config2 = await buildPreviewConfig(previewDir);
+                      res.setHeader("Content-Type", "application/json");
+                      res.end(JSON.stringify(config2));
+                      return;
+                    }
+                    res.statusCode = 400;
+                    res.end(JSON.stringify({ error: "Invalid config format" }));
+                    return;
+                  } catch (err) {
+                    console.error("Error building preview config:", err);
+                    res.statusCode = 500;
+                    res.end(JSON.stringify({ error: String(err) }));
+                    return;
+                  }
+                }
+              } else {
+                const previewDir = path8.resolve(previewsDir, pathAfterConfig);
+                if (!previewDir.startsWith(previewsDir)) {
+                  res.statusCode = 403;
+                  res.end("Forbidden");
                   return;
                 }
+                if (existsSync6(previewDir)) {
+                  try {
+                    const config2 = await buildPreviewConfig(previewDir);
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify(config2));
+                    return;
+                  } catch (err) {
+                    console.error("Error building preview config:", err);
+                    res.statusCode = 500;
+                    res.end(JSON.stringify({ error: String(err) }));
+                    return;
+                  }
+                }
+              }
+            }
+            if (urlPath.match(/^\/_preview\/(components|screens|flows|atlas)\/[^/]+\/?$/)) {
+              const routeMatch = urlPath.match(/^\/_preview\/(\w+)\/([^/]+)\/?$/);
+              if (routeMatch) {
+                const [, type, name] = routeMatch;
+                const singularType = TYPE_SINGULAR[type] || type;
+                const shellHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Preview: ${name}</title>
+  <script type="module">
+    import { PreviewRouter } from '@prev/theme/previews'
+    import { createRoot } from 'react-dom/client'
+    import React from 'react'
+
+    createRoot(document.getElementById('root')).render(
+      React.createElement(PreviewRouter, { type: '${singularType}', name: '${name}' })
+    )
+  </script>
+</head>
+<body>
+  <div id="root"></div>
+</body>
+</html>`;
+                const transformed = await server.transformIndexHtml(req.url, shellHtml);
+                res.setHeader("Content-Type", "text/html");
+                res.end(transformed);
+                return;
               }
             }
             if (urlPath.startsWith("/_preview/")) {
@@ -1132,9 +1392,9 @@ async function createViteConfig(options) {
                 if (!htmlPath.startsWith(previewsDir)) {
                   return next();
                 }
-                if (existsSync5(htmlPath)) {
+                if (existsSync6(htmlPath)) {
                   try {
-                    let html = readFileSync4(htmlPath, "utf-8");
+                    let html = readFileSync5(htmlPath, "utf-8");
                     const previewBase = `/_preview/${previewName}/`;
                     html = html.replace(/(src|href)=["']\.\/([^"']+)["']/g, `$1="${previewBase}$2"`);
                     const transformed = await server.transformIndexHtml(req.url, html);
@@ -1261,7 +1521,7 @@ async function findAvailablePort(minPort, maxPort) {
 
 // src/vite/start.ts
 import { exec } from "child_process";
-import { existsSync as existsSync6, rmSync as rmSync2, copyFileSync } from "fs";
+import { existsSync as existsSync7, rmSync as rmSync2, copyFileSync } from "fs";
 import path9 from "path";
 function printWelcome(type) {
   console.log();
@@ -1298,11 +1558,11 @@ function clearCache(rootDir) {
   const viteCacheDir = path9.join(rootDir, ".vite");
   const nodeModulesVite = path9.join(rootDir, "node_modules", ".vite");
   let cleared = 0;
-  if (existsSync6(viteCacheDir)) {
+  if (existsSync7(viteCacheDir)) {
     rmSync2(viteCacheDir, { recursive: true });
     cleared++;
   }
-  if (existsSync6(nodeModulesVite)) {
+  if (existsSync7(nodeModulesVite)) {
     rmSync2(nodeModulesVite, { recursive: true });
     cleared++;
   }
@@ -1424,7 +1684,7 @@ async function buildSite(rootDir, options = {}) {
   const distDir = path9.join(rootDir, "dist");
   const indexPath = path9.join(distDir, "index.html");
   const notFoundPath = path9.join(distDir, "404.html");
-  if (existsSync6(indexPath)) {
+  if (existsSync7(indexPath)) {
     copyFileSync(indexPath, notFoundPath);
   }
   console.log();
@@ -1503,14 +1763,14 @@ async function cleanCache(options) {
 }
 
 // src/cli.ts
-import yaml2 from "js-yaml";
+import yaml3 from "js-yaml";
 function getVersion() {
   try {
     let dir = path11.dirname(fileURLToPath3(import.meta.url));
     for (let i = 0;i < 5; i++) {
       const pkgPath = path11.join(dir, "package.json");
-      if (existsSync7(pkgPath)) {
-        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+      if (existsSync8(pkgPath)) {
+        const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
         if (pkg.name === "prev-cli")
           return pkg.version;
       }
@@ -1637,7 +1897,7 @@ async function clearViteCache(rootDir2) {
   let cleared = 0;
   try {
     const prevCacheDir = await getCacheDir(rootDir2);
-    if (existsSync7(prevCacheDir)) {
+    if (existsSync8(prevCacheDir)) {
       rmSync3(prevCacheDir, { recursive: true });
       cleared++;
       console.log(`  ✓ Removed ${prevCacheDir}`);
@@ -1645,12 +1905,12 @@ async function clearViteCache(rootDir2) {
   } catch {}
   const viteCacheDir = path11.join(rootDir2, ".vite");
   const nodeModulesVite = path11.join(rootDir2, "node_modules", ".vite");
-  if (existsSync7(viteCacheDir)) {
+  if (existsSync8(viteCacheDir)) {
     rmSync3(viteCacheDir, { recursive: true });
     cleared++;
     console.log(`  ✓ Removed .vite/`);
   }
-  if (existsSync7(nodeModulesVite)) {
+  if (existsSync8(nodeModulesVite)) {
     rmSync3(nodeModulesVite, { recursive: true });
     cleared++;
     console.log(`  ✓ Removed node_modules/.vite/`);
@@ -1678,7 +1938,7 @@ function handleConfig(rootDir2, subcommand) {
         console.log(`  File: (none - using defaults)
 `);
       }
-      const yamlOutput = yaml2.dump(config, {
+      const yamlOutput = yaml3.dump(config, {
         indent: 2,
         lineWidth: -1,
         quotingType: '"',
@@ -1756,7 +2016,7 @@ Available subcommands: show, init, path`);
 }
 function createPreview(rootDir2, name) {
   const previewDir = path11.join(rootDir2, "previews", name);
-  if (existsSync7(previewDir)) {
+  if (existsSync8(previewDir)) {
     console.error(`Preview "${name}" already exists at: ${previewDir}`);
     process.exit(1);
   }

package/dist/vite/config-parser.d.ts

@@ -0,0 +1,13 @@
+import { type PreviewConfig, type FlowDefinition, type AtlasDefinition } from './preview-types';
+/**
+ * Parse a config.yaml or config.yml file and validate against schema
+ */
+export declare function parsePreviewConfig(filePath: string): Promise<PreviewConfig | null>;
+/**
+ * Parse a flow index.yaml file
+ */
+export declare function parseFlowDefinition(filePath: string): Promise<FlowDefinition | null>;
+/**
+ * Parse an atlas index.yaml file
+ */
+export declare function parseAtlasDefinition(filePath: string): Promise<AtlasDefinition | null>;

package/dist/vite/preview-types.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+export type PreviewType = 'component' | 'screen' | 'flow' | 'atlas';
+export declare const configSchema: z.ZodObject<{
+    tags: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>]>>;
+    category: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        stable: "stable";
+        deprecated: "deprecated";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PreviewConfig = z.infer<typeof configSchema>;
+export interface PreviewUnit {
+    type: PreviewType;
+    name: string;
+    path: string;
+    route: string;
+    config: PreviewConfig | null;
+    files: {
+        index: string;
+        states?: string[];
+        schema?: string;
+        docs?: string;
+    };
+}
+export interface FlowStep {
+    screen: string;
+    state?: string;
+    note?: string;
+    trigger?: string;
+    highlight?: string[];
+}
+export interface FlowDefinition {
+    name: string;
+    description?: string;
+    steps: FlowStep[];
+}
+export interface AtlasArea {
+    title: string;
+    description?: string;
+    parent?: string;
+    children?: string[];
+    access?: string;
+}
+export interface AtlasDefinition {
+    name: string;
+    description?: string;
+    hierarchy: {
+        root: string;
+        areas: Record<string, AtlasArea>;
+    };
+    routes?: Record<string, {
+        area: string;
+        screen: string;
+        guard?: string;
+    }>;
+    navigation?: Record<string, Array<{
+        area?: string;
+        icon?: string;
+        action?: string;
+    }>>;
+    relationships?: Array<{
+        from: string;
+        to: string;
+        type: string;
+    }>;
+}

package/dist/vite/previews.d.ts

@@ -1,4 +1,5 @@
 import type { PreviewFile, PreviewConfig } from '../preview-runtime/types';
+import type { PreviewUnit } from './preview-types';
 export interface Preview {
     name: string;
     route: string;
@@ -21,3 +22,8 @@ export declare function detectEntry(files: PreviewFile[]): string;
  * Build a PreviewConfig for WASM runtime
  */
 export declare function buildPreviewConfig(previewDir: string): Promise<PreviewConfig>;
+/**
+ * Scan previews with multi-type folder structure support
+ * Supports: components/, screens/, flows/, atlas/
+ */
+export declare function scanPreviewUnits(rootDir: string): Promise<PreviewUnit[]>;