@mercurjs/dashboard-sdk 2.3.8-canary.2 → 2.3.8-canary.4

package/dist/vite.cjs

@@ -36,8 +36,8 @@ __export(vite_exports, {
 module.exports = __toCommonJS(vite_exports);
 
 // src/plugin.ts
-var import_path8 = __toESM(require("path"), 1);
-var import_fs7 = __toESM(require("fs"), 1);
+var import_path5 = __toESM(require("path"), 1);
+var import_fs6 = __toESM(require("fs"), 1);
 var import_module = require("module");
 
 // src/utils.ts
@@ -64,6 +64,8 @@ var I18N_VIRTUAL_MODULE = "virtual:mercur/i18n";
 var WIDGETS_VIRTUAL_MODULE = "virtual:mercur/widgets";
 var NAVIGATION_VIRTUAL_MODULE = "virtual:mercur/navigation";
 var CUSTOM_FIELDS_VIRTUAL_MODULE = "virtual:mercur/custom-fields";
+var LAYOUTS_VIRTUAL_MODULE = "virtual:mercur/layouts";
+var PREFERENCES_VIRTUAL_MODULE = "virtual:mercur/preferences";
 var RESOLVED_CONFIG_MODULE = "\0" + CONFIG_VIRTUAL_MODULE;
 var RESOLVED_ROUTES_MODULE = "\0" + ROUTES_VIRTUAL_MODULE;
 var RESOLVED_MENU_ITEMS_MODULE = "\0" + MENU_ITEMS_VIRTUAL_MODULE;
@@ -71,6 +73,8 @@ var RESOLVED_I18N_MODULE = "\0" + I18N_VIRTUAL_MODULE;
 var RESOLVED_WIDGETS_MODULE = "\0" + WIDGETS_VIRTUAL_MODULE;
 var RESOLVED_NAVIGATION_MODULE = "\0" + NAVIGATION_VIRTUAL_MODULE;
 var RESOLVED_CUSTOM_FIELDS_MODULE = "\0" + CUSTOM_FIELDS_VIRTUAL_MODULE;
+var RESOLVED_LAYOUTS_MODULE = "\0" + LAYOUTS_VIRTUAL_MODULE;
+var RESOLVED_PREFERENCES_MODULE = "\0" + PREFERENCES_VIRTUAL_MODULE;
 var VIRTUAL_MODULES = [
   CONFIG_VIRTUAL_MODULE,
   ROUTES_VIRTUAL_MODULE,
@@ -78,8 +82,12 @@ var VIRTUAL_MODULES = [
   I18N_VIRTUAL_MODULE,
   WIDGETS_VIRTUAL_MODULE,
   NAVIGATION_VIRTUAL_MODULE,
-  CUSTOM_FIELDS_VIRTUAL_MODULE
+  CUSTOM_FIELDS_VIRTUAL_MODULE,
+  LAYOUTS_VIRTUAL_MODULE,
+  PREFERENCES_VIRTUAL_MODULE
 ];
+var LAYOUT_PREFERENCES_FILE = "_layouts";
+var NAVIGATION_FILE = "_navigation";
 
 // src/utils.ts
 function normalizePath(filePath) {
@@ -118,9 +126,9 @@ function resolveExports(moduleExports) {
   }
   return moduleExports;
 }
-async function getFileExports(path10) {
+async function getFileExports(path6) {
   const { unregister } = await safeRegister();
-  const module2 = require(path10);
+  const module2 = require(path6);
   unregister();
   return resolveExports(module2);
 }
@@ -146,13 +154,13 @@ function hasDefaultExport(ast) {
     ExportDefaultDeclaration() {
       found = true;
     },
-    AssignmentExpression(path10) {
-      if (path10.node.left.type === "MemberExpression" && path10.node.left.object.type === "Identifier" && path10.node.left.object.name === "exports" && path10.node.left.property.type === "Identifier" && path10.node.left.property.name === "default") {
+    AssignmentExpression(path6) {
+      if (path6.node.left.type === "MemberExpression" && path6.node.left.object.type === "Identifier" && path6.node.left.object.name === "exports" && path6.node.left.property.type === "Identifier" && path6.node.left.property.name === "default") {
         found = true;
       }
     },
-    ExportNamedDeclaration(path10) {
-      const specifiers = path10.node.specifiers;
+    ExportNamedDeclaration(path6) {
+      const specifiers = path6.node.specifiers;
       if (specifiers?.some(
         (s) => s.type === "ExportSpecifier" && s.exported.type === "Identifier" && s.exported.name === "default"
       )) {
@@ -164,252 +172,16 @@ function hasDefaultExport(ast) {
 }
 
 // src/routes.ts
-var import_fs2 = __toESM(require("fs"), 1);
-var import_path2 = __toESM(require("path"), 1);
-function getRoute(file, routesDir) {
-  const importPath = normalizePath(file);
-  const normalizedRoutesDir = normalizePath(routesDir);
-  return importPath.replace(normalizedRoutesDir, "").replace(/\[\[\*\]\]/g, "*?").replace(/\[\*\]/g, "*").replace(/\(([^[\])]+)\)/g, "$1?").replace(/\[\[([^\]]+)\]\]/g, ":$1?").replace(/\[([^\]]+)\]/g, ":$1").replace(
-    new RegExp(
-      `/page\\.(${VALID_FILE_EXTENSIONS.map((ext) => ext.slice(1)).join("|")})$`
-    ),
-    ""
-  ) || "/";
-}
-function crawlRoutes(dir, pattern = "page") {
-  const files = [];
-  if (!import_fs2.default.existsSync(dir)) {
-    return files;
-  }
-  const entries = import_fs2.default.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = import_path2.default.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...crawlRoutes(fullPath, pattern));
-    } else if (entry.isFile()) {
-      const ext = import_path2.default.extname(entry.name);
-      const baseName = import_path2.default.basename(entry.name, ext);
-      if (baseName === pattern && VALID_FILE_EXTENSIONS.includes(ext)) {
-        files.push(fullPath);
-      }
-    }
-  }
-  return files;
-}
-function hasConfigPublic(ast) {
-  let found = false;
-  traverse(ast, {
-    ExportNamedDeclaration(path10) {
-      const declaration = path10.node.declaration;
-      if (!(0, import_types.isVariableDeclaration)(declaration)) return;
-      for (const decl of declaration.declarations) {
-        if ((0, import_types.isVariableDeclarator)(decl) && (0, import_types.isIdentifier)(decl.id, { name: "config" }) && decl.init?.type === "ObjectExpression") {
-          const publicProp = decl.init.properties.find(
-            (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "public" }) && (0, import_types.isBooleanLiteral)(prop.value, { value: true })
-          );
-          if (publicProp) {
-            found = true;
-          }
-        }
-      }
-    }
-  });
-  return found;
-}
-function getNamedExports(ast) {
-  let hasHandle = false;
-  let hasLoader = false;
-  traverse(ast, {
-    ExportNamedDeclaration(path10) {
-      const declaration = path10.node.declaration;
-      if (declaration?.type === "VariableDeclaration") {
-        declaration.declarations.forEach((decl) => {
-          if (decl.id.type === "Identifier" && decl.id.name === "handle") {
-            hasHandle = true;
-          }
-          if (decl.id.type === "Identifier" && decl.id.name === "loader") {
-            hasLoader = true;
-          }
-        });
-      }
-      if (declaration?.type === "FunctionDeclaration" && declaration.id?.name === "loader") {
-        hasLoader = true;
-      }
-      if (declaration?.type === "FunctionDeclaration" && declaration.id?.name === "handle") {
-        hasHandle = true;
-      }
-    }
-  });
-  return { hasHandle, hasLoader };
-}
-function generateRouteComponentName(index) {
-  return `RouteComponent${index}`;
-}
-function generateHandleName(index) {
-  return `RouteHandle${index}`;
-}
-function generateLoaderName(index) {
-  return `RouteLoader${index}`;
-}
-function generateImports(file, index, hasHandle, hasLoader) {
-  const imports = [];
-  const componentName = generateRouteComponentName(index);
-  const importPath = normalizePath(file);
-  if (!hasHandle && !hasLoader) {
-    imports.push(`import ${componentName} from "${importPath}"`);
-  } else {
-    const namedImports = [
-      hasHandle && `handle as ${generateHandleName(index)}`,
-      hasLoader && `loader as ${generateLoaderName(index)}`
-    ].filter(Boolean).join(", ");
-    imports.push(`import ${componentName}, { ${namedImports} } from "${importPath}"`);
-  }
-  return imports;
-}
-function generateRouteObject(routePath, index, hasHandle, hasLoader, isPublic) {
-  return {
-    Component: generateRouteComponentName(index),
-    path: routePath,
-    handle: hasHandle ? generateHandleName(index) : void 0,
-    loader: hasLoader ? generateLoaderName(index) : void 0,
-    isPublic
-  };
-}
-function formatRoute(route, indent = "    ") {
-  let result = `${indent}{
-`;
-  result += `${indent}    Component: ${route.Component},
-`;
-  result += `${indent}    path: "${route.path}"`;
-  if (route.handle) {
-    result += `,
-${indent}    handle: ${route.handle}`;
-  }
-  if (route.loader) {
-    result += `,
-${indent}    loader: ${route.loader}`;
-  }
-  if (route.isPublic) {
-    result += `,
-${indent}    isPublic: true`;
-  }
-  if (route.children?.length) {
-    result += `,
-${indent}    children: [
-`;
-    result += route.children.map((child) => formatRoute(child, indent + "        ")).join(",\n");
-    result += `
-${indent}    ]`;
-  }
-  result += `
-${indent}}`;
-  return result;
-}
-function parseFile(file, routesDir, index) {
-  try {
-    const code = import_fs2.default.readFileSync(file, "utf-8");
-    const ast = (0, import_parser.parse)(code, getParserOptions(file));
-    if (!hasDefaultExport(ast)) {
-      return null;
-    }
-    const { hasHandle, hasLoader } = getNamedExports(ast);
-    const isPublic = hasConfigPublic(ast);
-    const routePath = getRoute(file, routesDir);
-    const imports = generateImports(file, index, hasHandle, hasLoader);
-    const route = generateRouteObject(routePath, index, hasHandle, hasLoader, isPublic);
-    return {
-      imports,
-      route
-    };
-  } catch {
-    return null;
-  }
-}
-function buildRouteTree(results) {
-  const routeMap = /* @__PURE__ */ new Map();
-  const sortedResults = [...results].sort(
-    (a, b) => a.route.path.split("/").length - b.route.path.split("/").length
-  );
-  for (const result of sortedResults) {
-    const routePath = result.route.path;
-    const isParallel = routePath.includes("/@");
-    if (isParallel) {
-      const parentPath = routePath.split("/@")[0];
-      const parent = routeMap.get(parentPath);
-      if (parent) {
-        parent.route.children = parent.route.children ?? [];
-        parent.route.children.push({
-          ...result.route,
-          path: result.route.path.replace("/@", "/")
-        });
-        parent.imports.push(...result.imports);
-      } else {
-        routeMap.set(routePath, result);
-      }
-    } else {
-      routeMap.set(routePath, result);
-    }
-  }
-  return Array.from(routeMap.values());
-}
-function generateRoutes({ srcDir, pluginExtensions }) {
-  const routesDir = import_path2.default.join(srcDir, "routes");
-  let index = 0;
-  const results = [];
-  for (const file of crawlRoutes(routesDir)) {
-    const result = parseFile(file, routesDir, index);
-    if (result) {
-      results.push(result);
-      index++;
-    }
-  }
-  const pluginDeclarations = pluginExtensions.map(
-    (ext, i) => `import __plugin${i} from "${normalizePath(ext)}"`
-  );
-  const pluginSpreads = pluginExtensions.map(
-    (_, i) => `    ...(__plugin${i}.routeModule?.routes ?? [])`
-  );
-  const routeTree = buildRouteTree(results);
-  const appImports = routeTree.flatMap((r) => r.imports);
-  const appRoutes = routeTree.map((r) => formatRoute(r.route));
-  const allImports = [...appImports];
-  const allRoutes = [...appRoutes, ...pluginSpreads];
-  if (allImports.length === 0 && pluginDeclarations.length === 0 && allRoutes.length === 0) {
-    return `export const customRoutes = []`;
-  }
-  return `${allImports.join("\n")}
-
-${pluginDeclarations.join("\n")}
+var import_fs5 = __toESM(require("fs"), 1);
+var import_path4 = __toESM(require("path"), 1);
 
-export const customRoutes = [
-${allRoutes.join(",\n")}
-]`;
-}
+// src/layers.ts
+var import_fs4 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
 
 // src/menu-items.ts
-var import_fs3 = __toESM(require("fs"), 1);
-var import_path3 = __toESM(require("path"), 1);
-function crawlRoutes2(dir, pattern = "page") {
-  const files = [];
-  if (!import_fs3.default.existsSync(dir)) {
-    return files;
-  }
-  const entries = import_fs3.default.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = import_path3.default.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...crawlRoutes2(fullPath, pattern));
-    } else if (entry.isFile()) {
-      const ext = import_path3.default.extname(entry.name);
-      const baseName = import_path3.default.basename(entry.name, ext);
-      if (baseName === pattern && VALID_FILE_EXTENSIONS.includes(ext)) {
-        files.push(fullPath);
-      }
-    }
-  }
-  return files;
-}
-function getRoute2(file, routesDir) {
+var import_fs2 = __toESM(require("fs"), 1);
+function getRoute(file, routesDir) {
   const importPath = normalizePath(file);
   const normalizedRoutesDir = normalizePath(routesDir);
   return importPath.replace(normalizedRoutesDir, "").replace(/\[\[\*\]\]/g, "*?").replace(/\[\*\]/g, "*").replace(/\(([^[\])]+)\)/g, "$1?").replace(/\[\[([^\]]+)\]\]/g, ":$1?").replace(/\[([^\]]+)\]/g, ":$1").replace(
@@ -419,9 +191,9 @@ function getRoute2(file, routesDir) {
     ""
   ) || "/";
 }
