meno-core 1.0.52 → 1.0.53

package/dist/chunks/{chunk-A725KYFK.js → chunk-R6XHAFBF.js}

@@ -1,6 +1,5 @@
 import {
   CachedConfigLoader,
-  buildSlugIndex,
   colorService,
   formatJsonErrorMessage,
   generateFontCSS,
@@ -13,9 +12,8 @@ import {
   loadProjectConfig,
   mapPageNameToPath,
   parseJSON,
-  resolveSlugToPageId,
   variableService
-} from "./chunk-CXCBV2M7.js";
+} from "./chunk-IGYR22T6.js";
 import {
   configService
 } from "./chunk-2MHDV5BF.js";
@@ -37,14 +35,18 @@ import {
   writeFile
 } from "./chunk-WQFG7PAH.js";
 import {
-  extractStringValue
-} from "./chunk-H4JSCDNW.js";
+  extractStringValue,
+  rewriteComponentRefs
+} from "./chunk-QB2LNO4W.js";
 import {
-  isPathWithinRoot
-} from "./chunk-J23ZX5AP.js";
+  buildSlugIndex,
+  isPathWithinRoot,
+  resolveSlugToPageId
+} from "./chunk-X754AHS5.js";
 import {
-  addItemUrls
-} from "./chunk-7NIC4I3V.js";
+  addItemUrls,
+  toFriendlyError
+} from "./chunk-JGWFTO6P.js";
 import {
   parseLocaleFromPath
 } from "./chunk-AZQYF6KE.js";
@@ -55,7 +57,7 @@ import {
   SERVER_PORT,
   WEBSOCKET_STATES,
   init_constants
-} from "./chunk-2QK6U5UK.js";
+} from "./chunk-YBLHKYFF.js";
 
 // lib/server/pageCache.ts
 var PageCache = class {
@@ -540,6 +542,39 @@ var PageService = class {
     const lineMap = buildLineMap(content);
     this.pageCache.set(path2, content, lineMap);
   }
+  /**
+   * Re-read a single page from disk via the provider and refresh the cache.
+   *
+   * Used by the file watcher for live reload. Provider-based (not a hardcoded
+   * JSON read), so it works for any format — the FileSystem provider returns the
+   * raw JSON and the Astro provider returns the parsed model serialized to JSON.
+   *
+   * @returns true if the cache changed (page updated or confirmed-deleted) and a
+   *   reload broadcast is warranted; false if the read failed transiently (e.g. a
+   *   partial mid-write or parse error), in which case the cache is left intact and
+   *   the next watcher event retries.
+   */
+  async reloadPageFromDisk(path2) {
+    if (!this.provider) return false;
+    let content = null;
+    try {
+      content = await this.provider.get(path2);
+    } catch {
+      return false;
+    }
+    if (content) {
+      this.pageCache.set(path2, content, buildLineMap(content));
+      return true;
+    }
+    try {
+      if (!await this.provider.exists(path2)) {
+        this.pageCache.delete(path2);
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
   /**
    * Delete page from cache and optionally from storage
    *
@@ -616,6 +651,19 @@ var PageService = class {
   getLineMap(path2) {
     return this.pageCache.getLineMap(path2);
   }
+  /**
+   * Pages base directory — provider-aware (e.g. `src/pages` for astro projects),
+   * falling back to `projectPaths.pages()` when the provider doesn't expose
+   * `baseDir()` (or no provider is set). Used by the folder/move/rename ops that
+   * touch the filesystem directly.
+   */
+  pagesBaseDir() {
+    return this.provider?.baseDir?.() ?? projectPaths.pages();
+  }
+  /** Page file extension (e.g. `.astro` for astro projects), defaulting to `.json`. */
+  pageExt() {
+    return this.provider?.extension?.() ?? ".json";
+  }
   /**
    * Get all page folders
    *
@@ -624,7 +672,7 @@ var PageService = class {
    * @returns Sorted array of folder names
    */
   getAllFolders() {
-    const pagesDir = projectPaths.pages();
+    const pagesDir = this.pagesBaseDir();
     if (!existsSync(pagesDir)) {
       return [];
     }
@@ -666,7 +714,7 @@ var PageService = class {
         throw new Error("Each folder segment can only contain lowercase letters, numbers, dashes, and underscores");
       }
     }
-    const pagesDir = projectPaths.pages();
+    const pagesDir = this.pagesBaseDir();
     const folderPath = join(pagesDir, trimmed);
     if (existsSync(folderPath)) {
       throw new Error("Folder already exists");
@@ -684,12 +732,13 @@ var PageService = class {
    */
   async movePage(pagePath, newFolder) {
     const { rename } = await import("fs/promises");
-    const pagesDir = projectPaths.pages();
+    const pagesDir = this.pagesBaseDir();
+    const ext = this.pageExt();
     const pageName = pagePath === "/" ? "index" : pagePath.substring(1);
     const slashIndex = pageName.lastIndexOf("/");
     const baseName = slashIndex >= 0 ? pageName.substring(slashIndex + 1) : pageName;
-    const sourceFile = join(pagesDir, `${pageName}.json`);
-    const targetFile = newFolder ? join(pagesDir, newFolder, `${baseName}.json`) : join(pagesDir, `${baseName}.json`);
+    const sourceFile = join(pagesDir, `${pageName}${ext}`);
+    const targetFile = newFolder ? join(pagesDir, newFolder, `${baseName}${ext}`) : join(pagesDir, `${baseName}${ext}`);
     if (newFolder) {
       const targetDir = join(pagesDir, newFolder);
       if (!existsSync(targetDir)) {
@@ -719,6 +768,60 @@ var PageService = class {
       }
     }
   }
+  /**
+   * Rename a page (file rename + cache update).
+   *
+   * Renames the underlying .json file from `oldPath`'s filename to `newPath`'s
+   * filename, keeping the same folder. Updates the in-memory cache so the
+   * page is now keyed at `newPath`. Folder moves stay with `movePage()` —
+   * this is purely "change the URL slug of an existing page" for
+   * single-locale projects.
+   *
+   * @param oldPath - Current page path (e.g., "/about" or "/blog/post")
+   * @param newPath - New page path with same folder (e.g., "/about-us" or "/blog/new-slug")
+   * @throws {Error} If oldPath doesn't exist, newPath already exists, or paths
+   *   reference different folders.
+   */
+  async renamePage(oldPath, newPath) {
+    if (oldPath === newPath) return;
+    if (newPath === "/") {
+      throw new Error("Cannot rename a page to the index path");
+    }
+    if (!newPath.startsWith("/")) {
+      throw new Error('newPath must start with "/"');
+    }
+    const oldName = oldPath === "/" ? "index" : oldPath.substring(1);
+    const newName = newPath.substring(1);
+    const oldSlash = oldName.lastIndexOf("/");
+    const newSlash = newName.lastIndexOf("/");
+    const oldFolder = oldSlash >= 0 ? oldName.substring(0, oldSlash) : "";
+    const newFolder = newSlash >= 0 ? newName.substring(0, newSlash) : "";
+    if (oldFolder !== newFolder) {
+      throw new Error("renamePage only changes the filename; use movePage to change folder");
+    }
+    const baseSegment = newSlash >= 0 ? newName.substring(newSlash + 1) : newName;
+    if (!/^[a-z0-9][a-z0-9-_]*$/.test(baseSegment)) {
+      throw new Error("Page slug can only contain lowercase letters, numbers, dashes, and underscores");
+    }
+    const { rename } = await import("fs/promises");
+    const pagesDir = this.pagesBaseDir();
+    const ext = this.pageExt();
+    const sourceFile = join(pagesDir, `${oldName}${ext}`);
+    const targetFile = join(pagesDir, `${newName}${ext}`);
+    if (!existsSync(sourceFile)) {
+      throw new Error(`Page not found: ${oldPath}`);
+    }
+    if (existsSync(targetFile)) {
+      throw new Error(`Page already exists: ${newPath}`);
+    }
+    await rename(sourceFile, targetFile);
+    const content = this.pageCache.getContent(oldPath);
+    if (content) {
+      this.pageCache.delete(oldPath);
+      const lineMap = buildLineMap(content);
+      this.pageCache.set(newPath, content, lineMap);
+    }
+  }
   /**
    * Get slug mappings for all pages
    *
@@ -765,6 +868,7 @@ var ComponentService = class {
   componentCategories = /* @__PURE__ */ new Map();
   fs;
   loader;
+  writer;
   loadErrors = /* @__PURE__ */ new Map();
   loadWarnings = [];
   /**
@@ -772,11 +876,26 @@ var ComponentService = class {
    *
    * @param options - Optional configuration for dependency injection
    * @param options.fs - Optional file system interface for testing
-   * @param options.loader - Optional component loader interface for testing
+   * @param options.loader - Optional component loader interface for testing (READ)
+   * @param options.writer - Optional component writer for non-JSON on-disk formats
+   *   (WRITE). When omitted, the service writes JSON exactly as before — legacy
+   *   projects are byte-identical. The astro bootstrap injects an AstroComponentWriter
+   *   so saves emit `.astro` files under `src/components/`.
    */
   constructor(options) {
     this.fs = options?.fs;
     this.loader = options?.loader;
+    this.writer = options?.writer;
+  }
+  /**
+   * Base components directory — `<root>/components` for JSON, or whatever the
+   * injected writer owns (e.g. `<root>/src/components` for astro). All path
+   * resolution (categories, folders, save/move/rename targets) routes through
+   * here so a single switch covers every write op.
+   * @internal
+   */
+  componentsBaseDir() {
+    return this.writer ? this.writer.componentsDir() : projectPaths.components();
   }
   /**
    * Load all components from the components directory
@@ -795,28 +914,32 @@ var ComponentService = class {
    * ```
    */
   async loadAllComponents() {
-    this.components.clear();
-    this.componentCategories.clear();
-    this.loadErrors.clear();
-    this.loadWarnings = [];
+    const nextComponents = /* @__PURE__ */ new Map();
+    const nextCategories = /* @__PURE__ */ new Map();
+    const nextErrors = /* @__PURE__ */ new Map();
+    let nextWarnings = [];
     let loadedComponents;
     if (this.loader) {
       loadedComponents = await this.loader.loadDirectory(projectPaths.components());
     } else {
       const result = await loadComponentDirectory(projectPaths.components());
       loadedComponents = result.components;
-      this.loadWarnings = result.warnings;
+      nextWarnings = result.warnings;
       for (const error of result.errors) {
-        this.loadErrors.set(error.componentName, error);
+        nextErrors.set(error.componentName, error);
       }
     }
     loadedComponents.forEach((value, key) => {
       const componentWithCategory = value;
       const category = componentWithCategory._category;
-      this.componentCategories.set(key, category);
+      nextCategories.set(key, category);
       const { _category, _relativePath, ...cleanDef } = componentWithCategory;
-      this.components.set(key, cleanDef);
+      nextComponents.set(key, cleanDef);
     });
+    this.components = nextComponents;
+    this.componentCategories = nextCategories;
+    this.loadErrors = nextErrors;
+    this.loadWarnings = nextWarnings;
   }
   /**
    * Get component by name
@@ -968,10 +1091,60 @@ var ComponentService = class {
    * @internal
    */
   getComponentDir(name, category) {
-    const componentsDir = projectPaths.components();
-    const cat = category ?? this.componentCategories.get(name);
+    const componentsDir = this.componentsBaseDir();
+    const cat = this.resolveComponentCategory(name, category);
     return cat ? join2(componentsDir, cat) : componentsDir;
   }
+  /**
+   * Resolve which category a save should land in. Priority:
+   *   1. Explicit caller-supplied category (including '' for root)
+   *   2. In-memory categories cache
+   *   3. Existing file on disk (defense against a stale/empty cache)
+   * Falls back to root only when none of the above resolves. The disk
+   * scan in step 3 closes the race where a save fires while
+   * loadAllComponents has been called but hasn't rebuilt the cache yet.
+   * @internal
+   */
+  resolveComponentCategory(name, category) {
+    if (category !== void 0) {
+      return category || void 0;
+    }
+    if (this.componentCategories.has(name)) {
+      return this.componentCategories.get(name);
+    }
+    return this.findComponentCategoryOnDisk(name);
+  }
+  /**
+   * Look on disk for an existing `<name>.json` and return its category.
+   * Returns undefined for "exists at root" or "not found anywhere" — both
+   * map to writing at root, which is the right default.
+   * @internal
+   */
+  findComponentCategoryOnDisk(name) {
+    const componentsDir = this.componentsBaseDir();
+    if (!existsSync2(componentsDir)) return void 0;
+    const ext = this.writer ? null : ".json";
+    const existsAt = (dir) => {
+      if (ext) return existsSync2(join2(dir, `${name}${ext}`));
+      try {
+        return readdirSync2(dir, { withFileTypes: true }).some(
+          (e) => e.isFile() && (e.name === `${name}.json` || e.name === `${name}.astro`)
+        );
+      } catch {
+        return false;
+      }
+    };
+    if (existsAt(componentsDir)) return void 0;
+    try {
+      for (const entry of readdirSync2(componentsDir, { withFileTypes: true })) {
+        if (entry.isDirectory() && existsAt(join2(componentsDir, entry.name))) {
+          return entry.name;
+        }
+      }
+    } catch {
+    }
+    return void 0;
+  }
   /**
    * Get component JavaScript from .js file
    *
@@ -1029,18 +1202,23 @@ var ComponentService = class {
    * ```
    */
   async saveComponent(name, data, category) {
-    const writeFile2 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("fs/promises")).writeFile;
     const dataWithoutJS = JSON.parse(JSON.stringify(data));
     if (dataWithoutJS?.component?.javascript !== void 0) {
       delete dataWithoutJS.component.javascript;
     }
-    const targetCategory = category !== void 0 ? category || void 0 : this.componentCategories.get(name);
-    const componentDir = this.getComponentDir(name, targetCategory);
-    if (targetCategory && !existsSync2(componentDir)) {
-      mkdirSync2(componentDir, { recursive: true });
+    const targetCategory = this.resolveComponentCategory(name, category);
+    const componentsDir = this.componentsBaseDir();
+    const componentDir = targetCategory ? join2(componentsDir, targetCategory) : componentsDir;
+    if (this.writer) {
+      await this.writer.writeComponent(componentDir, name, dataWithoutJS);
+    } else {
+      const writeFile2 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("fs/promises")).writeFile;
+      if (targetCategory && !existsSync2(componentDir)) {
+        mkdirSync2(componentDir, { recursive: true });
+      }
+      const filePath = join2(componentDir, `${name}.json`);
+      await writeFile2(filePath, JSON.stringify(dataWithoutJS, null, 2), "utf-8");
     }
-    const filePath = join2(componentDir, `${name}.json`);
-    await writeFile2(filePath, JSON.stringify(dataWithoutJS, null, 2), "utf-8");
     this.components.set(name, dataWithoutJS);
     this.componentCategories.set(name, targetCategory);
   }
@@ -1062,8 +1240,15 @@ var ComponentService = class {
    * ```
    */
   async saveComponentJavaScript(name, javascript) {
-    const writeFile2 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("fs/promises")).writeFile;
     const componentDir = this.getComponentDir(name);
+    if (this.writer) {
+      const current = this.components.get(name);
+      await this.writer.writeJavaScript(componentDir, name, javascript || "", current);
+      const next = current ? { ...current, component: { ...current.component, javascript: javascript || "" } } : { component: { javascript: javascript || "" } };
+      this.components.set(name, next);
+      return;
+    }
+    const writeFile2 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("fs/promises")).writeFile;
     const jsFilePath = join2(componentDir, `${name}.js`);
     await writeFile2(jsFilePath, javascript || "", "utf-8");
     const componentPath = join2(componentDir, `${name}.json`);
@@ -1101,8 +1286,15 @@ var ComponentService = class {
    * ```
    */
   async saveComponentCSS(name, css) {
-    const writeFile2 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("fs/promises")).writeFile;
     const componentDir = this.getComponentDir(name);
+    if (this.writer) {
+      const current = this.components.get(name);
+      await this.writer.writeCSS(componentDir, name, css || "", current);
+      const next = current ? { ...current, component: { ...current.component, css: css || "" } } : { component: { css: css || "" } };
+      this.components.set(name, next);
+      return;
+    }
+    const writeFile2 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("fs/promises")).writeFile;
     const cssFilePath = join2(componentDir, `${name}.css`);
     await writeFile2(cssFilePath, css || "", "utf-8");
     const componentPath = join2(componentDir, `${name}.json`);
@@ -1137,7 +1329,7 @@ var ComponentService = class {
    * ```
    */
   getAllFolders() {
-    const componentsDir = projectPaths.components();
+    const componentsDir = this.componentsBaseDir();
     if (!existsSync2(componentsDir)) {
       return [];
     }
@@ -1172,7 +1364,7 @@ var ComponentService = class {
     if (sanitized !== folderName.trim()) {
       throw new Error("Folder name can only contain lowercase letters, numbers, dashes, and underscores");
     }
-    const componentsDir = projectPaths.components();
+    const componentsDir = this.componentsBaseDir();
     const folderPath = join2(componentsDir, folderName);
     if (existsSync2(folderPath)) {
       throw new Error("Folder already exists");
@@ -1206,19 +1398,23 @@ var ComponentService = class {
     if (currentCategory === targetCategory) {
       return;
     }
-    const componentsDir = projectPaths.components();
+    const componentsDir = this.componentsBaseDir();
     const sourceDir = currentCategory ? join2(componentsDir, currentCategory) : componentsDir;
     const targetDir = targetCategory ? join2(componentsDir, targetCategory) : componentsDir;
-    if (targetCategory && !existsSync2(targetDir)) {
-      mkdirSync2(targetDir, { recursive: true });
-    }
-    const extensions = [".json", ".js", ".css"];
-    const { rename } = await import("fs/promises");
-    for (const ext of extensions) {
-      const sourcePath = join2(sourceDir, `${name}${ext}`);
-      const targetPath = join2(targetDir, `${name}${ext}`);
-      if (existsSync2(sourcePath)) {
-        await rename(sourcePath, targetPath);
+    if (this.writer) {
+      await this.writer.moveComponent(sourceDir, targetDir, name);
+    } else {
+      if (targetCategory && !existsSync2(targetDir)) {
+        mkdirSync2(targetDir, { recursive: true });
+      }
+      const extensions = [".json", ".js", ".css"];
+      const { rename } = await import("fs/promises");
+      for (const ext of extensions) {
+        const sourcePath = join2(sourceDir, `${name}${ext}`);
+        const targetPath = join2(targetDir, `${name}${ext}`);
+        if (existsSync2(sourcePath)) {
+          await rename(sourcePath, targetPath);
+        }
       }
     }
     this.componentCategories.set(name, targetCategory);
@@ -1232,6 +1428,112 @@ var ComponentService = class {
       }
     }
   }
+  /**
+   * Rename a component across the project.
+   *
+   * Renames the component's `.json`/`.js`/`.css` files on disk (respecting its
+   * category folder), updates the in-memory caches, rewrites every
+   * `{ type: "component", component: "<oldName>" }` reference inside other
+   * component structures, and — if `pageService` is provided — also walks every
+   * page/template and rewrites references there, saving any pages that changed.
+   *
+   * Matching is structural (only `node.component` string equality), not
+   * text-based, so it never touches HTML tags, CSS classes, prop values, or
+   * embedded markup that happen to contain the name as a substring.
+   *
+   * @throws {Error} If old/new name is missing, names are identical, new name
+   *   isn't a valid JS identifier, the source component doesn't exist, or the
+   *   new name is already taken.
+   */
+  async renameComponent(oldName, newName, pageService) {
+    if (!oldName || typeof oldName !== "string") {
+      throw new Error("oldName is required");
+    }
+    if (!newName || typeof newName !== "string") {
+      throw new Error("newName is required");
+    }
+    const trimmedNew = newName.trim();
+    if (oldName === trimmedNew) {
+      throw new Error("newName must differ from oldName");
+    }
+    if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(trimmedNew)) {
+      throw new Error("newName must be a valid JavaScript identifier");
+    }
+    if (!this.components.has(oldName)) {
+      throw new Error(`Component "${oldName}" not found`);
+    }
+    if (this.components.has(trimmedNew)) {
+      throw new Error(`Component "${trimmedNew}" already exists`);
+    }
+    const category = this.componentCategories.get(oldName);
+    const componentsDir = this.componentsBaseDir();
+    const dir = category ? join2(componentsDir, category) : componentsDir;
+    if (this.writer) {
+      if (await this.writer.componentExists(dir, trimmedNew)) {
+        throw new Error(`Component "${trimmedNew}" already exists in components/${category ?? ""}`);
+      }
+      await this.writer.moveComponent(dir, dir, oldName, trimmedNew);
+    } else {
+      for (const ext of [".json", ".js", ".css"]) {
+        if (existsSync2(join2(dir, `${trimmedNew}${ext}`))) {
+          throw new Error(`File "${trimmedNew}${ext}" already exists in components/${category ?? ""}`);
+        }
+      }
+      const { rename } = await import("fs/promises");
+      for (const ext of [".json", ".js", ".css"]) {
+        const src = join2(dir, `${oldName}${ext}`);
+        const dst = join2(dir, `${trimmedNew}${ext}`);
+        if (existsSync2(src)) {
+          await rename(src, dst);
+        }
+      }
+    }
+    const def = this.components.get(oldName);
+    this.components.delete(oldName);
+    this.componentCategories.delete(oldName);
+    this.components.set(trimmedNew, def);
+    this.componentCategories.set(trimmedNew, category);
+    let componentRefs = 0;
+    const writeFile2 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("fs/promises")).writeFile;
+    for (const [name, otherDef] of this.components.entries()) {
+      if (name === trimmedNew) continue;
+      const structure = otherDef.component?.structure;
+      if (!structure) continue;
+      if (rewriteComponentRefs(structure, oldName, trimmedNew)) {
+        const otherCategory = this.componentCategories.get(name);
+        const otherDir = otherCategory ? join2(componentsDir, otherCategory) : componentsDir;
+        const persisted = JSON.parse(JSON.stringify(otherDef));
+        if (persisted?.component?.javascript !== void 0) {
+          delete persisted.component.javascript;
+        }
+        if (this.writer) {
+          await this.writer.writeComponent(otherDir, name, persisted);
+        } else {
+          await writeFile2(join2(otherDir, `${name}.json`), JSON.stringify(persisted, null, 2), "utf-8");
+        }
+        componentRefs++;
+      }
+    }
+    let pageRefs = 0;
+    if (pageService) {
+      const pagePaths = pageService.getAllPagePaths();
+      for (const path2 of pagePaths) {
+        const pageData = pageService.getPageData(path2);
+        if (!pageData || !("root" in pageData) || !pageData.root) continue;
+        if (rewriteComponentRefs(pageData.root, oldName, trimmedNew)) {
+          await pageService.savePage(path2, pageData);
+          pageRefs++;
+        }
+      }
+    }
+    return {
+      oldName,
+      newName: trimmedNew,
+      category,
+      componentRefs,
+      pageRefs
+    };
+  }
 };
 
 // lib/server/services/EnumService.ts
@@ -1328,13 +1630,9 @@ var EnumService = class extends CachedConfigLoader {
 };
 var enumService = new EnumService();
 
-// lib/server/services/fileWatcherService.ts
-import { join as join3 } from "path";
-import { existsSync as existsSync4 } from "fs";
-
 // lib/server/fileWatcher.ts
 import { watch, existsSync as existsSync3 } from "fs";
-import { basename, dirname } from "path";
+import { basename, dirname, join as join3 } from "path";
 function attachWhenDirExists(dirPath, attach, setWatcher) {
   if (existsSync3(dirPath)) {
     setWatcher(attach());
@@ -1369,6 +1667,10 @@ var FileWatcher = class {
   imagesWatcher = null;
   librariesWatcher = null;
   projectConfigWatcher = null;
+  // Astro-format projects keep pages/components/CMS under src/ as .astro/.json.
+  astroPagesWatcher = null;
+  astroComponentsWatcher = null;
+  astroContentWatcher = null;
   /**
    * Start watching components directory
    * Watches both .json and .js files to detect component definition and JavaScript changes
@@ -1565,6 +1867,39 @@ var FileWatcher = class {
       }
     );
   }
+  /**
+   * Astro-format projects keep pages/components/CMS under src/ as .astro/.json.
+   * The onPageChange/onComponentChange/onCMSChange callbacks are format-agnostic
+   * (reload goes through the active provider), so file→editor live reload works
+   * for `.astro` the same way it does for JSON. These are no-ops in JSON projects
+   * (the src/ dirs don't exist).
+   */
+  watchAstroPages(dirPath = join3(getProjectRoot(), "src", "pages")) {
+    if (!existsSync3(dirPath)) return;
+    this.astroPagesWatcher = watch(dirPath, { recursive: true }, async (_event, filename) => {
+      if (filename && filename.endsWith(".astro") && !filename.includes("[")) {
+        const pagePath = mapPageNameToPath(filename.replace(/\.astro$/, ""));
+        if (this.callbacks.onPageChange) await this.callbacks.onPageChange(pagePath);
+      }
+    });
+  }
+  watchAstroComponents(dirPath = join3(getProjectRoot(), "src", "components")) {
+    if (!existsSync3(dirPath)) return;
+    this.astroComponentsWatcher = watch(dirPath, { recursive: true }, async (_event, filename) => {
+      if (filename && filename.endsWith(".astro") && this.callbacks.onComponentChange) {
+        await this.callbacks.onComponentChange();
+      }
+    });
+  }
+  watchAstroContent(dirPath = join3(getProjectRoot(), "src", "content")) {
+    if (!existsSync3(dirPath)) return;
+    this.astroContentWatcher = watch(dirPath, { recursive: true }, async (_event, filename) => {
+      if (filename && filename.endsWith(".json") && this.callbacks.onCMSChange) {
+        const collection = filename.split("/")[0];
+        await this.callbacks.onCMSChange(collection);
+      }
+    });
+  }
   /**
    * Start watching all directories
    */
@@ -1579,6 +1914,9 @@ var FileWatcher = class {
     this.watchImages();
     this.watchLibraries();
     this.watchProjectConfig();
+    this.watchAstroPages();
+    this.watchAstroComponents();
+    this.watchAstroContent();
   }
   /**
    * Stop watching all directories
@@ -1624,6 +1962,18 @@ var FileWatcher = class {
       this.projectConfigWatcher.close();
       this.projectConfigWatcher = null;
     }
+    if (this.astroPagesWatcher) {
+      this.astroPagesWatcher.close();
+      this.astroPagesWatcher = null;
+    }
+    if (this.astroComponentsWatcher) {
+      this.astroComponentsWatcher.close();
+      this.astroComponentsWatcher = null;
+    }
+    if (this.astroContentWatcher) {
+      this.astroContentWatcher.close();
+      this.astroContentWatcher = null;
+    }
   }
   /**
    * Check if watchers are active
@@ -1656,18 +2006,8 @@ var FileWatcherService = class {
         this.wsManager.broadcastUpdate("all");
       },
       onPageChange: async (pagePath) => {
-        const pageName = pagePath === "/" ? "index" : pagePath.substring(1);
-        const filePath = pageName.startsWith("templates/") ? join3(projectPaths.templates(), `${pageName.substring("templates/".length)}.json`) : join3(projectPaths.pages(), `${pageName}.json`);
-        const content = await loadJSONFile(filePath);
-        if (content) {
-          const lineMap = buildLineMap(content);
-          this.pageCache.set(pagePath, content, lineMap);
+        if (await this.pageService.reloadPageFromDisk(pagePath)) {
           this.wsManager.broadcastUpdate(pagePath);
-        } else {
-          if (!existsSync4(filePath)) {
-            this.pageCache.delete(pagePath);
-            this.wsManager.broadcastUpdate(pagePath);
-          }
         }
         if (pagePath.startsWith("/templates/") && this.cmsService) {
           if (this.refreshSchemasTimer !== null) {
@@ -1862,6 +2202,41 @@ function jsonResponse(data, options = {}) {
 function errorResponse(message, status = 500) {
   return jsonResponse({ error: message }, { status });
 }
+function fnv1a(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function cachedJsonResponse(req, body, options = {}) {
+  const corsHeaders = createCorsHeaders();
+  const contentType = options.contentType ?? "application/json";
+  const etag = `W/"${fnv1a(body)}"`;
+  const ifNoneMatch = req.headers.get("if-none-match");
+  if (ifNoneMatch && ifNoneMatch === etag) {
+    return new Response(null, {
+      status: 304,
+      headers: {
+        "ETag": etag,
+        "Cache-Control": "no-cache",
+        ...corsHeaders
+      }
+    });
+  }
+  return new Response(body, {
+    status: options.status ?? 200,
+    headers: {
+      "Content-Type": contentType,
+      "ETag": etag,
+      // `no-cache` (not `no-store`) — browser may keep the body but must
+      // revalidate every time. Pairs with the 304 branch above.
+      "Cache-Control": "no-cache",
+      ...corsHeaders
+    }
+  });
+}
 
 // lib/server/routes/api/cms.ts
 function handleCollectionsRoute(cmsService) {
@@ -1958,32 +2333,21 @@ function handlePageDataRoute(url, pageService) {
     return jsonResponse({ error: "Page not found" }, { status: 404 });
   }
 }
-function handlePageContentRoute(url, pageService) {
+function handlePageContentRoute(req, url, pageService) {
   const page = url.searchParams.get("page") || "/";
   const content = pageService.getPage(page);
-  const corsHeaders = createCorsHeaders();
   if (content) {
-    return new Response(content, {
-      headers: {
-        "Content-Type": "application/json",
-        "Cache-Control": "no-store, max-age=0",
-        "Pragma": "no-cache",
-        "Expires": "0",
-        ...corsHeaders
-      }
-    });
-  } else {
-    return new Response("Page not found", {
-      status: 404,
-      headers: {
-        "Content-Type": "application/json",
-        "Cache-Control": "no-store, max-age=0",
-        "Pragma": "no-cache",
-        "Expires": "0",
-        ...corsHeaders
-      }
-    });
+    return cachedJsonResponse(req, content);
   }
+  const corsHeaders = createCorsHeaders();
+  return new Response("Page not found", {
+    status: 404,
+    headers: {
+      "Content-Type": "application/json",
+      "Cache-Control": "no-store, max-age=0",
+      ...corsHeaders
+    }
+  });
 }
 function handleSlugMappingsRoute(pageService) {
   const mappings = pageService.getSlugMappings();
@@ -1991,7 +2355,7 @@ function handleSlugMappingsRoute(pageService) {
 }
 
 // lib/server/routes/api/components.ts
-function handleComponentsRoute(componentService) {
+function handleComponentsRoute(req, componentService) {
   const componentsWithCategories = componentService.getAllComponentsWithCategories();
   const result = {};
   for (const [name, info] of Object.entries(componentsWithCategories)) {
@@ -2004,7 +2368,7 @@ function handleComponentsRoute(componentService) {
   if (diagnostics.errors.length > 0 || diagnostics.warnings.length > 0) {
     result._diagnostics = diagnostics;
   }
-  return jsonResponse(result);
+  return cachedJsonResponse(req, JSON.stringify(result));
 }
 function handleComponentDataRoute(url, componentService) {
   const componentName = url.pathname.replace("/api/component-data/", "");
@@ -2293,13 +2657,13 @@ async function handleCoreApiRoutes(req, url, context) {
   }
   if (url.pathname === API_ROUTES.PAGE_CONTENT && req.method === "GET") {
     return await handleRouteError(
-      () => Promise.resolve(handlePageContentRoute(url, pageService)),
+      () => Promise.resolve(handlePageContentRoute(req, url, pageService)),
       "Failed to fetch page content"
     );
   }
   if (url.pathname === API_ROUTES.COMPONENTS && req.method === "GET") {
     return await handleRouteError(
-      () => Promise.resolve(handleComponentsRoute(componentService)),
+      () => Promise.resolve(handleComponentsRoute(req, componentService)),
       "Failed to fetch components list"
     );
   }
@@ -2503,13 +2867,21 @@ function safeJsonForScript(data) {
 }
 function generateErrorPage(error, context, cspNonce) {
   const errorInfo = extractErrorInfo(error);
+  const friendly = toFriendlyError(errorInfo.message);
   const errorMessage = escapeHtml(errorInfo.message);
   const errorStack = errorInfo.stack ? escapeHtml(errorInfo.stack) : "";
+  const renderInline = (s) => escapeHtml(s).replace(/`([^`]+)`/g, "<code>$1</code>");
+  const friendlyTitle = escapeHtml(friendly.title);
+  const friendlyMessage = renderInline(friendly.friendlyMessage);
+  const friendlyHint = friendly.hint ? renderInline(friendly.hint) : "";
   const nonceAttr = cspNonce ? ` nonce="${cspNonce}"` : "";
   const errorDataJson = safeJsonForScript({
     type: "PREVIEW_ERROR",
     error: {
-      message: errorInfo.message,
+      message: friendly.friendlyMessage,
+      title: friendly.title,
+      hint: friendly.hint,
+      raw: errorInfo.message,
       stack: errorInfo.stack,
       context
     }
@@ -2523,7 +2895,7 @@ function generateErrorPage(error, context, cspNonce) {
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Preview Error</title>
-  <style>
+  <style${nonceAttr}>
     * { margin: 0; padding: 0; box-sizing: border-box; }
     body {
       font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
@@ -2560,6 +2932,21 @@ function generateErrorPage(error, context, cspNonce) {
       text-transform: uppercase;
       letter-spacing: 0.5px;
     }
+    .error-friendly {
+      font-size: 15px;
+      line-height: 1.6;
+      color: #e8e8e8;
+      margin-bottom: 16px;
+    }
+    .error-friendly code {
+      font-family: 'SF Mono', Menlo, Monaco, 'Courier New', monospace;
+      font-size: 13px;
+      background: #1a1a1a;
+      border: 1px solid #444;
+      border-radius: 4px;
+      padding: 1px 5px;
+      color: #ffb86b;
+    }
     .error-message {
       background: #1a1a1a;
       border: 1px solid #444;
@@ -2637,25 +3024,24 @@ function generateErrorPage(error, context, cspNonce) {
   <div class="error-container">
     <div class="error-header">
       <span class="error-icon">\u26A0\uFE0F</span>
-      <span class="error-title">Render Error</span>
+      <span class="error-title">${friendlyTitle}</span>
     </div>
     <div class="error-body">
       ${context ? `<div class="error-context">${escapeHtml(context)}</div>` : ""}
-      <div class="error-message">${errorMessage}</div>
-      ${errorStack ? `
+      <p class="error-friendly">${friendlyMessage}</p>
       <div class="error-stack">
         <button class="stack-toggle" id="stackToggle">
           <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
             <polyline points="9 18 15 12 9 6"></polyline>
           </svg>
-          <span>Show Stack Trace</span>
+          <span>Show technical details</span>
         </button>
-        <div class="stack-content" id="stackContent">${errorStack}</div>
+        <div class="stack-content" id="stackContent"><div class="error-message">${errorMessage}</div>${errorStack ? `
+${errorStack}` : ""}</div>
       </div>
-      ` : ""}
     </div>
     <div class="error-footer">
-      <span class="error-hint">Check your component JavaScript for errors</span>
+      <span class="error-hint">${friendlyHint}</span>
       <button class="copy-btn" id="copyBtn">
         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
           <rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect>
@@ -2683,7 +3069,7 @@ function generateErrorPage(error, context, cspNonce) {
         stackToggle.addEventListener('click', function() {
           var isVisible = stackContent.classList.toggle('visible');
           stackToggle.classList.toggle('expanded', isVisible);
-          stackToggle.querySelector('span').textContent = isVisible ? 'Hide Stack Trace' : 'Show Stack Trace';
+          stackToggle.querySelector('span').textContent = isVisible ? 'Hide technical details' : 'Show technical details';
         });
       }
 
@@ -2729,7 +3115,7 @@ function generateCspNonce() {
 async function handlePageRoute(url, context, req) {
   const { pageService, componentService, cmsService, injectLiveReload, isEditor, serverPort } = context;
   const pagePath = url.pathname;
-  const injectEditorAttrs = req?.headers.get(EDITOR_HEADER) === "1";
+  const injectEditorAttrs = injectLiveReload === true || req?.headers.get(EDITOR_HEADER) === "1";
   const cspNonce = generateCspNonce();
   const i18nConfig = await loadI18nConfig();
   const { locale, pathWithoutLocale } = parseLocaleFromPath(pagePath, i18nConfig);
@@ -2849,7 +3235,7 @@ async function handlePageRoute(url, context, req) {
       });
     }
   }
-  const pageContent = pageService.getPage(lookupPath);
+  const pageContent = context.draftPageStore?.get(lookupPath) ?? pageService.getPage(lookupPath);
   if (pageContent) {
     try {
       const pageData = parseJSON(pageContent);
@@ -3020,6 +3406,53 @@ async function handleRoutes(req, url, server, context) {
       logResponseTime(startTime, req);
       return void 0;
     }
+    if (url.pathname === "/__draft-page" && req.method === "POST") {
+      const corsHeaders = { "Access-Control-Allow-Origin": "*" };
+      const store = context.draftPageStore;
+      const ws = context.wsManager;
+      if (!store || !ws || ws.getClientCount() === 0) {
+        logResponseTime(startTime, req);
+        return new Response(null, { status: 204, headers: corsHeaders });
+      }
+      try {
+        const body = await req.json();
+        if (typeof body.path === "string" && typeof body.content === "string" && body.path.startsWith("/")) {
+          store.set(body.path, body.content);
+          ws.broadcastUpdate(body.path);
+        }
+      } catch {
+      }
+      logResponseTime(startTime, req);
+      return new Response(null, { status: 204, headers: corsHeaders });
+    }
+    if (url.pathname === "/__draft-page/clear" && req.method === "POST") {
+      const corsHeaders = { "Access-Control-Allow-Origin": "*" };
+      const store = context.draftPageStore;
+      if (store) {
+        try {
+          const body = await req.json();
+          if (typeof body.path === "string") {
+            store.clear(body.path);
+            context.wsManager?.broadcastUpdate(body.path);
+          }
+        } catch {
+        }
+      }
+      logResponseTime(startTime, req);
+      return new Response(null, { status: 204, headers: corsHeaders });
+    }
+    if (url.pathname === "/__draft-page/clients" && req.method === "GET") {
+      const count = context.wsManager?.getClientCount() ?? 0;
+      logResponseTime(startTime, req);
+      return new Response(JSON.stringify({ count }), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          "Cache-Control": "no-store",
+          "Access-Control-Allow-Origin": "*"
+        }
+      });
+    }
     const cmsContext = cmsService && cmsProvider ? { cmsService, cmsProvider } : void 0;
     const apiResponse = await handleApiRoutes(
       req,
@@ -3081,6 +3514,13 @@ async function handleRoutes(req, url, server, context) {
         return response2;
       }
     }
+    if (url.pathname.startsWith("/api/")) {
+      logResponseTime(startTime, req);
+      return new Response(
+        JSON.stringify({ error: "Not Found", path: url.pathname }),
+        { status: 404, headers: { "Content-Type": "application/json" } }
+      );
+    }
     if (url.pathname === "/" || url.pathname.startsWith("/") && !url.pathname.includes(".")) {
       const response2 = await handlePageRoute(url, context, req);
       logResponseTime(startTime, req);
@@ -3109,6 +3549,7 @@ async function createServer(config) {
     wsManager,
     cmsService,
     cmsProvider,
+    draftPageStore,
     additionalRoutes = [],
     onWSMessage,
     injectLiveReload,
@@ -3124,7 +3565,9 @@ async function createServer(config) {
     cmsService,
     cmsProvider,
     injectLiveReload,
-    isEditor
+    isEditor,
+    wsManager,
+    draftPageStore
   };
   let boundPort;
   let lastError;
@@ -3210,7 +3653,7 @@ async function createServer(config) {
 }
 
 // lib/server/providers/fileSystemPageProvider.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3, mkdirSync as mkdirSync3, rmdirSync as rmdirSync3 } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync3, mkdirSync as mkdirSync3, rmdirSync as rmdirSync3 } from "fs";
 import { join as join4, dirname as dirname2 } from "path";
 
 // lib/shared/utils/fileUtils.ts
@@ -3219,7 +3662,7 @@ var stripExtension = (name) => {
   const lastDotIndex = name.lastIndexOf(".");
   return lastDotIndex > 0 ? name.substring(0, lastDotIndex) : name;
 };
-var mapPageNameToPath3 = (pageName) => {
+var mapPageNameToPath2 = (pageName) => {
   return pageName === "index" ? "/" : `/${pageName}`;
 };
 var mapPathToPageName = (path2) => {
@@ -3244,10 +3687,10 @@ var FileSystemPageProvider = class {
   }
   async loadAll() {
     const pages = /* @__PURE__ */ new Map();
-    if (existsSync5(this.pagesDir)) {
+    if (existsSync4(this.pagesDir)) {
       await this.scanDirectory(this.pagesDir, "", pages);
     }
-    if (this.templatesDir && existsSync5(this.templatesDir)) {
+    if (this.templatesDir && existsSync4(this.templatesDir)) {
       await this.scanDirectory(this.templatesDir, "templates", pages);
     }
     return pages;
@@ -3266,7 +3709,7 @@ var FileSystemPageProvider = class {
         const pageName = prefix ? `${prefix}/${stripExtension(entry.name)}` : stripExtension(entry.name);
         const content = await loadJSONFile2(join4(dir, entry.name));
         if (content) {
-          const pagePath = mapPageNameToPath3(pageName);
+          const pagePath = mapPageNameToPath2(pageName);
           pages.set(pagePath, content);
         }
       }),
@@ -3307,7 +3750,7 @@ var FileSystemPageProvider = class {
     const { writeFile: writeFile2 } = await import("fs/promises");
     const filePath = this.resolveFilePath(path2);
     const dir = dirname2(filePath);
-    if (!existsSync5(dir)) {
+    if (!existsSync4(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
     await writeFile2(filePath, content, "utf-8");
@@ -3316,7 +3759,7 @@ var FileSystemPageProvider = class {
     const { unlink } = await import("fs/promises");
     const filePath = this.resolveFilePath(path2);
     const rootDir = this.resolveRootDir(path2);
-    if (existsSync5(filePath)) {
+    if (existsSync4(filePath)) {
       await unlink(filePath);
       let dir = dirname2(filePath);
       while (dir !== rootDir) {
@@ -3336,7 +3779,13 @@ var FileSystemPageProvider = class {
   }
   async exists(path2) {
     const filePath = this.resolveFilePath(path2);
-    return existsSync5(filePath);
+    return existsSync4(filePath);
+  }
+  baseDir() {
+    return this.pagesDir;
+  }
+  extension() {
+    return ".json";
   }
 };
 
@@ -3369,4 +3818,4 @@ export {
   createServer,
   FileSystemPageProvider
 };
-//# sourceMappingURL=chunk-A725KYFK.js.map
+//# sourceMappingURL=chunk-R6XHAFBF.js.map