-function getConfigObjectProperties(path10) {
-  if ((0, import_types.isVariableDeclarator)(path10.node)) {
-    const decl = (0, import_types.isIdentifier)(path10.node.id, { name: "config" }) ? path10.node : null;
+function getConfigObjectProperties(path6) {
+  if ((0, import_types.isVariableDeclarator)(path6.node)) {
+    const decl = (0, import_types.isIdentifier)(path6.node.id, { name: "config" }) ? path6.node : null;
     if (!decl) return null;
     if ((0, import_types.isCallExpression)(decl.init) && decl.init.arguments.length > 0 && (0, import_types.isObjectExpression)(decl.init.arguments[0])) {
       return decl.init.arguments[0].properties;
@@ -431,7 +203,7 @@ function getConfigObjectProperties(path10) {
     }
     return null;
   }
-  const declaration = path10.node.declaration;
+  const declaration = path6.node.declaration;
   if ((0, import_types.isVariableDeclaration)(declaration)) {
     const configDecl = declaration.declarations.find(
       (d) => (0, import_types.isVariableDeclarator)(d) && (0, import_types.isIdentifier)(d.id, { name: "config" })
@@ -507,21 +279,21 @@ function processConfigProperties(properties) {
 }
 function getRouteConfig(file) {
   try {
-    const code = import_fs3.default.readFileSync(file, "utf-8");
+    const code = import_fs2.default.readFileSync(file, "utf-8");
     const ast = (0, import_parser.parse)(code, getParserOptions(file));
     let config = null;
     let configFound = false;
     traverse(ast, {
-      VariableDeclarator(path10) {
+      VariableDeclarator(path6) {
         if (configFound) return;
-        const properties = getConfigObjectProperties(path10);
+        const properties = getConfigObjectProperties(path6);
         if (!properties) return;
         config = processConfigProperties(properties);
         if (config) configFound = true;
       },
-      ExportNamedDeclaration(path10) {
+      ExportNamedDeclaration(path6) {
         if (configFound) return;
-        const properties = getConfigObjectProperties(path10);
+        const properties = getConfigObjectProperties(path6);
         if (!properties) return;
         config = processConfigProperties(properties);
         if (config) configFound = true;
@@ -544,7 +316,7 @@ function generateMenuItem(config, file, routesDir, index) {
   return {
     label: `${configName}.label`,
     icon: config.icon ? `${configName}.icon` : void 0,
-    path: getRoute2(file, routesDir),
+    path: getRoute(file, routesDir),
     rank: config.rank,
     nested: config.nested,
     group: config.group,
@@ -574,75 +346,485 @@ function parseMenuItemFile(file, routesDir, index) {
   if (!config) {
     return null;
   }
-  return {
-    import: generateImport(file, index),
-    menuItem: generateMenuItem(config, file, routesDir, index)
-  };
+  return {
+    import: generateImport(file, index),
+    menuItem: generateMenuItem(config, file, routesDir, index)
+  };
+}
+function generateMenuItems(config) {
+  const { header, names } = emitLayers(config);
+  return `${header}
+
+const byPath = new Map()
+for (const item of [
+${spreadLayers(names, "menuItemModule", "menuItems")}
+]) {
+    byPath.set(item.path, item)
+}
+
+export default { menuItems: [...byPath.values()] }`;
+}
+
+// src/widgets.ts
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+function readNumber(value) {
+  if ((0, import_types.isNumericLiteral)(value)) return value.value;
+  if ((0, import_types.isUnaryExpression)(value) && value.operator === "-" && (0, import_types.isNumericLiteral)(value.argument)) {
+    return -value.argument.value;
+  }
+  return void 0;
+}
+function extractStrings(value, zones) {
+  if ((0, import_types.isStringLiteral)(value)) {
+    zones.push(value.value);
+  } else if ((0, import_types.isArrayExpression)(value)) {
+    for (const el of value.elements) {
+      if ((0, import_types.isStringLiteral)(el)) zones.push(el.value);
+    }
+  }
+}
+function readWidgetConfig(properties) {
+  const zones = [];
+  const permissions = [];
+  let id;
+  let label;
+  let section;
+  let order;
+  let replace;
+  for (const prop of properties) {
+    if (!(0, import_types.isObjectProperty)(prop)) continue;
+    if ((0, import_types.isIdentifier)(prop.key, { name: "zone" })) {
+      extractStrings(prop.value, zones);
+    }
+    if ((0, import_types.isIdentifier)(prop.key, { name: "permission" })) {
+      extractStrings(prop.value, permissions);
+    }
+    if ((0, import_types.isIdentifier)(prop.key, { name: "id" }) && (0, import_types.isStringLiteral)(prop.value)) {
+      id = prop.value.value;
+    }
+    if ((0, import_types.isIdentifier)(prop.key, { name: "label" }) && (0, import_types.isStringLiteral)(prop.value)) {
+      label = prop.value.value;
+    }
+    if ((0, import_types.isIdentifier)(prop.key, { name: "section" }) && (0, import_types.isStringLiteral)(prop.value)) {
+      section = prop.value.value;
+    }
+    if ((0, import_types.isIdentifier)(prop.key, { name: "order" })) {
+      order = readNumber(prop.value);
+    }
+    if ((0, import_types.isIdentifier)(prop.key, { name: "replace" }) && (0, import_types.isStringLiteral)(prop.value)) {
+      replace = prop.value.value;
+    }
+  }
+  if (zones.length === 0) return null;
+  return { zones, id, label, permissions, section, order, replace };
+}
+function getConfigProperties(node) {
+  if ((0, import_types.isCallExpression)(node) && node.arguments.length > 0 && (0, import_types.isObjectExpression)(node.arguments[0])) {
+    return node.arguments[0].properties;
+  }
+  if ((0, import_types.isObjectExpression)(node)) {
+    return node.properties;
+  }
+  return null;
+}
+function getWidgetConfig(file) {
+  try {
+    const code = import_fs3.default.readFileSync(file, "utf-8");
+    const ast = (0, import_parser.parse)(code, getParserOptions(file));
+    if (!hasDefaultExport(ast)) return null;
+    let info = null;
+    const visit = (declaration) => {
+      if (info) return;
+      if (!(0, import_types.isVariableDeclaration)(declaration)) return;
+      for (const decl of declaration.declarations) {
+        if ((0, import_types.isVariableDeclarator)(decl) && (0, import_types.isIdentifier)(decl.id, { name: "config" })) {
+          const props = getConfigProperties(decl.init);
+          if (props) info = readWidgetConfig(props);
+        }
+      }
+    };
+    traverse(ast, {
+      ExportNamedDeclaration(p) {
+        visit(p.node.declaration);
+      },
+      VariableDeclaration(p) {
+        visit(p.node);
+      }
+    });
+    return info;
+  } catch {
+    return null;
+  }
+}
+function hashPath(relative) {
+  let hash = 0;
+  for (let i = 0; i < relative.length; i++) {
+    hash = (hash << 5) - hash + relative.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36).slice(0, 6);
+}
+function widgetId(info, file, widgetsDir) {
+  if (info.id) return info.id;
+  const relative = normalizePath(import_path2.default.relative(widgetsDir, file));
+  return `Widget-${hashPath(relative)}`;
+}
+function parseWidgetFile(file, widgetsDir, index) {
+  const info = getWidgetConfig(file);
+  if (!info) return null;
+  const name = `Widget${index}`;
+  const importPath = normalizePath(file);
+  const zonesLiteral = JSON.stringify(info.zones);
+  const id = widgetId(info, file, widgetsDir);
+  return {
+    import: `import ${name} from "${importPath}"`,
+    entry: `    { Component: ${name}, zone: ${zonesLiteral}, widgetId: ${JSON.stringify(
+      id
+    )}${info.label ? `, label: ${JSON.stringify(info.label)}` : ""}${info.permissions.length ? `, permission: ${JSON.stringify(info.permissions)}` : ""}${info.section ? `, section: ${JSON.stringify(info.section)}` : ""}${info.order !== void 0 ? `, order: ${info.order}` : ""}${info.replace ? `, replace: ${JSON.stringify(info.replace)}` : ""} }`
+  };
+}
+function collectWidgets(srcDir, startIndex = 0) {
+  const widgetsDir = import_path2.default.join(srcDir, "widgets");
+  let index = startIndex;
+  const results = [];
+  for (const file of crawlModuleFiles(widgetsDir)) {
+    const result = parseWidgetFile(file, widgetsDir, index);
+    if (result) {
+      results.push(result);
+      index++;
+    }
+  }
+  return {
+    imports: results.map((r) => r.import),
+    entries: results.map((r) => r.entry)
+  };
+}
+function generateWidgets(config) {
+  const { header, names } = emitLayers(config);
+  return `${header}
+
+const byId = new Map()
+for (const widget of [
+${spreadLayers(names, "widgetModule", "widgets")}
+]) {
+    byId.set(widget.widgetId, widget)
+}
+
+export default { widgets: [...byId.values()] }`;
+}
+
+// src/layers.ts
+function layerSources({
+  pluginExtensions,
+  projectDir,
+  srcDir
+}) {
+  return [
+    ...pluginExtensions.map((entry) => ({ entry })),
+    ...projectDir ? [{ srcDir: projectDir }] : [],
+    { srcDir }
+  ];
+}
+function findFile(dir, stem) {
+  for (const ext of VALID_FILE_EXTENSIONS) {
+    const file = import_path3.default.join(dir, `${stem}${ext}`);
+    if (import_fs4.default.existsSync(file)) return file;
+  }
+  return null;
+}
+function collectLayer(srcDir, layer, startIndex = 0) {
+  const name = `__layer${layer}`;
+  const routesDir = import_path3.default.join(srcDir, "routes");
+  let index = startIndex;
+  const routeResults = [];
+  const menuItemResults = [];
+  for (const file of crawlRoutes(routesDir)) {
+    const route = parseFile(file, routesDir, index);
+    if (route) routeResults.push(route);
+    const menuItem = parseMenuItemFile(file, routesDir, index);
+    if (menuItem) menuItemResults.push(menuItem);
+    index++;
+  }
+  const routeTree = buildRouteTree(routeResults);
+  const routeImports = routeTree.flatMap((r) => r.imports);
+  const routes = routeTree.map((r) => formatRoute(r.route));
+  const menuItemImports = menuItemResults.map((r) => r.import);
+  const menuItems = menuItemResults.map((r) => formatMenuItem(r.menuItem));
+  const widgets = collectWidgets(srcDir, index);
+  index += widgets.entries.length;
+  const cfFiles = crawlModuleFiles(import_path3.default.join(srcDir, "custom-fields"));
+  const cfImports = cfFiles.map(
+    (file, i) => `import __cf${layer}_${i} from "${normalizePath(file)}"`
+  );
+  const cfRefs = cfFiles.map((_, i) => `        __cf${layer}_${i}`);
+  const layoutFiles = crawlModuleFiles(import_path3.default.join(srcDir, "layouts"));
+  const layoutImports = layoutFiles.map(
+    (file, i) => `import __layout${layer}_${i} from "${normalizePath(file)}"`
+  );
+  const layoutRefs = layoutFiles.map((_, i) => `        __layout${layer}_${i}`);
+  const i18nFile = findFile(import_path3.default.join(srcDir, "i18n"), "index");
+  const i18nName = `__i18n${layer}`;
+  const navigationFile = findFile(srcDir, NAVIGATION_FILE);
+  const navigationName = `__navigation${layer}`;
+  const preferencesFile = findFile(srcDir, LAYOUT_PREFERENCES_FILE);
+  const preferencesName = `__preferences${layer}`;
+  const imports = [
+    ...routeImports,
+    ...menuItemImports,
+    ...widgets.imports,
+    ...cfImports,
+    ...layoutImports,
+    ...i18nFile ? [`import ${i18nName} from "${normalizePath(i18nFile)}"`] : [],
+    ...navigationFile ? [`import ${navigationName} from "${normalizePath(navigationFile)}"`] : [],
+    ...preferencesFile ? [`import ${preferencesName} from "${normalizePath(preferencesFile)}"`] : []
+  ];
+  const declaration = `const ${name} = {
+    routeModule: { routes: [
+${routes.join(",\n")}
+    ] },
+    menuItemModule: { menuItems: [
+${menuItems.join(",\n")}
+    ] },
+    widgetModule: { widgets: [
+${widgets.entries.join(",\n")}
+    ] },
+    customFieldsModule: { configs: [
+${cfRefs.join(",\n")}
+    ] },
+    layoutModule: { layouts: [
+${layoutRefs.join(",\n")}
+    ] },
+    i18nModule: ${i18nFile ? i18nName : "{}"},
+    navigationModule: ${navigationFile ? navigationName : "{}"},
+    preferenceModule: ${preferencesFile ? preferencesName : "{}"},
+}`;
+  return { imports, declaration, name, nextIndex: index };
+}
+function emitLayers(config) {
+  const lines = [];
+  const declarations = [];
+  const names = [];
+  let index = 0;
+  layerSources(config).forEach((source, layer) => {
+    if ("entry" in source) {
+      const name = `__layer${layer}`;
+      lines.push(`import ${name} from "${normalizePath(source.entry)}"`);
+      names.push(name);
+      return;
+    }
+    const collected = collectLayer(source.srcDir, layer, index);
+    index = collected.nextIndex;
+    lines.push(...collected.imports);
+    declarations.push(collected.declaration);
+    names.push(collected.name);
+  });
+  return { header: [...lines, ...declarations].join("\n"), names };
+}
+function spreadLayers(names, key, list) {
+  return names.map((name) => `    ...(${name}.${key}?.${list} ?? [])`).join(",\n");
+}
+
+// src/routes.ts
+function getRoute2(file, routesDir) {
+  const importPath = normalizePath(file);
+  const normalizedRoutesDir = normalizePath(routesDir);
+  return importPath.replace(normalizedRoutesDir, "").replace(/\[\[\*\]\]/g, "*?").replace(/\[\*\]/g, "*").replace(/\(([^[\])]+)\)/g, "$1?").replace(/\[\[([^\]]+)\]\]/g, ":$1?").replace(/\[([^\]]+)\]/g, ":$1").replace(
+    new RegExp(
+      `/page\\.(${VALID_FILE_EXTENSIONS.map((ext) => ext.slice(1)).join("|")})$`
+    ),
+    ""
+  ) || "/";
+}
+function crawlRoutes(dir, pattern = "page") {
+  const files = [];
+  if (!import_fs5.default.existsSync(dir)) {
+    return files;
+  }
+  const entries = import_fs5.default.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = import_path4.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...crawlRoutes(fullPath, pattern));
+    } else if (entry.isFile()) {
+      const ext = import_path4.default.extname(entry.name);
+      const baseName = import_path4.default.basename(entry.name, ext);
+      if (baseName === pattern && VALID_FILE_EXTENSIONS.includes(ext)) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+function hasConfigPublic(ast) {
+  let found = false;
+  traverse(ast, {
+    ExportNamedDeclaration(path6) {
+      const declaration = path6.node.declaration;
+      if (!(0, import_types.isVariableDeclaration)(declaration)) return;
+      for (const decl of declaration.declarations) {
+        if ((0, import_types.isVariableDeclarator)(decl) && (0, import_types.isIdentifier)(decl.id, { name: "config" }) && decl.init?.type === "ObjectExpression") {
+          const publicProp = decl.init.properties.find(
+            (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "public" }) && (0, import_types.isBooleanLiteral)(prop.value, { value: true })
+          );
+          if (publicProp) {
+            found = true;
+          }
+        }
+      }
+    }
+  });
+  return found;
+}
+function getNamedExports(ast) {
+  let hasHandle = false;
+  let hasLoader = false;
+  traverse(ast, {
+    ExportNamedDeclaration(path6) {
+      const declaration = path6.node.declaration;
+      if (declaration?.type === "VariableDeclaration") {
+        declaration.declarations.forEach((decl) => {
+          if (decl.id.type === "Identifier" && decl.id.name === "handle") {
+            hasHandle = true;
+          }
+          if (decl.id.type === "Identifier" && decl.id.name === "loader") {
+            hasLoader = true;
+          }
+        });
+      }
+      if (declaration?.type === "FunctionDeclaration" && declaration.id?.name === "loader") {
+        hasLoader = true;
+      }
+      if (declaration?.type === "FunctionDeclaration" && declaration.id?.name === "handle") {
+        hasHandle = true;
+      }
+    }
+  });
+  return { hasHandle, hasLoader };
+}
+function generateRouteComponentName(index) {
+  return `RouteComponent${index}`;
+}
+function generateHandleName(index) {
+  return `RouteHandle${index}`;
+}
+function generateLoaderName(index) {
+  return `RouteLoader${index}`;
+}
+function generateImports(file, index, hasHandle, hasLoader) {
+  const imports = [];
+  const componentName = generateRouteComponentName(index);
+  const importPath = normalizePath(file);
+  if (!hasHandle && !hasLoader) {
+    imports.push(`import ${componentName} from "${importPath}"`);
+  } else {
+    const namedImports = [
+      hasHandle && `handle as ${generateHandleName(index)}`,
+      hasLoader && `loader as ${generateLoaderName(index)}`
+    ].filter(Boolean).join(", ");
+    imports.push(`import ${componentName}, { ${namedImports} } from "${importPath}"`);
+  }
+  return imports;
+}
+function generateRouteObject(routePath, index, hasHandle, hasLoader, isPublic) {
+  return {
+    Component: generateRouteComponentName(index),
+    path: routePath,
+    handle: hasHandle ? generateHandleName(index) : void 0,
+    loader: hasLoader ? generateLoaderName(index) : void 0,
+    isPublic
+  };
+}
+function formatRoute(route, indent = "    ") {
+  let result = `${indent}{
+`;
+  result += `${indent}    Component: ${route.Component},
+`;
+  result += `${indent}    path: "${route.path}"`;
+  if (route.handle) {
+    result += `,
+${indent}    handle: ${route.handle}`;
+  }
+  if (route.loader) {
+    result += `,
+${indent}    loader: ${route.loader}`;
+  }
+  if (route.isPublic) {
+    result += `,
+${indent}    isPublic: true`;
+  }
+  if (route.children?.length) {
+    result += `,
+${indent}    children: [
+`;
+    result += route.children.map((child) => formatRoute(child, indent + "        ")).join(",\n");
+    result += `
+${indent}    ]`;
+  }
+  result += `
+${indent}}`;
+  return result;
 }
-function generateMenuItems({ srcDir, pluginExtensions }) {
-  const routesDir = import_path3.default.join(srcDir, "routes");
-  let index = 0;
-  const results = [];
-  for (const file of crawlRoutes2(routesDir)) {
-    const result = parseMenuItemFile(file, routesDir, index);
-    if (result) {
-      results.push(result);
-      index++;
+function parseFile(file, routesDir, index) {
+  try {
+    const code = import_fs5.default.readFileSync(file, "utf-8");
+    const ast = (0, import_parser.parse)(code, getParserOptions(file));
+    if (!hasDefaultExport(ast)) {
+      return null;
     }
+    const { hasHandle, hasLoader } = getNamedExports(ast);
+    const isPublic = hasConfigPublic(ast);
+    const routePath = getRoute2(file, routesDir);
+    const imports = generateImports(file, index, hasHandle, hasLoader);
+    const route = generateRouteObject(routePath, index, hasHandle, hasLoader, isPublic);
+    return {
+      imports,
+      route
+    };
+  } catch {
+    return null;
   }
-  const pluginDeclarations = pluginExtensions.map(
-    (ext, i) => `import __plugin${i} from "${normalizePath(ext)}"`
-  );
-  const pluginSpreads = pluginExtensions.map(
-    (_, i) => `        ...(__plugin${i}.menuItemModule?.menuItems ?? [])`
+}
+function buildRouteTree(results) {
+  const routeMap = /* @__PURE__ */ new Map();
+  const sortedResults = [...results].sort(
+    (a, b) => a.route.path.split("/").length - b.route.path.split("/").length
   );
-  const appImports = results.map((r) => r.import);
-  const appMenuItems = results.map((r) => formatMenuItem(r.menuItem));
-  const allImports = [...appImports];
-  const allMenuItems = [...appMenuItems, ...pluginSpreads];
-  if (allImports.length === 0 && pluginDeclarations.length === 0 && allMenuItems.length === 0) {
-    return `export default { menuItems: [] }`;
+  for (const result of sortedResults) {
+    const routePath = result.route.path;
+    const isParallel = routePath.includes("/@");
+    if (isParallel) {
+      const parentPath = routePath.split("/@")[0];
+      const parent = routeMap.get(parentPath);
+      if (parent) {
+        parent.route.children = parent.route.children ?? [];
+        parent.route.children.push({
+          ...result.route,
+          path: result.route.path.replace("/@", "/")
+        });
+        parent.imports.push(...result.imports);
+      } else {
+        routeMap.set(routePath, result);
+      }
+    } else {
+      routeMap.set(routePath, result);
+    }
   }
-  return `${allImports.join("\n")}
-
-${pluginDeclarations.join("\n")}
+  return Array.from(routeMap.values());
+}
+function generateRoutes(config) {
+  const { header, names } = emitLayers(config);
+  return `${header}
 
-export default {
-    menuItems: [
-${allMenuItems.join(",\n")}
-    ]
-}`;
+export const customRoutes = [
+${spreadLayers(names, "routeModule", "routes")}
+]`;
 }
 
 // src/i18n.ts
-var import_fs4 = __toESM(require("fs"), 1);
-var import_path4 = __toESM(require("path"), 1);
-function findI18nIndex(srcDir) {
-  const i18nDir = import_path4.default.join(srcDir, "i18n");
-  if (!import_fs4.default.existsSync(i18nDir)) {
-    return null;
-  }
-  for (const ext of VALID_FILE_EXTENSIONS) {
-    const filePath = import_path4.default.join(i18nDir, `index${ext}`);
-    if (import_fs4.default.existsSync(filePath)) {
-      return filePath;
-    }
-  }
-  return null;
-}
-function generateI18n({ srcDir, pluginExtensions }) {
-  const indexFile = findI18nIndex(srcDir);
-  const imports = [
-    ...indexFile ? [`import appI18n from "${normalizePath(indexFile)}"`] : [],
-    ...pluginExtensions.map(
-      (ext, i) => `import __plugin${i} from "${normalizePath(ext)}"`
-    )
-  ];
-  const sources = [
-    ...pluginExtensions.map((_, i) => `(__plugin${i}.i18nModule ?? {})`),
-    ...indexFile ? ["appI18n"] : []
-  ];
-  return `${imports.join("\n")}
+function generateI18n(config) {
+  const { header, names } = emitLayers(config);
+  return `${header}
 
 function deepMerge(target, source) {
   const result = { ...target }
@@ -668,205 +850,62 @@ function mergeResources(target, source) {
   return result
 }
 
-export default [${sources.join(", ")}].reduce(mergeResources, {})
+export default [${names.map((name) => `(${name}.i18nModule ?? {})`).join(", ")}].reduce(mergeResources, {})
 `;
 }
 
-// src/widgets.ts
-var import_fs5 = __toESM(require("fs"), 1);
-var import_path5 = __toESM(require("path"), 1);
-function extractStrings(value, zones) {
-  if ((0, import_types.isStringLiteral)(value)) {
-    zones.push(value.value);
-  } else if ((0, import_types.isArrayExpression)(value)) {
-    for (const el of value.elements) {
-      if ((0, import_types.isStringLiteral)(el)) zones.push(el.value);
-    }
-  }
-}
-function readWidgetConfig(properties) {
-  const zones = [];
-  const permissions = [];
-  let id;
-  let label;
-  for (const prop of properties) {
-    if (!(0, import_types.isObjectProperty)(prop)) continue;
-    if ((0, import_types.isIdentifier)(prop.key, { name: "zone" })) {
-      extractStrings(prop.value, zones);
-    }
-    if ((0, import_types.isIdentifier)(prop.key, { name: "permission" })) {
-      extractStrings(prop.value, permissions);
-    }
-    if ((0, import_types.isIdentifier)(prop.key, { name: "id" }) && (0, import_types.isStringLiteral)(prop.value)) {
-      id = prop.value.value;
+// src/navigation.ts
+function generateNavigation(config) {
+  const { header, names } = emitLayers(config);
+  return `${header}
+
+const groups = new Map()
+const items = new Map()
+for (const navigation of [${names.map((name) => `${name}.navigationModule ?? {}`).join(", ")}]) {
+    for (const group of navigation.groups ?? []) {
+        if (group?.id) groups.set(group.id, { ...(groups.get(group.id) ?? {}), ...group })
     }
-    if ((0, import_types.isIdentifier)(prop.key, { name: "label" }) && (0, import_types.isStringLiteral)(prop.value)) {
-      label = prop.value.value;
+    for (const item of navigation.items ?? []) {
+        if (item?.id) items.set(item.id, { ...(items.get(item.id) ?? {}), ...item })
     }
-  }
-  if (zones.length === 0) return null;
-  return { zones, id, label, permissions };
-}
-function getConfigProperties(node) {
-  if ((0, import_types.isCallExpression)(node) && node.arguments.length > 0 && (0, import_types.isObjectExpression)(node.arguments[0])) {
-    return node.arguments[0].properties;
-  }
-  if ((0, import_types.isObjectExpression)(node)) {
-    return node.properties;
-  }
-  return null;
-}
-function getWidgetConfig(file) {
-  try {
-    const code = import_fs5.default.readFileSync(file, "utf-8");
-    const ast = (0, import_parser.parse)(code, getParserOptions(file));
-    if (!hasDefaultExport(ast)) return null;
-    let info = null;
-    const visit = (declaration) => {
-      if (info) return;
-      if (!(0, import_types.isVariableDeclaration)(declaration)) return;
-      for (const decl of declaration.declarations) {
-        if ((0, import_types.isVariableDeclarator)(decl) && (0, import_types.isIdentifier)(decl.id, { name: "config" })) {
-          const props = getConfigProperties(decl.init);
-          if (props) info = readWidgetConfig(props);
-        }
-      }
-    };
-    traverse(ast, {
-      ExportNamedDeclaration(p) {
-        visit(p.node.declaration);
-      },
-      VariableDeclaration(p) {
-        visit(p.node);
-      }
-    });
-    return info;
-  } catch {
-    return null;
-  }
-}
-function hashPath(relative) {
-  let hash = 0;
-  for (let i = 0; i < relative.length; i++) {
-    hash = (hash << 5) - hash + relative.charCodeAt(i);
-    hash |= 0;
-  }
-  return Math.abs(hash).toString(36).slice(0, 6);
-}
-function widgetId(info, file, widgetsDir) {
-  if (info.id) return info.id;
-  const relative = normalizePath(import_path5.default.relative(widgetsDir, file));
-  return `Widget-${hashPath(relative)}`;
-}
-function parseWidgetFile(file, widgetsDir, index) {
-  const info = getWidgetConfig(file);
-  if (!info) return null;
-  const name = `Widget${index}`;
-  const importPath = normalizePath(file);
-  const zonesLiteral = JSON.stringify(info.zones);
-  const id = widgetId(info, file, widgetsDir);
-  return {
-    import: `import ${name} from "${importPath}"`,
-    entry: `    { Component: ${name}, zone: ${zonesLiteral}, widgetId: ${JSON.stringify(
-      id
-    )}${info.label ? `, label: ${JSON.stringify(info.label)}` : ""}${info.permissions.length ? `, permission: ${JSON.stringify(info.permissions)}` : ""} }`
-  };
 }
-function collectWidgets(srcDir, startIndex = 0) {
-  const widgetsDir = import_path5.default.join(srcDir, "widgets");
-  let index = startIndex;
-  const results = [];
-  for (const file of crawlModuleFiles(widgetsDir)) {
-    const result = parseWidgetFile(file, widgetsDir, index);
-    if (result) {
-      results.push(result);
-      index++;
-    }
-  }
-  return {
-    imports: results.map((r) => r.import),
-    entries: results.map((r) => r.entry)
-  };
+
+export default { groups: [...groups.values()], items: [...items.values()] }`;
 }
-function generateWidgets({
-  srcDir,
-  pluginExtensions
-}) {
-  const { imports, entries: widgetEntries } = collectWidgets(srcDir);
-  const pluginDeclarations = pluginExtensions.map(
-    (ext, i) => `import __plugin${i} from "${normalizePath(ext)}"`
-  );
-  const pluginSpreads = pluginExtensions.map(
-    (_, i) => `    ...(__plugin${i}.widgetModule?.widgets ?? [])`
-  );
-  const entries = [...widgetEntries, ...pluginSpreads];
-  if (imports.length === 0 && pluginDeclarations.length === 0 && entries.length === 0) {
-    return `export default { widgets: [] }`;
-  }
-  return `${imports.join("\n")}
 
-${pluginDeclarations.join("\n")}
+// src/custom-fields.ts
+function generateCustomFields(config) {
+  const { header, names } = emitLayers(config);
+  return `${header}
 
 export default {
-    widgets: [
-${entries.join(",\n")}
+    configs: [
+${spreadLayers(names, "customFieldsModule", "configs")}
     ]
 }`;
 }
 
-// src/navigation.ts
-var import_fs6 = __toESM(require("fs"), 1);
-var import_path6 = __toESM(require("path"), 1);
-function findNavigationFile(srcDir) {
-  for (const ext of VALID_FILE_EXTENSIONS) {
-    const filePath = import_path6.default.join(srcDir, `_navigation${ext}`);
-    if (import_fs6.default.existsSync(filePath)) return filePath;
-  }
-  return null;
-}
-function generateNavigation({ srcDir }) {
-  const file = findNavigationFile(srcDir);
-  if (!file) {
-    return `export default { items: [] }`;
-  }
-  return `import navigationConfig from "${normalizePath(file)}"
-export default navigationConfig`;
+// src/layouts-module.ts
+function generateLayouts(config) {
+  const { header, names } = emitLayers(config);
+  return `${header}
+
+const byId = new Map()
+for (const layout of [
+${spreadLayers(names, "layoutModule", "layouts")}
+]) {
+    if (layout?.id) byId.set(layout.id, layout)
 }
 
-// src/custom-fields.ts
-var import_path7 = __toESM(require("path"), 1);
-function generateCustomFields({
-  srcDir,
-  pluginExtensions
-}) {
-  const dir = import_path7.default.join(srcDir, "custom-fields");
-  const files = crawlModuleFiles(dir);
-  const imports = files.map(
-    (file, i) => `import __cf${i} from "${normalizePath(file)}"`
-  );
-  const localRefs = files.map((_, i) => `__cf${i}`);
-  const pluginDeclarations = pluginExtensions.map(
-    (ext, i) => `const __plugin${i} = (await import("${normalizePath(ext)}")).default`
-  );
-  const pluginSpreads = pluginExtensions.map(
-    (_, i) => `    ...(__plugin${i}.customFieldsModule?.configs ?? [])`
-  );
-  const configs = [
-    ...pluginSpreads,
-    ...localRefs.map((ref) => `    ${ref}`)
-  ];
-  if (configs.length === 0 && pluginDeclarations.length === 0) {
-    return `export default { configs: [] }`;
-  }
-  return `${imports.join("\n")}
+export default { layouts: [...byId.values()] }`;
+}
 
-${pluginDeclarations.join("\n")}
+// src/preferences-module.ts
+function generatePreferences(config) {
+  const { header, names } = emitLayers(config);
+  return `${header}
 
-export default {
-    configs: [
-${configs.join(",\n")}
-    ]
-}`;
+export default { layers: [${names.map((name) => `${name}.preferenceModule ?? {}`).join(", ")}] }`;
 }
 
 // src/virtual-modules.ts
@@ -901,6 +940,12 @@ function loadVirtualModule({
   if (id === RESOLVED_CUSTOM_FIELDS_MODULE) {
     return generateCustomFields(mercurConfig);
   }
+  if (id === RESOLVED_LAYOUTS_MODULE) {
+    return generateLayouts(mercurConfig);
+  }
+  if (id === RESOLVED_PREFERENCES_MODULE) {
+    return generatePreferences(mercurConfig);
+  }
   return null;
 }
 function loadConfigModule(mercurConfig) {
@@ -918,19 +963,42 @@ function loadI18nModule(mercurConfig) {
 
 // src/plugin.ts
 function isRouteFile(file) {
-  const basename = import_path8.default.basename(file, import_path8.default.extname(file));
+  const basename = import_path5.default.basename(file, import_path5.default.extname(file));
   return basename === "page";
 }
 function isWidgetFile(file) {
   return normalizeSep(file).includes("/src/widgets/");
 }
 function isNavigationFile(file) {
-  const basename = import_path8.default.basename(file, import_path8.default.extname(file));
-  return basename === "_navigation";
+  const basename = import_path5.default.basename(file, import_path5.default.extname(file));
+  return basename === NAVIGATION_FILE;
+}
+function isPreferencesFile(file) {
+  const basename = import_path5.default.basename(file, import_path5.default.extname(file));
+  return basename === LAYOUT_PREFERENCES_FILE;
 }
 function isCustomFieldFile(file) {
   return normalizeSep(file).includes("/src/custom-fields/");
 }
+function isLayoutFile(file) {
+  return normalizeSep(file).includes("/layouts/");
+}
+function isI18nFile(file) {
+  return normalizeSep(file).includes("/i18n/");
+}
+var LAYERED_MODULES = [
+  RESOLVED_ROUTES_MODULE,
+  RESOLVED_MENU_ITEMS_MODULE,
+  RESOLVED_WIDGETS_MODULE,
+  RESOLVED_NAVIGATION_MODULE,
+  RESOLVED_CUSTOM_FIELDS_MODULE,
+  RESOLVED_LAYOUTS_MODULE,
+  RESOLVED_PREFERENCES_MODULE,
+  RESOLVED_I18N_MODULE
+];
+function isExtensionFile(file) {
+  return isRouteFile(file) || isWidgetFile(file) || isNavigationFile(file) || isPreferencesFile(file) || isCustomFieldFile(file) || isLayoutFile(file) || isI18nFile(file);
+}
 function normalizeSep(file) {
   return file.replace(/\\/g, "/");
 }
@@ -951,7 +1019,7 @@ function isMedusaVirtualModule(id) {
   return MEDUSA_VIRTUAL_MODULES.includes(id);
 }
 function filterResolvableDeps(specifiers, fromDir) {
-  const require2 = (0, import_module.createRequire)(import_path8.default.join(fromDir, "noop.js"));
+  const require2 = (0, import_module.createRequire)(import_path5.default.join(fromDir, "noop.js"));
   return specifiers.filter((specifier) => {
     try {
       require2.resolve(specifier);
@@ -969,44 +1037,44 @@ function isResolvedMedusaVirtualModule(id) {
 }
 function findNodeModulesRoot(configDir) {
   let dir = configDir;
-  while (dir !== import_path8.default.dirname(dir)) {
-    const candidate = import_path8.default.join(dir, "node_modules");
-    if (import_fs7.default.existsSync(candidate) && import_fs7.default.statSync(candidate).isDirectory()) {
+  while (dir !== import_path5.default.dirname(dir)) {
+    const candidate = import_path5.default.join(dir, "node_modules");
+    if (import_fs6.default.existsSync(candidate) && import_fs6.default.statSync(candidate).isDirectory()) {
       return candidate;
     }
-    dir = import_path8.default.dirname(dir);
+    dir = import_path5.default.dirname(dir);
   }
-  return import_path8.default.join(configDir, "node_modules");
+  return import_path5.default.join(configDir, "node_modules");
 }
 function resolvePluginRoot(resolve, configDir, nodeModulesRoot) {
   if (resolve.startsWith(".")) {
     try {
-      const resolved = import_path8.default.resolve(configDir, resolve);
-      return import_fs7.default.existsSync(resolved) ? import_fs7.default.realpathSync(resolved) : null;
+      const resolved = import_path5.default.resolve(configDir, resolve);
+      return import_fs6.default.existsSync(resolved) ? import_fs6.default.realpathSync(resolved) : null;
     } catch {
       return null;
     }
   }
-  const require2 = (0, import_module.createRequire)(import_path8.default.join(configDir, "noop.js"));
+  const require2 = (0, import_module.createRequire)(import_path5.default.join(configDir, "noop.js"));
   try {
-    return import_fs7.default.realpathSync(
-      import_path8.default.dirname(require2.resolve(`${resolve}/package.json`))
+    return import_fs6.default.realpathSync(
+      import_path5.default.dirname(require2.resolve(`${resolve}/package.json`))
     );
   } catch {
   }
   try {
-    let dir = import_path8.default.dirname(require2.resolve(resolve));
-    while (dir !== import_path8.default.dirname(dir)) {
-      if (import_fs7.default.existsSync(import_path8.default.join(dir, "package.json"))) {
-        return import_fs7.default.realpathSync(dir);
+    let dir = import_path5.default.dirname(require2.resolve(resolve));
+    while (dir !== import_path5.default.dirname(dir)) {
+      if (import_fs6.default.existsSync(import_path5.default.join(dir, "package.json"))) {
+        return import_fs6.default.realpathSync(dir);
       }
-      dir = import_path8.default.dirname(dir);
+      dir = import_path5.default.dirname(dir);
     }
   } catch {
   }
   try {
-    const packagePath = import_path8.default.join(nodeModulesRoot, resolve);
-    return import_fs7.default.existsSync(packagePath) ? import_fs7.default.realpathSync(packagePath) : null;
+    const packagePath = import_path5.default.join(nodeModulesRoot, resolve);
+    return import_fs6.default.existsSync(packagePath) ? import_fs6.default.realpathSync(packagePath) : null;
   } catch {
     return null;
   }
@@ -1024,13 +1092,13 @@ function resolvePluginExtensions(plugins, configDir, appType) {
       );
       continue;
     }
-    const extFile = import_path8.default.join(
+    const extFile = import_path5.default.join(
       pluginRoot,
       ".medusa/server/src",
       appType,
       "index.mjs"
     );
-    if (import_fs7.default.existsSync(extFile)) {
+    if (import_fs6.default.existsSync(extFile)) {
       extensions.push(extFile);
     }
   }
@@ -1044,7 +1112,7 @@ function trimTrailingSlashes(value) {
   return end === value.length ? value : value.slice(0, end);
 }
 async function loadMedusaConfig(medusaConfigPath, root, options) {
-  const configDir = import_path8.default.dirname(medusaConfigPath);
+  const configDir = import_path5.default.dirname(medusaConfigPath);
   try {
     const previousCwd = process.cwd();
     let mod;
@@ -1074,7 +1142,7 @@ async function loadMedusaConfig(medusaConfigPath, root, options) {
       const value = modules[key];
       if (!value || typeof value !== "object" || !value.options?.appDir)
         continue;
-      const appDir = import_path8.default.resolve(configDir, value.options.appDir);
+      const appDir = import_path5.default.resolve(configDir, value.options.appDir);
       if (appDir === root) {
         base = value.options.path;
         appType = key === "vendor_ui" ? "vendor" : "admin";
@@ -1085,7 +1153,9 @@ async function loadMedusaConfig(medusaConfigPath, root, options) {
       (plugin) => plugin.resolve !== "@medusajs/draft-order"
     ) ?? [];
     const pluginExtensions = resolvePluginExtensions(plugins, configDir, appType);
-    return { base, pluginExtensions, vendorAppUrl };
+    const projectCandidate = import_path5.default.join(configDir, "src", appType);
+    const projectDir = import_fs6.default.existsSync(projectCandidate) && import_fs6.default.realpathSync(projectCandidate) !== root ? projectCandidate : void 0;
+    return { base, pluginExtensions, projectDir, vendorAppUrl };
   } catch (error) {
     console.warn(
       `[@mercurjs/dashboard-sdk] Could not load the Medusa config from "${medusaConfigPath}": ${error instanceof Error ? error.message : String(error)}. Building with base "/" and no plugin extensions \u2014 if this panel is served under a sub-path (e.g. /dashboard), its assets will not resolve.`
@@ -1101,11 +1171,11 @@ function mercurDashboardPlugin(pluginConfig) {
     async config(viteConfig) {
       root = viteConfig.root || process.cwd();
       const isDevelopment = (viteConfig.mode || process.env.NODE_ENV || "development") !== "production";
-      const medusaConfigPath = import_path8.default.resolve(
+      const medusaConfigPath = import_path5.default.resolve(
         root,
         pluginConfig.medusaConfigPath
       );
-      const { base, pluginExtensions, vendorAppUrl } = await loadMedusaConfig(
+      const { base, pluginExtensions, projectDir, vendorAppUrl } = await loadMedusaConfig(
         medusaConfigPath,
         root,
         {
@@ -1113,7 +1183,7 @@ function mercurDashboardPlugin(pluginConfig) {
           vendorUrl: pluginConfig.vendorUrl
         }
       );
-      const srcDir = import_path8.default.join(root, "src");
+      const srcDir = import_path5.default.join(root, "src");
       const backendUrl = pluginConfig.backendUrl ?? "http://localhost:9000";
       const imageLimit = pluginConfig.imageLimit ?? 2 * 1024 * 1024;
       config = {
@@ -1122,6 +1192,7 @@ function mercurDashboardPlugin(pluginConfig) {
         base,
         root,
         srcDir,
+        projectDir,
         pluginExtensions,
         imageLimit
       };
@@ -1136,16 +1207,7 @@ function mercurDashboardPlugin(pluginConfig) {
           dedupe: ["i18next", "react-i18next", "react", "react-dom"]
         },
         optimizeDeps: {
-          exclude: [
-            "virtual:mercur/config",
-            "virtual:mercur/routes",
-            "virtual:mercur/menu-items",
-            "virtual:mercur/i18n",
-            "virtual:mercur/widgets",
-            "virtual:mercur/navigation",
-            "virtual:mercur/custom-fields",
-            ...MEDUSA_VIRTUAL_MODULES
-          ],
+          exclude: [...VIRTUAL_MODULES, ...MEDUSA_VIRTUAL_MODULES],
           include: filterResolvableDeps(
             [
               "react",
@@ -1191,10 +1253,9 @@ function mercurDashboardPlugin(pluginConfig) {
         }
       };
       const handleChange = (file) => {
-        if (isRouteFile(file)) invalidate(RESOLVED_ROUTES_MODULE, true);
-        if (isWidgetFile(file)) invalidate(RESOLVED_WIDGETS_MODULE, true);
-        if (isNavigationFile(file)) invalidate(RESOLVED_NAVIGATION_MODULE, true);
-        if (isCustomFieldFile(file)) invalidate(RESOLVED_CUSTOM_FIELDS_MODULE, true);
+        if (!isExtensionFile(file)) return;
+        for (const moduleId of LAYERED_MODULES) invalidate(moduleId, false);
+        server.ws.send({ type: "full-reload" });
       };
       server.watcher.on("add", handleChange);
       server.watcher.on("unlink", handleChange);
@@ -1204,103 +1265,21 @@ function mercurDashboardPlugin(pluginConfig) {
         const mod = server.moduleGraph.getModuleById(moduleId);
         if (mod) server.moduleGraph.invalidateModule(mod);
       };
-      if (isRouteFile(file)) invalidate(RESOLVED_ROUTES_MODULE);
-      if (isWidgetFile(file)) invalidate(RESOLVED_WIDGETS_MODULE);
-      if (isNavigationFile(file)) invalidate(RESOLVED_NAVIGATION_MODULE);
-      if (isCustomFieldFile(file)) invalidate(RESOLVED_CUSTOM_FIELDS_MODULE);
+      if (!isExtensionFile(file)) return;
+      for (const moduleId of LAYERED_MODULES) invalidate(moduleId);
     }
   };
 }
 
 // src/generate-plugin-entry.ts
-var import_path9 = __toESM(require("path"), 1);
-var import_fs8 = __toESM(require("fs"), 1);
-function findI18nIndex2(srcDir) {
-  const i18nDir = import_path9.default.join(srcDir, "i18n");
-  if (!import_fs8.default.existsSync(i18nDir)) return null;
-  for (const ext of VALID_FILE_EXTENSIONS) {
-    const filePath = import_path9.default.join(i18nDir, `index${ext}`);
-    if (import_fs8.default.existsSync(filePath)) return filePath;
-  }
-  return null;
-}
 function generatePluginEntryModule(srcDir) {
-  const routesDir = import_path9.default.join(srcDir, "routes");
-  const files = crawlRoutes(routesDir);
-  let index = 0;
-  const routeResults = [];
-  const menuItemResults = [];
-  for (const file of files) {
-    const route = parseFile(file, routesDir, index);
-    if (route) {
-      routeResults.push(route);
-    }
-    const menuItem = parseMenuItemFile(file, routesDir, index);
-    if (menuItem) {
-      menuItemResults.push(menuItem);
-    }
-    index++;
-  }
-  const routeTree = buildRouteTree(routeResults.filter(Boolean));
-  const routeImports = routeTree.flatMap((r) => r.imports);
-  const routes = routeTree.map((r) => formatRoute(r.route));
-  const menuItemImports = menuItemResults.filter(Boolean).map((r) => r.import);
-  const menuItems = menuItemResults.filter(Boolean).map((r) => formatMenuItem(r.menuItem));
-  const { imports: widgetImports, entries: widgetEntries } = collectWidgets(
-    srcDir,
-    index
-  );
-  const cfFiles = crawlModuleFiles(import_path9.default.join(srcDir, "custom-fields"));
-  const cfImports = cfFiles.map(
-    (file, i) => `import __cf${i} from "${normalizePath(file)}"`
-  );
-  const cfRefs = cfFiles.map((_, i) => `    __cf${i}`);
-  const i18nFile = findI18nIndex2(srcDir);
-  const i18nImport = i18nFile ? `import i18nResources from "${normalizePath(i18nFile)}"` : "";
-  const i18nValue = i18nFile ? "i18nResources" : "{}";
-  const allImports = [
-    ...routeImports,
-    ...menuItemImports,
-    ...widgetImports,
-    ...cfImports
-  ];
-  if (i18nImport) allImports.push(i18nImport);
+  const { imports, declaration, name } = collectLayer(srcDir, 0);
   return `// Auto-generated plugin extensions entry
-${allImports.join("\n")}
-
-const routeModule = {
-    routes: [
-${routes.join(",\n")}
-    ]
-}
-
-const menuItemModule = {
-    menuItems: [
-${menuItems.join(",\n")}
-    ]
-}
-
-const widgetModule = {
-    widgets: [
-${widgetEntries.join(",\n")}
-    ]
-}
-
-const customFieldsModule = {
-    configs: [
-${cfRefs.join(",\n")}
-    ]
-}
+${imports.join("\n")}
 
-const plugin = {
-    routeModule,
-    menuItemModule,
-    widgetModule,
-    customFieldsModule,
-    i18nModule: ${i18nValue},
-}
+${declaration}
 
-export default plugin
+export default ${name}
 `;
 }
 // Annotate the CommonJS export names for ESM import in node: