meno-core 1.0.53 → 1.1.0

package/dist/chunks/chunk-R6XHAFBF.js

@@ -1,3821 +0,0 @@
-import {
-  CachedConfigLoader,
-  colorService,
-  formatJsonErrorMessage,
-  generateFontCSS,
-  generateSSRHTML,
-  generateVariablesCSS,
-  loadBreakpointConfig,
-  loadComponentDirectory,
-  loadI18nConfig,
-  loadJSONFile,
-  loadProjectConfig,
-  mapPageNameToPath,
-  parseJSON,
-  variableService
-} from "./chunk-IGYR22T6.js";
-import {
-  configService
-} from "./chunk-2MHDV5BF.js";
-import {
-  bundleFile,
-  createRuntimeServer,
-  getPackageRoot,
-  getProjectRoot,
-  packagePaths,
-  projectPaths,
-  resolvePackagePath,
-  resolveProjectPath
-} from "./chunk-I7YIGZXT.js";
-import {
-  fileExists,
-  hashContent,
-  readTextFile,
-  serveFile,
-  writeFile
-} from "./chunk-WQFG7PAH.js";
-import {
-  extractStringValue,
-  rewriteComponentRefs
-} from "./chunk-QB2LNO4W.js";
-import {
-  buildSlugIndex,
-  isPathWithinRoot,
-  resolveSlugToPageId
-} from "./chunk-X754AHS5.js";
-import {
-  addItemUrls,
-  toFriendlyError
-} from "./chunk-JGWFTO6P.js";
-import {
-  parseLocaleFromPath
-} from "./chunk-AZQYF6KE.js";
-import {
-  API_ROUTES,
-  HMR_ROUTE,
-  MAX_PORT_ATTEMPTS,
-  SERVER_PORT,
-  WEBSOCKET_STATES,
-  init_constants
-} from "./chunk-YBLHKYFF.js";
-
-// lib/server/pageCache.ts
-var PageCache = class {
-  cache = /* @__PURE__ */ new Map();
-  /**
-   * Store page content and line map in cache
-   */
-  set(path2, content, lineMap) {
-    this.cache.set(path2, { content, lineMap });
-  }
-  /**
-   * Get cached page data
-   */
-  get(path2) {
-    return this.cache.get(path2);
-  }
-  /**
-   * Get page content from cache
-   */
-  getContent(path2) {
-    return this.cache.get(path2)?.content;
-  }
-  /**
-   * Get line map from cache
-   */
-  getLineMap(path2) {
-    return this.cache.get(path2)?.lineMap;
-  }
-  /**
-   * Get line range for a specific element path
-   */
-  getLineRange(pagePath, elementPath) {
-    return this.cache.get(pagePath)?.lineMap.get(elementPath);
-  }
-  /**
-   * Delete page from cache
-   */
-  delete(path2) {
-    this.cache.delete(path2);
-  }
-  /**
-   * Check if page exists in cache
-   */
-  has(path2) {
-    return this.cache.has(path2);
-  }
-  /**
-   * Get all page paths
-   */
-  keys() {
-    return Array.from(this.cache.keys());
-  }
-  /**
-   * Clear all cached pages
-   */
-  clear() {
-    this.cache.clear();
-  }
-  /**
-   * Get cache size
-   */
-  size() {
-    return this.cache.size;
-  }
-  /**
-   * Get all pages content as object (without line maps)
-   */
-  toObject() {
-    const obj = {};
-    this.cache.forEach((value, key) => {
-      obj[key] = value.content;
-    });
-    return obj;
-  }
-};
-
-// lib/server/websocketManager.ts
-init_constants();
-var WebSocketManager = class {
-  clients = /* @__PURE__ */ new Set();
-  /**
-   * Add a WebSocket client
-   */
-  addClient(ws) {
-    this.clients.add(ws);
-  }
-  /**
-   * Remove a WebSocket client
-   */
-  removeClient(ws) {
-    this.clients.delete(ws);
-  }
-  /**
-   * Broadcast message to all connected clients
-   */
-  broadcast(message) {
-    const messageStr = typeof message === "string" ? message : JSON.stringify(message);
-    for (const ws of this.clients) {
-      if (ws.readyState === WEBSOCKET_STATES.OPEN) {
-        ws.send(messageStr);
-      }
-    }
-  }
-  /**
-   * Broadcast update notification
-   */
-  broadcastUpdate(path2) {
-    this.broadcast({
-      type: "hmr:update",
-      path: path2 || "all"
-    });
-  }
-  /**
-   * Broadcast colors/themes update notification
-   */
-  broadcastColorsUpdate() {
-    this.broadcast({
-      type: "hmr:colors-update"
-    });
-  }
-  /**
-   * Broadcast variables update notification
-   */
-  broadcastVariablesUpdate() {
-    this.broadcast({
-      type: "hmr:variables-update"
-    });
-  }
-  /**
-   * Broadcast fonts update notification
-   */
-  broadcastFontsUpdate() {
-    this.broadcast({
-      type: "hmr:fonts-update"
-    });
-  }
-  /**
-   * Broadcast libraries update notification
-   */
-  broadcastLibrariesUpdate() {
-    this.broadcast({
-      type: "hmr:libraries-update"
-    });
-  }
-  /**
-   * Broadcast enums update notification
-   */
-  broadcastEnumsUpdate() {
-    this.broadcast({
-      type: "hmr:enums-update"
-    });
-  }
-  /**
-   * Broadcast CMS content update notification
-   */
-  broadcastCMSUpdate(collection) {
-    this.broadcast({
-      type: "hmr:cms-update",
-      collection
-    });
-  }
-  /**
-   * Broadcast CMS collections-list update notification.
-   * Emitted when a template file is added, removed, or its schema changes —
-   * tells connected clients to re-fetch the collections list.
-   */
-  broadcastCollectionsUpdate() {
-    this.broadcast({
-      type: "hmr:cms-collections-update"
-    });
-  }
-  /**
-   * Broadcast project.config.json update notification.
-   * Emitted when project.config.json changes (e.g. an AI tool adds a new
-   * locale) — tells connected clients to re-fetch config-derived state
-   * such as the i18n locale list.
-   */
-  broadcastConfigUpdate() {
-    this.broadcast({
-      type: "hmr:config-update"
-    });
-  }
-  /**
-   * Get number of connected clients
-   */
-  getClientCount() {
-    return this.clients.size;
-  }
-  /**
-   * Clear all clients
-   */
-  clear() {
-    this.clients.clear();
-  }
-  /**
-   * Get all clients
-   */
-  getClients() {
-    return new Set(this.clients);
-  }
-  /**
-   * Check if any clients are connected
-   */
-  hasClients() {
-    return this.clients.size > 0;
-  }
-};
-
-// lib/server/utils/jsonLineMapper.ts
-function buildLineMap(jsonText) {
-  const lineMap = /* @__PURE__ */ new Map();
-  const lines = jsonText.split("\n");
-  const charToLine = [];
-  let currentLine = 1;
-  for (let i = 0; i < jsonText.length; i++) {
-    charToLine[i] = currentLine;
-    if (jsonText[i] === "\n") {
-      currentLine++;
-    }
-  }
-  let pos = 0;
-  function skipWhitespace() {
-    while (pos < jsonText.length && /\s/.test(jsonText[pos])) {
-      pos++;
-    }
-  }
-  function parseString() {
-    if (jsonText[pos] !== '"') return "";
-    pos++;
-    let result = "";
-    while (pos < jsonText.length && jsonText[pos] !== '"') {
-      if (jsonText[pos] === "\\") {
-        pos++;
-        if (pos < jsonText.length) {
-          result += jsonText[pos];
-          pos++;
-        }
-      } else {
-        result += jsonText[pos];
-        pos++;
-      }
-    }
-    pos++;
-    return result;
-  }
-  function parseNumber() {
-    while (pos < jsonText.length && /[\d.eE\-+]/.test(jsonText[pos])) {
-      pos++;
-    }
-  }
-  function parseValue(path2, trackChildren) {
-    skipWhitespace();
-    const startPos = pos;
-    if (jsonText[pos] === "{") {
-      parseObject(path2, trackChildren);
-    } else if (jsonText[pos] === "[") {
-      parseArray(path2, trackChildren);
-    } else if (jsonText[pos] === '"') {
-      parseString();
-    } else if (jsonText[pos] === "t") {
-      pos += 4;
-    } else if (jsonText[pos] === "f") {
-      pos += 5;
-    } else if (jsonText[pos] === "n") {
-      pos += 4;
-    } else {
-      parseNumber();
-    }
-    return { start: startPos, end: pos };
-  }
-  function recordTrackedRoot(path2) {
-    const { start, end } = parseValue(path2, true);
-    lineMap.set("", {
-      startLine: charToLine[start],
-      endLine: charToLine[end - 1] || charToLine[start]
-    });
-  }
-  function parseObject(path2, trackChildren) {
-    pos++;
-    skipWhitespace();
-    while (pos < jsonText.length && jsonText[pos] !== "}") {
-      skipWhitespace();
-      const key = parseString();
-      skipWhitespace();
-      pos++;
-      skipWhitespace();
-      if (key === "root" && path2.length === 0) {
-        recordTrackedRoot(path2);
-      } else if (key === "component" && path2.length === 0) {
-        parseComponentWrapper(path2);
-      } else if (key === "children" && trackChildren) {
-        parseValue(path2, true);
-      } else {
-        parseValue(path2, false);
-      }
-      skipWhitespace();
-      if (jsonText[pos] === ",") pos++;
-      skipWhitespace();
-    }
-    pos++;
-  }
-  function parseComponentWrapper(path2) {
-    if (jsonText[pos] !== "{") {
-      parseValue(path2, false);
-      return;
-    }
-    pos++;
-    skipWhitespace();
-    while (pos < jsonText.length && jsonText[pos] !== "}") {
-      skipWhitespace();
-      const key = parseString();
-      skipWhitespace();
-      pos++;
-      skipWhitespace();
-      if (key === "structure") {
-        recordTrackedRoot(path2);
-      } else {
-        parseValue(path2, false);
-      }
-      skipWhitespace();
-      if (jsonText[pos] === ",") pos++;
-      skipWhitespace();
-    }
-    pos++;
-  }
-  function parseArray(path2, trackChildren) {
-    pos++;
-    skipWhitespace();
-    let index = 0;
-    while (pos < jsonText.length && jsonText[pos] !== "]") {
-      const childPath = [...path2, index];
-      const { start, end } = parseValue(childPath, trackChildren);
-      if (trackChildren) {
-        const pathStr = childPath.join(",");
-        lineMap.set(pathStr, {
-          startLine: charToLine[start],
-          endLine: charToLine[end - 1] || charToLine[start]
-        });
-      }
-      index++;
-      skipWhitespace();
-      if (jsonText[pos] === ",") pos++;
-      skipWhitespace();
-    }
-    pos++;
-  }
-  try {
-    skipWhitespace();
-    parseValue([], false);
-  } catch (e) {
-    console.error("Failed to build line map:", e);
-  }
-  return lineMap;
-}
-function lineMapToObject(lineMap) {
-  const obj = {};
-  lineMap.forEach((value, key) => {
-    obj[key] = value;
-  });
-  return obj;
-}
-
-// lib/server/services/pageService.ts
-import { existsSync, readdirSync, mkdirSync, rmdirSync } from "fs";
-import { join } from "path";
-var PageService = class {
-  /**
-   * Creates a new PageService instance
-   *
-   * @param pageCache - PageCache instance to use for caching pages
-   * @param provider - Optional PageProvider for loading pages (enables DI for testing/CMS)
-   */
-  constructor(pageCache, provider) {
-    this.pageCache = pageCache;
-    this.provider = provider;
-  }
-  /**
-   * Set the page provider
-   * Allows setting provider after construction for backward compatibility
-   *
-   * @param provider - PageProvider implementation
-   */
-  setProvider(provider) {
-    this.provider = provider;
-  }
-  /**
-   * Load all pages from the data provider
-   *
-   * Uses the provider to load pages. If no provider is set, does nothing.
-   * Pages are cached in memory for fast access.
-   *
-   * @returns Promise that resolves when all pages are loaded
-   *
-   * @example
-   * ```typescript
-   * await pageService.loadAllPages();
-   * const paths = pageService.getAllPagePaths();
-   * ```
-   */
-  async loadAllPages() {
-    if (!this.provider) {
-      return;
-    }
-    const pages = await this.provider.loadAll();
-    for (const [path2, content] of pages) {
-      const lineMap = buildLineMap(content);
-      this.pageCache.set(path2, content, lineMap);
-    }
-  }
-  /**
-   * Get page content from cache
-   *
-   * @param path - Page path (e.g., "/" or "/about")
-   * @returns Raw JSON string content, or undefined if page not found
-   *
-   * @example
-   * ```typescript
-   * const content = pageService.getPage('/');
-   * if (content) {
-   *   const data = JSON.parse(content);
-   * }
-   * ```
-   */
-  getPage(path2) {
-    return this.pageCache.getContent(path2);
-  }
-  /**
-   * Get parsed page data
-   *
-   * Retrieves page content from cache and parses it as JSON. Returns null if
-   * the page doesn't exist or if parsing fails.
-   *
-   * @param path - Page path (e.g., "/" or "/about")
-   * @returns Parsed JSONPage object, or null if not found or invalid
-   *
-   * @example
-   * ```typescript
-   * const pageData = pageService.getPageData('/');
-   * if (pageData) {
-   *   console.log(pageData.meta.title);
-   * }
-   * ```
-   */
-  getPageData(path2) {
-    const content = this.pageCache.getContent(path2);
-    if (!content) {
-      return null;
-    }
-    try {
-      return parseJSON(content);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Save page content
-   *
-   * Saves page data via the provider and updates the cache. The page path
-   * is converted to a filename (e.g., "/" -> "index.json", "/about" -> "about.json").
-   *
-   * @param path - Page path (e.g., "/" or "/about")
-   * @param data - JSONPage object to save
-   * @returns Promise that resolves when the page is saved
-   *
-   * @throws {Error} If provider is not set or file write fails
-   *
-   * @example
-   * ```typescript
-   * await pageService.savePage('/', {
-   *   meta: { title: 'Home' },
-   *   root: { type: 'node', tag: 'div', children: [] }
-   * });
-   * ```
-   */
-  async savePage(path2, data) {
-    if (!this.provider) {
-      throw new Error("PageProvider not set");
-    }
-    const { _lineMap, ...dataToSave } = data;
-    const content = JSON.stringify(dataToSave, null, 2);
-    await this.provider.save(path2, content);
-    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
-   *
-   * Removes a page from the in-memory cache. If provider is set,
-   * also deletes from the underlying storage.
-   *
-   * @param path - Page path to delete
-   * @param deleteFromStorage - If true and provider is set, also delete from storage
-   *
-   * @example
-   * ```typescript
-   * pageService.deletePage('/old-page');
-   * // Or with storage deletion:
-   * await pageService.deletePage('/old-page', true);
-   * ```
-   */
-  async deletePage(path2, deleteFromStorage = false) {
-    this.pageCache.delete(path2);
-    if (deleteFromStorage && this.provider) {
-      await this.provider.delete(path2);
-    }
-  }
-  /**
-   * Get all page paths
-   *
-   * Returns an array of all page paths currently in the cache.
-   *
-   * @returns Array of page paths (e.g., ["/", "/about", "/contact"])
-   *
-   * @example
-   * ```typescript
-   * const paths = pageService.getAllPagePaths();
-   * console.log(`Loaded ${paths.length} pages`);
-   * ```
-   */
-  getAllPagePaths() {
-    return this.pageCache.keys();
-  }
-  /**
-   * Get all pages with their info (including draft status)
-   *
-   * Returns an array of page info objects including path and draft status.
-   *
-   * @returns Array of page info objects
-   *
-   * @example
-   * ```typescript
-   * const pages = pageService.getAllPagesWithInfo();
-   * // [{ path: "/", isDraft: false }, { path: "/about", isDraft: true }]
-   * ```
-   */
-  getAllPagesWithInfo() {
-    const paths = this.pageCache.keys().filter((p) => !p.startsWith("/_sketch/"));
-    return paths.map((path2) => {
-      const pageData = this.getPageData(path2);
-      const pathWithoutSlash = path2 === "/" ? "index" : path2.substring(1);
-      const slashIndex = pathWithoutSlash.lastIndexOf("/");
-      const folder = slashIndex > 0 ? pathWithoutSlash.substring(0, slashIndex) : void 0;
-      return {
-        path: path2,
-        isDraft: pageData?.meta?.draft === true,
-        ...folder ? { folder } : {}
-      };
-    });
-  }
-  /**
-   * Get line map for a page
-   *
-   * Returns the line number mapping for elements in the page JSON.
-   *
-   * @param path - Page path (e.g., "/" or "/about")
-   * @returns LineMap object or undefined if page not found
-   */
-  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
-   *
-   * Scans the pages directory for subdirectories.
-   *
-   * @returns Sorted array of folder names
-   */
-  getAllFolders() {
-    const pagesDir = this.pagesBaseDir();
-    if (!existsSync(pagesDir)) {
-      return [];
-    }
-    const collectFolders = (dir, prefix) => {
-      try {
-        const entries = readdirSync(dir, { withFileTypes: true });
-        const result = [];
-        for (const entry of entries) {
-          if (!entry.isDirectory()) continue;
-          const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-          result.push(relativePath);
-          result.push(...collectFolders(join(dir, entry.name), relativePath));
-        }
-        return result;
-      } catch {
-        return [];
-      }
-    };
-    return collectFolders(pagesDir, "").sort();
-  }
-  /**
-   * Create a page folder
-   *
-   * Creates an empty folder in the pages directory.
-   *
-   * @param folderName - Name of the folder to create
-   * @throws {Error} If folder name is invalid or already exists
-   */
-  async createFolder(folderName) {
-    if (!folderName || folderName.trim() === "") {
-      throw new Error("Folder name cannot be empty");
-    }
-    const trimmed = folderName.trim();
-    const segments = trimmed.split("/");
-    const segmentRegex = /^[a-z0-9][a-z0-9-_]*$/;
-    for (const segment of segments) {
-      if (!segment) throw new Error("Folder path cannot have empty segments");
-      if (!segmentRegex.test(segment)) {
-        throw new Error("Each folder segment can only contain lowercase letters, numbers, dashes, and underscores");
-      }
-    }
-    const pagesDir = this.pagesBaseDir();
-    const folderPath = join(pagesDir, trimmed);
-    if (existsSync(folderPath)) {
-      throw new Error("Folder already exists");
-    }
-    mkdirSync(folderPath, { recursive: true });
-  }
-  /**
-   * Move a page to a different folder
-   *
-   * Moves a page file from its current location to the target folder.
-   * If folder is empty string, moves to root pages directory.
-   *
-   * @param pagePath - Current page path (e.g., "/blog/post" or "/about")
-   * @param newFolder - Target folder name (empty string for root)
-   */
-  async movePage(pagePath, newFolder) {
-    const { rename } = await import("fs/promises");
-    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}${ext}`);
-    const targetFile = newFolder ? join(pagesDir, newFolder, `${baseName}${ext}`) : join(pagesDir, `${baseName}${ext}`);
-    if (newFolder) {
-      const targetDir = join(pagesDir, newFolder);
-      if (!existsSync(targetDir)) {
-        mkdirSync(targetDir, { recursive: true });
-      }
-    }
-    if (!existsSync(sourceFile)) {
-      throw new Error(`Page not found: ${pagePath}`);
-    }
-    await rename(sourceFile, targetFile);
-    const content = this.pageCache.getContent(pagePath);
-    if (content) {
-      this.pageCache.delete(pagePath);
-      const newPageName = newFolder ? `${newFolder}/${baseName}` : baseName;
-      const newPath = newPageName === "index" ? "/" : `/${newPageName}`;
-      const lineMap = buildLineMap(content);
-      this.pageCache.set(newPath, content, lineMap);
-    }
-    const sourceDir = slashIndex >= 0 ? join(pagesDir, pageName.substring(0, slashIndex)) : null;
-    if (sourceDir && sourceDir !== pagesDir) {
-      try {
-        const remaining = readdirSync(sourceDir);
-        if (remaining.length === 0) {
-          rmdirSync(sourceDir);
-        }
-      } catch {
-      }
-    }
-  }
-  /**
-   * 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
-   *
-   * Extracts slug translations from all pages' meta.slugs fields.
-   * Returns a list of { pageId, slugs } objects for locale-aware routing.
-   *
-   * @returns Array of SlugMap objects with pageId and translated slugs
-   *
-   * @example
-   * ```typescript
-   * const mappings = pageService.getSlugMappings();
-   * // [{ pageId: "about", slugs: { "en": "about", "pl": "o-nas" } }]
-   * ```
-   */
-  getSlugMappings() {
-    const mappings = [];
-    const paths = this.pageCache.keys();
-    for (const path2 of paths) {
-      const pageData = this.getPageData(path2);
-      if (pageData?.meta?.slugs) {
-        const pageId = path2 === "/" ? "index" : path2.substring(1);
-        mappings.push({
-          pageId,
-          slugs: pageData.meta.slugs
-        });
-      } else {
-        const pageId = path2 === "/" ? "index" : path2.substring(1);
-        const defaultSlug = path2 === "/" ? "" : path2.substring(1);
-        mappings.push({
-          pageId,
-          slugs: { _default: defaultSlug }
-        });
-      }
-    }
-    return mappings;
-  }
-};
-
-// lib/server/services/componentService.ts
-import { join as join2 } from "path";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, rmdirSync as rmdirSync2 } from "fs";
-var ComponentService = class {
-  components = /* @__PURE__ */ new Map();
-  componentCategories = /* @__PURE__ */ new Map();
-  fs;
-  loader;
-  writer;
-  loadErrors = /* @__PURE__ */ new Map();
-  loadWarnings = [];
-  /**
-   * Creates a new ComponentService instance
-   *
-   * @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 (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
-   *
-   * Scans the ./components directory recursively and loads all component definitions.
-   * Subdirectories are treated as category folders. Clears existing components before loading.
-   * Components are loaded from .json files, and associated .js and .css files are
-   * automatically loaded if they exist.
-   *
-   * @returns Promise that resolves when all components are loaded
-   *
-   * @example
-   * ```typescript
-   * await componentService.loadAllComponents();
-   * const count = Object.keys(componentService.getAllComponents()).length;
-   * ```
-   */
-  async loadAllComponents() {
-    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;
-      nextWarnings = result.warnings;
-      for (const error of result.errors) {
-        nextErrors.set(error.componentName, error);
-      }
-    }
-    loadedComponents.forEach((value, key) => {
-      const componentWithCategory = value;
-      const category = componentWithCategory._category;
-      nextCategories.set(key, category);
-      const { _category, _relativePath, ...cleanDef } = componentWithCategory;
-      nextComponents.set(key, cleanDef);
-    });
-    this.components = nextComponents;
-    this.componentCategories = nextCategories;
-    this.loadErrors = nextErrors;
-    this.loadWarnings = nextWarnings;
-  }
-  /**
-   * Get component by name
-   * 
-   * @param name - Component name (without .json extension)
-   * @returns ComponentDefinition if found, undefined otherwise
-   * 
-   * @example
-   * ```typescript
-   * const button = componentService.getComponent('Button');
-   * if (button) {
-   *   console.log(button.component.interface);
-   * }
-   * ```
-   */
-  getComponent(name) {
-    return this.components.get(name);
-  }
-  /**
-   * Check if component exists
-   * 
-   * @param name - Component name to check
-   * @returns True if component exists in cache, false otherwise
-   * 
-   * @example
-   * ```typescript
-   * if (componentService.hasComponent('Button')) {
-   *   // Component is available
-   * }
-   * ```
-   */
-  hasComponent(name) {
-    return this.components.has(name);
-  }
-  /**
-   * Get all components as a Record
-   *
-   * Returns all loaded components as a plain object for easy iteration
-   * or serialization.
-   *
-   * @returns Record mapping component names to ComponentDefinition objects
-   *
-   * @example
-   * ```typescript
-   * const allComponents = componentService.getAllComponents();
-   * Object.keys(allComponents).forEach(name => {
-   *   console.log(`Component: ${name}`);
-   * });
-   * ```
-   */
-  getAllComponents() {
-    const record = {};
-    this.components.forEach((value, key) => {
-      record[key] = value;
-    });
-    return record;
-  }
-  /**
-   * Get all components with their category information
-   *
-   * Returns all loaded components with category metadata derived from folder structure.
-   *
-   * @returns Record mapping component names to ComponentInfo objects (definition + category)
-   *
-   * @example
-   * ```typescript
-   * const components = componentService.getAllComponentsWithCategories();
-   * Object.entries(components).forEach(([name, info]) => {
-   *   console.log(`${name}: category=${info.category || 'uncategorized'}`);
-   * });
-   * ```
-   */
-  getAllComponentsWithCategories() {
-    const record = {};
-    this.components.forEach((value, key) => {
-      record[key] = {
-        definition: value,
-        category: this.componentCategories.get(key)
-      };
-    });
-    return record;
-  }
-  /**
-   * Get category for a component
-   *
-   * @param name - Component name
-   * @returns Category string if component is in a category folder, undefined otherwise
-   */
-  getComponentCategory(name) {
-    return this.componentCategories.get(name);
-  }
-  /**
-   * Get load errors keyed by component name
-   */
-  getLoadErrors() {
-    return this.loadErrors;
-  }
-  /**
-   * Get load warnings
-   */
-  getLoadWarnings() {
-    return this.loadWarnings;
-  }
-  /**
-   * Get all load diagnostics
-   */
-  getLoadDiagnostics() {
-    return {
-      errors: Array.from(this.loadErrors.values()),
-      warnings: this.loadWarnings
-    };
-  }
-  /**
-   * Validate that a component has a valid structure
-   * 
-   * @param componentDef - ComponentDefinition to validate
-   * @returns true if component has valid structure, false otherwise
-   * 
-   * @example
-   * ```typescript
-   * const component = componentService.getComponent('Button');
-   * if (component && componentService.validateComponentStructure(component)) {
-   *   // Component has valid structure
-   * }
-   * ```
-   */
-  validateComponentStructure(componentDef) {
-    if (!componentDef) {
-      return false;
-    }
-    const component = componentDef.component;
-    if (!component || typeof component !== "object") {
-      return false;
-    }
-    const structure = component.structure;
-    if (!structure) {
-      return false;
-    }
-    if (typeof structure !== "object" || structure === null || Array.isArray(structure)) {
-      return false;
-    }
-    if (!("type" in structure) || typeof structure.type !== "string") {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Get the directory path for a component based on its category
-   * @internal
-   */
-  getComponentDir(name, category) {
-    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
-   *
-   * Loads the JavaScript code for a component from its .js file.
-   * Returns null if the file doesn't exist.
-   *
-   * @param name - Component name (without .js extension)
-   * @returns JavaScript code as string, or null if file doesn't exist
-   *
-   * @example
-   * ```typescript
-   * const js = await componentService.getComponentJavaScript('Button');
-   * if (js) {
-   *   console.log('Component has JavaScript');
-   * }
-   * ```
-   */
-  async getComponentJavaScript(name) {
-    const componentDir = this.getComponentDir(name);
-    const jsFilePath = join2(componentDir, `${name}.js`);
-    try {
-      if (await fileExists(jsFilePath)) {
-        return await readTextFile(jsFilePath);
-      }
-      return null;
-    } catch (error) {
-      return null;
-    }
-  }
-  /**
-   * Save component definition
-   *
-   * Saves component definition to a .json file and updates the cache.
-   * The javascript field is automatically removed from the saved data
-   * (JavaScript should only be in .js files).
-   *
-   * If category is provided, the component is saved to the category subfolder.
-   * If category is undefined and component exists, it stays in its current location.
-   * If category is empty string '', component is saved to root (uncategorized).
-   *
-   * @param name - Component name (without .json extension)
-   * @param data - ComponentDefinition object to save
-   * @param category - Optional category folder name (empty string for root/uncategorized)
-   * @returns Promise that resolves when the component is saved
-   *
-   * @throws {Error} If file write fails
-   *
-   * @example
-   * ```typescript
-   * // Save to root (uncategorized)
-   * await componentService.saveComponent('Button', buttonDef);
-   *
-   * // Save to 'ui' category folder
-   * await componentService.saveComponent('Card', cardDef, 'ui');
-   * ```
-   */
-  async saveComponent(name, data, category) {
-    const dataWithoutJS = JSON.parse(JSON.stringify(data));
-    if (dataWithoutJS?.component?.javascript !== void 0) {
-      delete dataWithoutJS.component.javascript;
-    }
-    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");
-    }
-    this.components.set(name, dataWithoutJS);
-    this.componentCategories.set(name, targetCategory);
-  }
-  /**
-   * Save component JavaScript to .js file
-   *
-   * Saves JavaScript code to a component's .js file and reloads the component
-   * to update the in-memory cache with the new JavaScript.
-   *
-   * @param name - Component name (without .js extension)
-   * @param javascript - JavaScript code to save
-   * @returns Promise that resolves when the JavaScript is saved
-   *
-   * @throws {Error} If file write fails
-   *
-   * @example
-   * ```typescript
-   * await componentService.saveComponentJavaScript('Button', 'console.log("clicked");');
-   * ```
-   */
-  async saveComponentJavaScript(name, javascript) {
-    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`);
-    const componentData = await loadJSONFile(componentPath);
-    if (componentData) {
-      const parsed = parseJSON(componentData);
-      try {
-        if (await fileExists(jsFilePath)) {
-          const jsContent = await readTextFile(jsFilePath);
-          if (!parsed.component) {
-            parsed.component = {};
-          }
-          parsed.component.javascript = jsContent;
-        }
-      } catch (error) {
-      }
-      this.components.set(name, parsed);
-    }
-  }
-  /**
-   * Save component CSS to .css file
-   *
-   * Saves CSS code to a component's .css file and reloads the component
-   * to update the in-memory cache with the new CSS.
-   *
-   * @param name - Component name (without .css extension)
-   * @param css - CSS code to save
-   * @returns Promise that resolves when the CSS is saved
-   *
-   * @throws {Error} If file write fails
-   *
-   * @example
-   * ```typescript
-   * await componentService.saveComponentCSS('Button', '.button { color: blue; }');
-   * ```
-   */
-  async saveComponentCSS(name, css) {
-    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`);
-    const componentData = await loadJSONFile(componentPath);
-    if (componentData) {
-      const parsed = parseJSON(componentData);
-      try {
-        if (await fileExists(cssFilePath)) {
-          const cssContent = await readTextFile(cssFilePath);
-          if (!parsed.component) {
-            parsed.component = {};
-          }
-          parsed.component.css = cssContent;
-        }
-      } catch (error) {
-      }
-      this.components.set(name, parsed);
-    }
-  }
-  /**
-   * Get all component folders (including empty ones)
-   *
-   * Scans the components directory for subdirectories.
-   * Returns all folder names, whether they contain components or not.
-   *
-   * @returns Array of folder names
-   *
-   * @example
-   * ```typescript
-   * const folders = componentService.getAllFolders();
-   * // ['ui', 'layout', 'content']
-   * ```
-   */
-  getAllFolders() {
-    const componentsDir = this.componentsBaseDir();
-    if (!existsSync2(componentsDir)) {
-      return [];
-    }
-    try {
-      const entries = readdirSync2(componentsDir, { withFileTypes: true });
-      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
-    } catch {
-      return [];
-    }
-  }
-  /**
-   * Create a component folder
-   *
-   * Creates an empty folder in the components directory.
-   * Useful for pre-creating category folders before moving components.
-   *
-   * @param folderName - Name of the folder to create
-   * @returns Promise that resolves when folder is created
-   *
-   * @throws {Error} If folder creation fails
-   *
-   * @example
-   * ```typescript
-   * await componentService.createFolder('ui');
-   * ```
-   */
-  async createFolder(folderName) {
-    if (!folderName || folderName.trim() === "") {
-      throw new Error("Folder name cannot be empty");
-    }
-    const sanitized = folderName.trim().toLowerCase().replace(/[^a-z0-9-_]/g, "-");
-    if (sanitized !== folderName.trim()) {
-      throw new Error("Folder name can only contain lowercase letters, numbers, dashes, and underscores");
-    }
-    const componentsDir = this.componentsBaseDir();
-    const folderPath = join2(componentsDir, folderName);
-    if (existsSync2(folderPath)) {
-      throw new Error("Folder already exists");
-    }
-    mkdirSync2(folderPath, { recursive: true });
-  }
-  /**
-   * Move component to a different category folder
-   *
-   * Moves all component files (.json, .js, .css) from current location to new category folder.
-   * If newCategory is empty string or undefined, moves to root (uncategorized).
-   *
-   * @param name - Component name
-   * @param newCategory - Target category folder (empty string or undefined for root)
-   * @returns Promise that resolves when move is complete
-   *
-   * @throws {Error} If component doesn't exist or move fails
-   *
-   * @example
-   * ```typescript
-   * // Move Button from root to 'ui' category
-   * await componentService.moveComponent('Button', 'ui');
-   *
-   * // Move Card from 'ui' to root (uncategorized)
-   * await componentService.moveComponent('Card', '');
-   * ```
-   */
-  async moveComponent(name, newCategory) {
-    const currentCategory = this.componentCategories.get(name);
-    const targetCategory = newCategory || void 0;
-    if (currentCategory === targetCategory) {
-      return;
-    }
-    const componentsDir = this.componentsBaseDir();
-    const sourceDir = currentCategory ? join2(componentsDir, currentCategory) : componentsDir;
-    const targetDir = targetCategory ? join2(componentsDir, targetCategory) : componentsDir;
-    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);
-    if (currentCategory) {
-      try {
-        const remaining = readdirSync2(sourceDir);
-        if (remaining.length === 0) {
-          rmdirSync2(sourceDir);
-        }
-      } catch {
-      }
-    }
-  }
-  /**
-   * 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
-var EnumService = class extends CachedConfigLoader {
-  /**
-   * Load enums configuration from enums.json
-   */
-  async loadConfig() {
-    return this.load();
-  }
-  async performLoad() {
-    const [enumsContent, configContent] = await Promise.all([
-      loadJSONFile(projectPaths.enums()).catch(() => null),
-      loadJSONFile(projectPaths.config()).catch(() => null)
-    ]);
-    if (enumsContent) {
-      try {
-        const data = parseJSON(enumsContent);
-        if (data && typeof data === "object" && !Array.isArray(data)) {
-          return this.validateEnums(data);
-        }
-      } catch (error) {
-        console.warn("Failed to parse enums.json:", error);
-      }
-    }
-    if (configContent) {
-      try {
-        const configData = parseJSON(configContent);
-        if (configData && typeof configData === "object" && "enums" in configData) {
-          const enums = configData.enums;
-          if (enums && typeof enums === "object" && !Array.isArray(enums)) {
-            return this.validateEnums(enums);
-          }
-        }
-      } catch {
-      }
-    }
-    return this.getDefaultConfig();
-  }
-  getDefaultConfig() {
-    return {};
-  }
-  /**
-   * Validate that all values are string arrays
-   */
-  validateEnums(data) {
-    const result = {};
-    for (const [key, value] of Object.entries(data)) {
-      if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
-        result[key] = value;
-      }
-    }
-    return result;
-  }
-  /**
-   * Get config with status info (for editor UI)
-   */
-  async getConfigWithStatus() {
-    const filePath = projectPaths.enums();
-    try {
-      const content = await loadJSONFile(filePath);
-      if (!content) {
-        const fallbackConfig = await this.performLoad();
-        const hasFallback = Object.keys(fallbackConfig).length > 0;
-        return {
-          status: hasFallback ? "valid" : "missing",
-          config: fallbackConfig,
-          filePath
-        };
-      }
-      const data = parseJSON(content);
-      if (data && typeof data === "object" && !Array.isArray(data)) {
-        return { status: "valid", config: this.validateEnums(data), filePath };
-      }
-      return { status: "invalid", config: this.getDefaultConfig(), error: "Invalid structure: expected Record<string, string[]>", filePath };
-    } catch (error) {
-      return {
-        status: "invalid",
-        config: this.getDefaultConfig(),
-        error: error instanceof Error ? error.message : "Parse error",
-        filePath
-      };
-    }
-  }
-  /**
-   * Save enums configuration to enums.json
-   */
-  async saveConfig(config) {
-    const enumsPath = projectPaths.enums();
-    const content = JSON.stringify(config, null, 2);
-    await writeFile(enumsPath, content);
-    this.setCache(config);
-  }
-};
-var enumService = new EnumService();
-
-// lib/server/fileWatcher.ts
-import { watch, existsSync as existsSync3 } from "fs";
-import { basename, dirname, join as join3 } from "path";
-function attachWhenDirExists(dirPath, attach, setWatcher) {
-  if (existsSync3(dirPath)) {
-    setWatcher(attach());
-    return;
-  }
-  const parentDir = dirname(dirPath);
-  const targetName = basename(dirPath);
-  if (!existsSync3(parentDir)) {
-    return;
-  }
-  let parentWatcher = null;
-  parentWatcher = watch(parentDir, (_event, filename) => {
-    if (filename !== targetName) return;
-    if (!existsSync3(dirPath)) return;
-    parentWatcher?.close();
-    parentWatcher = null;
-    setWatcher(attach());
-  });
-  setWatcher(parentWatcher);
-}
-var FileWatcher = class {
-  constructor(callbacks) {
-    this.callbacks = callbacks;
-  }
-  componentsWatcher = null;
-  pagesWatcher = null;
-  templatesWatcher = null;
-  colorsWatcher = null;
-  variablesWatcher = null;
-  enumsWatcher = null;
-  cmsWatcher = null;
-  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
-   */
-  watchComponents(dirPath = projectPaths.components()) {
-    if (!existsSync3(dirPath)) {
-      return;
-    }
-    this.componentsWatcher = watch(
-      dirPath,
-      { recursive: true },
-      async (event, filename) => {
-        if (filename && (filename.endsWith(".json") || filename.endsWith(".js") || filename.endsWith(".css"))) {
-          const fileType = filename.endsWith(".js") ? "JavaScript" : filename.endsWith(".css") ? "CSS" : "component";
-          if (this.callbacks.onComponentChange) {
-            await this.callbacks.onComponentChange();
-          }
-        }
-      }
-    );
-  }
-  /**
-   * Start watching pages directory
-   */
-  watchPages(dirPath = projectPaths.pages()) {
-    if (!existsSync3(dirPath)) {
-      return;
-    }
-    this.pagesWatcher = watch(
-      dirPath,
-      { recursive: true },
-      async (event, filename) => {
-        if (filename && filename.endsWith(".json")) {
-          const pageName = filename.replace(".json", "");
-          const pagePath = mapPageNameToPath(pageName);
-          if (this.callbacks.onPageChange) {
-            await this.callbacks.onPageChange(pagePath);
-          }
-        }
-      }
-    );
-  }
-  /**
-   * Start watching root templates directory for CMS template changes.
-   * Falls back to a deferred-attach watcher on the project root when
-   * `templates/` doesn't exist yet (blank projects, projects that have never
-   * had a CMS collection).
-   */
-  watchTemplates(dirPath = projectPaths.templates()) {
-    attachWhenDirExists(
-      dirPath,
-      () => watch(
-        dirPath,
-        { recursive: true },
-        async (event, filename) => {
-          if (filename && filename.endsWith(".json")) {
-            const pageName = `templates/${filename.replace(".json", "")}`;
-            const pagePath = mapPageNameToPath(pageName);
-            if (this.callbacks.onPageChange) {
-              await this.callbacks.onPageChange(pagePath);
-            }
-          }
-        }
-      ),
-      (w) => {
-        this.templatesWatcher = w;
-      }
-    );
-  }
-  /**
-   * Start watching colors.json file
-   */
-  watchColors(filePath = projectPaths.colors()) {
-    if (!existsSync3(filePath)) {
-      return;
-    }
-    const dirPath = getProjectRoot();
-    this.colorsWatcher = watch(
-      dirPath,
-      { recursive: false },
-      async (event, filename) => {
-        if (filename === "colors.json" && this.callbacks.onColorsChange) {
-          await this.callbacks.onColorsChange();
-        }
-      }
-    );
-  }
-  /**
-   * Start watching variables.json file
-   */
-  watchVariables() {
-    const dirPath = getProjectRoot();
-    this.variablesWatcher = watch(
-      dirPath,
-      { recursive: false },
-      async (event, filename) => {
-        if (filename === "variables.json" && this.callbacks.onVariablesChange) {
-          await this.callbacks.onVariablesChange();
-        }
-      }
-    );
-  }
-  /**
-   * Start watching enums.json file
-   */
-  watchEnums() {
-    const dirPath = getProjectRoot();
-    this.enumsWatcher = watch(
-      dirPath,
-      { recursive: false },
-      async (event, filename) => {
-        if (filename === "enums.json" && this.callbacks.onEnumsChange) {
-          await this.callbacks.onEnumsChange();
-        }
-      }
-    );
-  }
-  /**
-   * Start watching CMS directory.
-   * Watches for changes in CMS content files (cms/{collection}/*.json).
-   * Falls back to a deferred-attach watcher when `cms/` doesn't exist yet.
-   */
-  watchCMS(dirPath = projectPaths.cms()) {
-    attachWhenDirExists(
-      dirPath,
-      () => watch(
-        dirPath,
-        { recursive: true },
-        async (event, filename) => {
-          if (filename && filename.endsWith(".json")) {
-            const collection = filename.split("/")[0];
-            if (this.callbacks.onCMSChange) {
-              await this.callbacks.onCMSChange(collection);
-            }
-          }
-        }
-      ),
-      (w) => {
-        this.cmsWatcher = w;
-      }
-    );
-  }
-  /**
-   * Start watching images directory for new source images
-   */
-  watchImages(dirPath = projectPaths.images()) {
-    if (!existsSync3(dirPath)) {
-      return;
-    }
-    this.imagesWatcher = watch(
-      dirPath,
-      { recursive: false },
-      async (event, filename) => {
-        if (event === "rename" && filename && this.callbacks.onImageAdded) {
-          await this.callbacks.onImageAdded(filename);
-        }
-      }
-    );
-  }
-  /**
-   * Start watching project.config.json for changes.
-   * Picks up edits to i18n locales, breakpoints, libraries, icons, etc. so the
-   * studio reflects external writes (e.g. an AI tool adding a new locale) without
-   * a dev-server restart.
-   */
-  watchProjectConfig() {
-    const dirPath = getProjectRoot();
-    this.projectConfigWatcher = watch(
-      dirPath,
-      { recursive: false },
-      async (_event, filename) => {
-        if (filename === "project.config.json" && this.callbacks.onProjectConfigChange) {
-          await this.callbacks.onProjectConfigChange();
-        }
-      }
-    );
-  }
-  /**
-   * Start watching libraries directory for CSS/JS changes
-   */
-  watchLibraries(dirPath = projectPaths.libraries()) {
-    if (!existsSync3(dirPath)) {
-      return;
-    }
-    this.librariesWatcher = watch(
-      dirPath,
-      { recursive: true },
-      async (event, filename) => {
-        if (filename && (filename.endsWith(".css") || filename.endsWith(".js"))) {
-          if (this.callbacks.onLibraryChange) {
-            await this.callbacks.onLibraryChange();
-          }
-        }
-      }
-    );
-  }
-  /**
-   * 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
-   */
-  watchAll() {
-    this.watchComponents();
-    this.watchPages();
-    this.watchTemplates();
-    this.watchColors();
-    this.watchVariables();
-    this.watchEnums();
-    this.watchCMS();
-    this.watchImages();
-    this.watchLibraries();
-    this.watchProjectConfig();
-    this.watchAstroPages();
-    this.watchAstroComponents();
-    this.watchAstroContent();
-  }
-  /**
-   * Stop watching all directories
-   */
-  stopAll() {
-    if (this.componentsWatcher) {
-      this.componentsWatcher.close();
-      this.componentsWatcher = null;
-    }
-    if (this.pagesWatcher) {
-      this.pagesWatcher.close();
-      this.pagesWatcher = null;
-    }
-    if (this.templatesWatcher) {
-      this.templatesWatcher.close();
-      this.templatesWatcher = null;
-    }
-    if (this.colorsWatcher) {
-      this.colorsWatcher.close();
-      this.colorsWatcher = null;
-    }
-    if (this.variablesWatcher) {
-      this.variablesWatcher.close();
-      this.variablesWatcher = null;
-    }
-    if (this.enumsWatcher) {
-      this.enumsWatcher.close();
-      this.enumsWatcher = null;
-    }
-    if (this.cmsWatcher) {
-      this.cmsWatcher.close();
-      this.cmsWatcher = null;
-    }
-    if (this.imagesWatcher) {
-      this.imagesWatcher.close();
-      this.imagesWatcher = null;
-    }
-    if (this.librariesWatcher) {
-      this.librariesWatcher.close();
-      this.librariesWatcher = null;
-    }
-    if (this.projectConfigWatcher) {
-      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
-   */
-  isWatching() {
-    return this.componentsWatcher !== null || this.pagesWatcher !== null || this.cmsWatcher !== null || this.imagesWatcher !== null;
-  }
-};
-
-// lib/server/services/fileWatcherService.ts
-var FileWatcherService = class {
-  constructor(componentService, pageService, pageCache, wsManager, cmsService, onImageAdded) {
-    this.componentService = componentService;
-    this.pageService = pageService;
-    this.pageCache = pageCache;
-    this.wsManager = wsManager;
-    this.cmsService = cmsService;
-    this.onImageAdded = onImageAdded;
-  }
-  fileWatcher = null;
-  /** Timer for debouncing refreshSchemas calls from burst fs.watch events */
-  refreshSchemasTimer = null;
-  /**
-   * Initialize file watchers
-   */
-  initialize() {
-    this.fileWatcher = new FileWatcher({
-      onComponentChange: async () => {
-        await this.componentService.loadAllComponents();
-        this.wsManager.broadcastUpdate("all");
-      },
-      onPageChange: async (pagePath) => {
-        if (await this.pageService.reloadPageFromDisk(pagePath)) {
-          this.wsManager.broadcastUpdate(pagePath);
-        }
-        if (pagePath.startsWith("/templates/") && this.cmsService) {
-          if (this.refreshSchemasTimer !== null) {
-            clearTimeout(this.refreshSchemasTimer);
-          }
-          const cmsService = this.cmsService;
-          const wsManager = this.wsManager;
-          this.refreshSchemasTimer = setTimeout(async () => {
-            this.refreshSchemasTimer = null;
-            await cmsService.refreshSchemas();
-            wsManager.broadcastCollectionsUpdate();
-          }, 50);
-        }
-      },
-      onColorsChange: async () => {
-        colorService.clearCache();
-        this.wsManager.broadcastColorsUpdate();
-      },
-      onVariablesChange: async () => {
-        variableService.clearCache();
-        this.wsManager.broadcastVariablesUpdate();
-      },
-      onEnumsChange: async () => {
-        enumService.clearCache();
-        this.wsManager.broadcastEnumsUpdate();
-      },
-      onCMSChange: async (collection) => {
-        this.cmsService?.clearItemsCache(collection);
-        this.wsManager.broadcastCMSUpdate(collection);
-      },
-      onImageAdded: this.onImageAdded,
-      onLibraryChange: async () => {
-        this.wsManager.broadcastLibrariesUpdate();
-      },
-      onProjectConfigChange: async () => {
-        configService.reset();
-        await configService.load();
-        this.wsManager.broadcastConfigUpdate();
-      }
-    });
-    this.fileWatcher.watchAll();
-  }
-  /**
-   * Stop file watchers
-   */
-  stop() {
-    if (this.refreshSchemasTimer !== null) {
-      clearTimeout(this.refreshSchemasTimer);
-      this.refreshSchemasTimer = null;
-    }
-    if (this.fileWatcher) {
-      this.fileWatcher.stopAll();
-      this.fileWatcher = null;
-    }
-  }
-};
-
-// lib/server/middleware/cors.ts
-var DEFAULT_OPTIONS = {
-  origin: "*",
-  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-  allowedHeaders: ["Content-Type", "Authorization"],
-  credentials: false
-};
-function createCorsHeaders(options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const headers = {};
-  if (opts.origin) {
-    if (typeof opts.origin === "function") {
-      headers["Access-Control-Allow-Origin"] = "*";
-    } else if (Array.isArray(opts.origin)) {
-      headers["Access-Control-Allow-Origin"] = opts.origin.join(", ");
-    } else {
-      headers["Access-Control-Allow-Origin"] = opts.origin;
-    }
-  }
-  if (opts.methods && opts.methods.length > 0) {
-    headers["Access-Control-Allow-Methods"] = opts.methods.join(", ");
-  }
-  if (opts.allowedHeaders && opts.allowedHeaders.length > 0) {
-    headers["Access-Control-Allow-Headers"] = opts.allowedHeaders.join(", ");
-  }
-  if (opts.credentials) {
-    headers["Access-Control-Allow-Credentials"] = "true";
-  }
-  return headers;
-}
-function handleCorsPreflight(req, options = {}) {
-  if (req.method === "OPTIONS") {
-    return new Response(null, {
-      status: 204,
-      headers: createCorsHeaders(options)
-    });
-  }
-  return null;
-}
-
-// lib/server/middleware/errorHandler.ts
-function createErrorResponse(error, status = 500, message) {
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  const response = {
-    error: errorMessage,
-    status
-  };
-  if (message) {
-    response.message = message;
-  }
-  return new Response(JSON.stringify(response), {
-    status,
-    headers: {
-      "Content-Type": "application/json"
-    }
-  });
-}
-async function handleRouteError(handler, errorMessage = "Internal server error") {
-  try {
-    return await handler();
-  } catch (error) {
-    return createErrorResponse(error, 500, errorMessage);
-  }
-}
-function withErrorHandling(handler, errorMessage) {
-  return async (...args) => {
-    return handleRouteError(() => handler(...args), errorMessage);
-  };
-}
-
-// lib/server/middleware/logger.ts
-var DEFAULT_OPTIONS2 = {
-  logRequests: true,
-  logErrors: true,
-  logResponseTime: true
-};
-function logRequest(req, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS2, ...options };
-  if (!opts.logRequests) {
-    return;
-  }
-  const url = new URL(req.url);
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-}
-function logError(error, context, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS2, ...options };
-  if (!opts.logErrors) {
-    return;
-  }
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const contextStr = context ? ` [${context}]` : "";
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  if (error instanceof Error && error.stack) {
-  }
-}
-function logResponseTime(startTime, req, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS2, ...options };
-  if (!opts.logResponseTime) {
-    return;
-  }
-  const url = new URL(req.url);
-  const duration = Date.now() - startTime;
-}
-function withLogging(handler, options = {}) {
-  return async (...args) => {
-    const startTime = Date.now();
-    const req = args[0];
-    logRequest(req, options);
-    try {
-      const response = await handler(...args);
-      logResponseTime(startTime, req, options);
-      return response;
-    } catch (error) {
-      logError(error, req.method, options);
-      logResponseTime(startTime, req, options);
-      throw error;
-    }
-  };
-}
-
-// lib/server/routes/api/shared.ts
-function jsonResponse(data, options = {}) {
-  const corsHeaders = createCorsHeaders();
-  return new Response(JSON.stringify(data), {
-    status: options.status || 200,
-    headers: {
-      "Content-Type": "application/json",
-      "Cache-Control": "no-store, max-age=0",
-      "Pragma": "no-cache",
-      "Expires": "0",
-      ...corsHeaders
-    }
-  });
-}
-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) {
-  const schemas = cmsService.getAllSchemas();
-  const collections = [];
-  for (const [, schemaInfo] of schemas) {
-    collections.push(schemaInfo.schema);
-  }
-  return jsonResponse({ collections });
-}
-function handleCollectionSchemaRoute(collection, cmsService) {
-  const schema = cmsService.getSchema(collection);
-  if (!schema) {
-    return errorResponse("Collection not found", 404);
-  }
-  return jsonResponse({ schema });
-}
-async function handleItemsRoute(collection, cmsService, searchParams) {
-  const limit = searchParams?.get("limit") ? parseInt(searchParams.get("limit"), 10) : void 0;
-  const offset = searchParams?.get("offset") ? parseInt(searchParams.get("offset"), 10) : void 0;
-  const search = searchParams?.get("search") || void 0;
-  const allItems = await cmsService.queryItems({ collection });
-  const total = allItems.length;
-  let filteredItems = allItems;
-  if (search) {
-    const searchLower = search.toLowerCase();
-    const schema2 = cmsService.getSchema(collection);
-    const slugField = schema2?.slugField || "slug";
-    filteredItems = allItems.filter((item) => {
-      const title = extractStringValue(item.title || "").toLowerCase();
-      const slug = extractStringValue(item[slugField] || item._slug || "").toLowerCase();
-      const filename = String(item._filename || "").toLowerCase();
-      return title.includes(searchLower) || slug.includes(searchLower) || filename.includes(searchLower);
-    });
-  }
-  let items = filteredItems;
-  if (offset !== void 0 && offset > 0) {
-    items = items.slice(offset);
-  }
-  if (limit !== void 0 && limit > 0) {
-    items = items.slice(0, limit);
-  }
-  const schema = cmsService.getSchema(collection);
-  const itemsWithUrl = schema ? addItemUrls(items, schema) : items;
-  return jsonResponse({
-    items: itemsWithUrl,
-    total: search ? filteredItems.length : total,
-    limit,
-    offset: offset || 0
-  });
-}
-async function handleItemRoute(collection, slug, cmsService) {
-  const match = await cmsService.matchRoute(
-    cmsService.getSchema(collection)?.urlPattern.replace("{{slug}}", slug) || ""
-  );
-  if (!match) {
-    const items = await cmsService.queryItems({ collection });
-    const item = items.find((i) => i._slug === slug || i[cmsService.getSchema(collection)?.slugField || "slug"] === slug);
-    if (!item) {
-      return errorResponse("Item not found", 404);
-    }
-    return jsonResponse({ item });
-  }
-  return jsonResponse({ item: match.item });
-}
-
-// lib/server/routes/api/core-routes.ts
-init_constants();
-
-// lib/server/routes/api/pages.ts
-init_constants();
-function handlePagesRoute(pageService) {
-  const pages = pageService.getAllPagesWithInfo();
-  return jsonResponse({ pages });
-}
-function handlePageDataRoute(url, pageService) {
-  const pagePath = url.pathname.replace(API_ROUTES.PAGE_DATA, "") || "/";
-  const content = pageService.getPage(pagePath);
-  if (content) {
-    try {
-      const parsedContent = parseJSON(content);
-      const lineMap = pageService.getLineMap(pagePath);
-      const lineMapObj = {};
-      if (lineMap) {
-        lineMap.forEach((value, key) => {
-          lineMapObj[key] = value;
-        });
-      }
-      return jsonResponse({ ...parsedContent, _lineMap: lineMapObj });
-    } catch (error) {
-      return jsonResponse({ error: "Invalid JSON" }, { status: 500 });
-    }
-  } else {
-    return jsonResponse({ error: "Page not found" }, { status: 404 });
-  }
-}
-function handlePageContentRoute(req, url, pageService) {
-  const page = url.searchParams.get("page") || "/";
-  const content = pageService.getPage(page);
-  if (content) {
-    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();
-  return jsonResponse({ mappings });
-}
-
-// lib/server/routes/api/components.ts
-function handleComponentsRoute(req, componentService) {
-  const componentsWithCategories = componentService.getAllComponentsWithCategories();
-  const result = {};
-  for (const [name, info] of Object.entries(componentsWithCategories)) {
-    result[name] = {
-      ...info.definition,
-      _category: info.category
-    };
-  }
-  const diagnostics = componentService.getLoadDiagnostics();
-  if (diagnostics.errors.length > 0 || diagnostics.warnings.length > 0) {
-    result._diagnostics = diagnostics;
-  }
-  return cachedJsonResponse(req, JSON.stringify(result));
-}
-function handleComponentDataRoute(url, componentService) {
-  const componentName = url.pathname.replace("/api/component-data/", "");
-  const componentDef = componentService.getComponent(componentName);
-  if (!componentDef) {
-    const loadErrors = componentService.getLoadErrors();
-    const diagnostic = loadErrors.get(componentName);
-    if (diagnostic) {
-      const message = formatJsonErrorMessage(
-        `${diagnostic.componentName}.json`,
-        { message: diagnostic.description, line: diagnostic.line, column: diagnostic.column }
-      );
-      return jsonResponse(
-        { error: "json_parse_error", message, errorCode: "JSON_PARSE_ERROR" },
-        { status: 422 }
-      );
-    }
-    return jsonResponse({ error: "Component not found" }, { status: 404 });
-  }
-  if (!componentService.validateComponentStructure(componentDef)) {
-    return jsonResponse(
-      {
-        error: "Component structure is missing",
-        message: `Component "${componentName}" does not have a valid structure definition. Please add a structure field to the component definition.`
-      },
-      { status: 400 }
-    );
-  }
-  return jsonResponse(componentDef);
-}
-async function handleComponentJavaScriptRoute(url, componentService) {
-  const componentName = url.pathname.replace("/api/component-js/", "");
-  const jsContent = await componentService.getComponentJavaScript(componentName);
-  const corsHeaders = createCorsHeaders();
-  return new Response(jsContent || "", {
-    headers: {
-      "Content-Type": "text/javascript",
-      ...corsHeaders
-    }
-  });
-}
-function handleComponentUsageRoute(pageService, componentService) {
-  const usageMap = /* @__PURE__ */ new Map();
-  function walkTree(node, fileName, filePath, fileType) {
-    if (!node || typeof node !== "object") return;
-    if (node.type === "component" && "component" in node && node.component) {
-      const compName = node.component;
-      if (!usageMap.has(compName)) {
-        usageMap.set(compName, { count: 0, files: /* @__PURE__ */ new Map() });
-      }
-      const entry = usageMap.get(compName);
-      entry.count++;
-      entry.files.set(filePath, { name: fileName, path: filePath, type: fileType });
-    }
-    if ("children" in node && Array.isArray(node.children)) {
-      for (const child of node.children) {
-        if (child && typeof child === "object") {
-          walkTree(child, fileName, filePath, fileType);
-        }
-      }
-    }
-  }
-  const pagePaths = pageService.getAllPagePaths();
-  for (const path2 of pagePaths) {
-    const pageData = pageService.getPageData(path2);
-    if (pageData && "root" in pageData && pageData.root) {
-      const name = path2 === "/" ? "index" : path2.replace(/^\//, "").replace(/\//g, "-");
-      walkTree(pageData.root, name, path2, "page");
-    }
-  }
-  const allComponents = componentService.getAllComponents();
-  for (const [compName, compDef] of Object.entries(allComponents)) {
-    if (compDef.component?.structure) {
-      walkTree(compDef.component.structure, compName, compName, "component");
-    }
-  }
-  const result = {};
-  for (const [name, data] of usageMap) {
-    result[name] = {
-      count: data.count,
-      files: Array.from(data.files.values())
-    };
-  }
-  return jsonResponse(result);
-}
-
-// lib/server/routes/api/config.ts
-async function handleConfigRoute() {
-  try {
-    const configContent = await loadJSONFile(projectPaths.config());
-    if (configContent) {
-      const config = parseJSON(configContent);
-      return jsonResponse(config);
-    } else {
-      return jsonResponse({ editor: { theme: "dark" } });
-    }
-  } catch (error) {
-    return jsonResponse({ editor: { theme: "dark" } });
-  }
-}
-async function handleComponentsConfigRoute() {
-  try {
-    const configContent = await loadJSONFile(projectPaths.componentsConfig());
-    if (configContent) {
-      const config = parseJSON(configContent);
-      return jsonResponse(config);
-    } else {
-      return jsonResponse({ componentTypes: [], componentCategories: {} });
-    }
-  } catch (error) {
-    return jsonResponse({ componentTypes: [], componentCategories: {} });
-  }
-}
-
-// lib/server/routes/api/colors.ts
-async function handleColorsRoute(url) {
-  const themeName = url?.searchParams.get("theme") || void 0;
-  const colors = await colorService.getThemeColors(themeName);
-  return jsonResponse(colors);
-}
-async function handleThemesRoute() {
-  const themes = await colorService.getAvailableThemes();
-  const defaultTheme = await colorService.getDefaultTheme();
-  return jsonResponse({ themes, default: defaultTheme });
-}
-async function handleColorsConfigRoute() {
-  const config = await colorService.getFullConfig();
-  return jsonResponse(config);
-}
-async function handleColorsStatusRoute() {
-  const result = await colorService.getConfigWithStatus();
-  return jsonResponse(result);
-}
-
-// lib/server/routes/api/variables.ts
-async function handleVariablesStatusRoute() {
-  const result = await variableService.getConfigWithStatus();
-  return jsonResponse(result);
-}
-async function handleVariablesCSSRoute() {
-  await configService.load();
-  const variablesConfig = await variableService.loadConfig();
-  const breakpointConfig = await loadBreakpointConfig();
-  const responsiveScalesConfig = configService.getResponsiveScales();
-  const css = generateVariablesCSS(variablesConfig, breakpointConfig, responsiveScalesConfig);
-  return new Response(css, {
-    headers: { "Content-Type": "text/css" }
-  });
-}
-
-// lib/server/routes/api/enums.ts
-async function handleEnumsRoute() {
-  const result = await enumService.getConfigWithStatus();
-  return jsonResponse(result);
-}
-
-// lib/server/routes/api/functions.ts
-import path from "path";
-async function loadProjectEnv() {
-  const envPath = projectPaths.env();
-  const env = {};
-  try {
-    if (await fileExists(envPath)) {
-      const content = await readTextFile(envPath);
-      for (const line of content.split("\n")) {
-        const trimmed = line.trim();
-        if (trimmed && !trimmed.startsWith("#")) {
-          const [key, ...valueParts] = trimmed.split("=");
-          if (key) {
-            let value = valueParts.join("=");
-            if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-              value = value.slice(1, -1);
-            }
-            env[key.trim()] = value;
-          }
-        }
-      }
-    }
-  } catch (error) {
-    console.warn("Could not load .env file:", error);
-  }
-  return env;
-}
-async function handleFunctionsRoute(req, url) {
-  if (!url.pathname.startsWith("/api/")) {
-    return void 0;
-  }
-  if (url.pathname.startsWith("/api/editor/")) {
-    return void 0;
-  }
-  const functionPath = url.pathname.replace("/api/", "");
-  const functionFilePath = path.join(
-    projectPaths.functions(),
-    "api",
-    `${functionPath}.ts`
-  );
-  if (!await fileExists(functionFilePath)) {
-    const jsFilePath = functionFilePath.replace(".ts", ".js");
-    if (!await fileExists(jsFilePath)) {
-      return void 0;
-    }
-  }
-  try {
-    const moduleUrl = `${functionFilePath}?t=${Date.now()}`;
-    const functionModule = await import(moduleUrl);
-    const method = req.method.toUpperCase();
-    const handlerName = `onRequest${method.charAt(0)}${method.slice(1).toLowerCase()}`;
-    const handler = functionModule[handlerName] || functionModule.onRequest;
-    if (!handler || typeof handler !== "function") {
-      return new Response(
-        JSON.stringify({ error: `No handler found for ${method} request` }),
-        { status: 405, headers: { "Content-Type": "application/json" } }
-      );
-    }
-    const env = await loadProjectEnv();
-    const context = {
-      request: req,
-      env,
-      params: {},
-      // Could parse URL params if needed
-      waitUntil: () => {
-      },
-      // No-op in dev
-      passThroughOnException: () => {
-      }
-      // No-op in dev
-    };
-    const response = await handler(context);
-    const headers = new Headers(response.headers);
-    headers.set("Access-Control-Allow-Origin", "*");
-    headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
-    headers.set("Access-Control-Allow-Headers", "Content-Type");
-    return new Response(response.body, {
-      status: response.status,
-      statusText: response.statusText,
-      headers
-    });
-  } catch (error) {
-    console.error(`Error executing function ${functionPath}:`, error);
-    return new Response(
-      JSON.stringify({
-        error: "Function execution error",
-        message: error instanceof Error ? error.message : "Unknown error"
-      }),
-      { status: 500, headers: { "Content-Type": "application/json" } }
-    );
-  }
-}
-function handleFunctionsPreflight(req, url) {
-  if (req.method !== "OPTIONS" || !url.pathname.startsWith("/api/")) {
-    return void 0;
-  }
-  return new Response(null, {
-    status: 204,
-    headers: {
-      "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-      "Access-Control-Allow-Headers": "Content-Type",
-      "Access-Control-Max-Age": "86400"
-    }
-  });
-}
-
-// lib/server/routes/api/core-routes.ts
-async function handleCoreApiRoutes(req, url, context) {
-  const { pageService, componentService, cmsService } = context;
-  const preflightResponse = handleFunctionsPreflight(req, url);
-  if (preflightResponse) {
-    return preflightResponse;
-  }
-  const functionsResponse = await handleFunctionsRoute(req, url);
-  if (functionsResponse) {
-    return functionsResponse;
-  }
-  if (url.pathname === API_ROUTES.PAGES && req.method === "GET") {
-    return await handleRouteError(
-      () => Promise.resolve(handlePagesRoute(pageService)),
-      "Failed to fetch pages list"
-    );
-  }
-  if (url.pathname.startsWith(API_ROUTES.PAGE_DATA) && req.method === "GET") {
-    return await handleRouteError(
-      () => Promise.resolve(handlePageDataRoute(url, pageService)),
-      "Failed to fetch page data"
-    );
-  }
-  if (url.pathname === API_ROUTES.PAGE_CONTENT && req.method === "GET") {
-    return await handleRouteError(
-      () => 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(req, componentService)),
-      "Failed to fetch components list"
-    );
-  }
-  if (url.pathname.startsWith("/api/component-data/") && req.method === "GET") {
-    return await handleRouteError(
-      () => Promise.resolve(handleComponentDataRoute(url, componentService)),
-      "Failed to fetch component data"
-    );
-  }
-  if (url.pathname.startsWith("/api/component-js/") && req.method === "GET") {
-    return await handleRouteError(
-      () => handleComponentJavaScriptRoute(url, componentService),
-      "Failed to fetch component JavaScript"
-    );
-  }
-  if (url.pathname === "/api/config" && req.method === "GET") {
-    return await handleRouteError(
-      () => handleConfigRoute(),
-      "Failed to fetch config"
-    );
-  }
-  if (url.pathname === "/api/components-config" && req.method === "GET") {
-    return await handleRouteError(
-      () => handleComponentsConfigRoute(),
-      "Failed to fetch components config"
-    );
-  }
-  if (url.pathname === "/api/colors" && req.method === "GET") {
-    return await handleRouteError(
-      () => handleColorsRoute(url),
-      "Failed to fetch colors"
-    );
-  }
-  if (url.pathname === "/api/themes" && req.method === "GET") {
-    return await handleRouteError(
-      () => handleThemesRoute(),
-      "Failed to fetch themes"
-    );
-  }
-  if (url.pathname === "/api/colors-config" && req.method === "GET") {
-    return await handleRouteError(
-      () => handleColorsConfigRoute(),
-      "Failed to fetch colors config"
-    );
-  }
-  if (url.pathname === "/api/colors-status" && req.method === "GET") {
-    return await handleRouteError(
-      () => handleColorsStatusRoute(),
-      "Failed to fetch colors status"
-    );
-  }
-  if (url.pathname === "/api/variables-status" && req.method === "GET") {
-    return await handleRouteError(
-      () => handleVariablesStatusRoute(),
-      "Failed to fetch variables status"
-    );
-  }
-  if (url.pathname === "/api/variables-css" && req.method === "GET") {
-    return await handleRouteError(
-      () => handleVariablesCSSRoute(),
-      "Failed to generate variables CSS"
-    );
-  }
-  if (url.pathname === "/api/fonts-css" && req.method === "GET") {
-    return await handleRouteError(
-      async () => {
-        await loadProjectConfig();
-        const css = generateFontCSS();
-        return new Response(css, {
-          headers: { "Content-Type": "text/css" }
-        });
-      },
-      "Failed to generate fonts CSS"
-    );
-  }
-  if (url.pathname === "/api/enums" && req.method === "GET") {
-    return await handleRouteError(
-      () => handleEnumsRoute(),
-      "Failed to fetch enums"
-    );
-  }
-  if (url.pathname === "/api/usage" && req.method === "GET") {
-    return await handleRouteError(
-      () => {
-        const cmsCollections = cmsService ? cmsService.getAllSchemas().size : 0;
-        const allPages = pageService.getAllPagePaths();
-        const pages = allPages.filter((p) => !p.includes("/templates/")).length;
-        const i18n = configService.getI18n();
-        const locales = i18n.locales.length;
-        return Promise.resolve(
-          new Response(JSON.stringify({ cmsCollections, pages, locales }), {
-            headers: { "Content-Type": "application/json" }
-          })
-        );
-      },
-      "Failed to fetch usage stats"
-    );
-  }
-  if (url.pathname === API_ROUTES.COMPONENT_USAGE && req.method === "GET") {
-    return await handleRouteError(
-      () => Promise.resolve(handleComponentUsageRoute(pageService, componentService)),
-      "Failed to fetch component usage"
-    );
-  }
-  if (url.pathname === "/api/slug-mappings" && req.method === "GET") {
-    return await handleRouteError(
-      () => Promise.resolve(handleSlugMappingsRoute(pageService)),
-      "Failed to fetch slug mappings"
-    );
-  }
-  if (cmsService && url.pathname.startsWith("/api/cms/")) {
-    if (url.pathname === "/api/cms/collections" && req.method === "GET") {
-      return await handleRouteError(
-        () => Promise.resolve(handleCollectionsRoute(cmsService)),
-        "Failed to fetch CMS collections"
-      );
-    }
-    const collectionSchemaMatch = url.pathname.match(/^\/api\/cms\/collections\/([^/]+)$/);
-    if (collectionSchemaMatch && req.method === "GET") {
-      const collection = collectionSchemaMatch[1];
-      return await handleRouteError(
-        () => Promise.resolve(handleCollectionSchemaRoute(collection, cmsService)),
-        "Failed to fetch collection schema"
-      );
-    }
-    const cmsPathMatch = url.pathname.match(/^\/api\/cms\/([^/]+)(?:\/([^/]+))?$/);
-    if (cmsPathMatch) {
-      const collection = cmsPathMatch[1];
-      const slug = cmsPathMatch[2];
-      if (collection === "collections") {
-        return void 0;
-      }
-      if (!slug && req.method === "GET") {
-        return await handleRouteError(
-          () => handleItemsRoute(collection, cmsService, url.searchParams),
-          "Failed to fetch CMS items"
-        );
-      }
-      if (slug && req.method === "GET") {
-        return await handleRouteError(
-          () => handleItemRoute(collection, slug, cmsService),
-          "Failed to fetch CMS item"
-        );
-      }
-    }
-  }
-  return void 0;
-}
-
-// lib/server/routes/index.ts
-init_constants();
-
-// lib/server/routes/api/index.ts
-async function handleApiRoutes(req, url, pageService, componentService, cmsContext) {
-  try {
-    const coreContext = {
-      pageService,
-      componentService,
-      cmsService: cmsContext?.cmsService
-    };
-    return await handleCoreApiRoutes(req, url, coreContext);
-  } catch (error) {
-    return handleRouteError(
-      () => Promise.reject(error),
-      "API route error"
-    );
-  }
-}
-
-// lib/server/routes/pages.ts
-import { randomBytes } from "crypto";
-
-// lib/shared/pathUtils.ts
-function getStaticFilePath(pagePath, distDir = "./dist") {
-  if (pagePath === "/") {
-    return `${distDir}/index.html`;
-  }
-  const pathParts = pagePath.substring(1).split("/");
-  const fileName = pathParts.join("-") + ".html";
-  return `${distDir}/${fileName}`;
-}
-
-// lib/server/ssr/errorOverlay.ts
-function extractErrorInfo(error) {
-  if (error instanceof Error) {
-    return {
-      message: error.message,
-      stack: error.stack
-    };
-  }
-  if (typeof error === "string") {
-    return { message: error };
-  }
-  return { message: String(error) };
-}
-function escapeHtml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-}
-function safeJsonForScript(data) {
-  return JSON.stringify(data).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
-}
-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: friendly.friendlyMessage,
-      title: friendly.title,
-      hint: friendly.hint,
-      raw: errorInfo.message,
-      stack: errorInfo.stack,
-      context
-    }
-  });
-  const fullErrorText = safeJsonForScript(
-    errorInfo.message + (errorInfo.stack ? "\n\n" + errorInfo.stack : "")
-  );
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Preview Error</title>
-  <style${nonceAttr}>
-    * { margin: 0; padding: 0; box-sizing: border-box; }
-    body {
-      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-      background: #1a1a1a;
-      color: #fff;
-      min-height: 100vh;
-      display: flex;
-      align-items: center;
-      justify-content: center;
-      padding: 20px;
-    }
-    .error-container {
-      max-width: 800px;
-      width: 100%;
-      background: #2d2d2d;
-      border-radius: 12px;
-      overflow: hidden;
-      box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
-    }
-    .error-header {
-      background: linear-gradient(135deg, #ff4444 0%, #cc0000 100%);
-      padding: 20px 24px;
-      display: flex;
-      align-items: center;
-      gap: 12px;
-    }
-    .error-icon { font-size: 24px; }
-    .error-title { font-size: 18px; font-weight: 600; }
-    .error-body { padding: 24px; }
-    .error-context {
-      font-size: 12px;
-      color: #888;
-      margin-bottom: 16px;
-      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;
-      border-radius: 8px;
-      padding: 16px;
-      font-family: 'SF Mono', Menlo, Monaco, 'Courier New', monospace;
-      font-size: 14px;
-      line-height: 1.6;
-      color: #ff6b6b;
-      overflow-x: auto;
-      white-space: pre-wrap;
-      word-break: break-word;
-    }
-    .error-stack { margin-top: 16px; }
-    .stack-toggle {
-      background: none;
-      border: 1px solid #444;
-      color: #888;
-      padding: 8px 16px;
-      border-radius: 6px;
-      cursor: pointer;
-      font-size: 13px;
-      display: flex;
-      align-items: center;
-      gap: 8px;
-      transition: all 0.15s;
-    }
-    .stack-toggle:hover { background: #333; color: #fff; border-color: #555; }
-    .stack-toggle svg { width: 14px; height: 14px; transition: transform 0.2s; }
-    .stack-toggle.expanded svg { transform: rotate(90deg); }
-    .stack-content {
-      display: none;
-      margin-top: 12px;
-      background: #1a1a1a;
-      border: 1px solid #444;
-      border-radius: 8px;
-      padding: 16px;
-      font-family: 'SF Mono', Menlo, Monaco, 'Courier New', monospace;
-      font-size: 12px;
-      line-height: 1.8;
-      color: #999;
-      overflow-x: auto;
-      white-space: pre;
-    }
-    .stack-content.visible { display: block; }
-    .error-footer {
-      padding: 16px 24px;
-      background: #252525;
-      border-top: 1px solid #333;
-      display: flex;
-      justify-content: space-between;
-      align-items: center;
-      flex-wrap: wrap;
-      gap: 12px;
-    }
-    .error-hint { font-size: 13px; color: #888; }
-    .copy-btn {
-      background: #333;
-      border: 1px solid #444;
-      color: #fff;
-      padding: 8px 16px;
-      border-radius: 6px;
-      cursor: pointer;
-      font-size: 13px;
-      display: flex;
-      align-items: center;
-      gap: 6px;
-      transition: all 0.15s;
-    }
-    .copy-btn:hover { background: #444; border-color: #555; }
-    .copy-btn svg { width: 14px; height: 14px; }
-  </style>
-</head>
-<body>
-  <div class="error-container">
-    <div class="error-header">
-      <span class="error-icon">\u26A0\uFE0F</span>
-      <span class="error-title">${friendlyTitle}</span>
-    </div>
-    <div class="error-body">
-      ${context ? `<div class="error-context">${escapeHtml(context)}</div>` : ""}
-      <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 technical details</span>
-        </button>
-        <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">${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>
-          <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path>
-        </svg>
-        <span>Copy Error</span>
-      </button>
-    </div>
-  </div>
-  <script${nonceAttr}>
-    (function() {
-      // Send error to parent editor
-      if (window.parent && window.parent !== window) {
-        try {
-          window.parent.postMessage(${errorDataJson}, '*');
-        } catch (e) {
-          console.error('Failed to send error to parent:', e);
-        }
-      }
-
-      // Stack trace toggle
-      var stackToggle = document.getElementById('stackToggle');
-      var stackContent = document.getElementById('stackContent');
-      if (stackToggle && stackContent) {
-        stackToggle.addEventListener('click', function() {
-          var isVisible = stackContent.classList.toggle('visible');
-          stackToggle.classList.toggle('expanded', isVisible);
-          stackToggle.querySelector('span').textContent = isVisible ? 'Hide technical details' : 'Show technical details';
-        });
-      }
-
-      // Copy button
-      var copyBtn = document.getElementById('copyBtn');
-      if (copyBtn) {
-        copyBtn.addEventListener('click', function() {
-          var errorText = ${fullErrorText};
-          navigator.clipboard.writeText(errorText).then(function() {
-            var span = copyBtn.querySelector('span');
-            var original = span.textContent;
-            span.textContent = 'Copied!';
-            setTimeout(function() { span.textContent = original; }, 2000);
-          }).catch(function(err) {
-            console.error('Failed to copy:', err);
-          });
-        });
-      }
-    })();
-  </script>
-</body>
-</html>`;
-}
-
-// lib/server/scriptCache.ts
-var scriptCache = /* @__PURE__ */ new Map();
-function cacheScript(hash, content) {
-  scriptCache.set(hash, content);
-}
-function getScript(hash) {
-  return scriptCache.get(hash);
-}
-function hashContent2(content) {
-  return hashContent(content);
-}
-
-// lib/server/routes/pages.ts
-var EDITOR_HEADER = "x-meno-editor";
-var CSP_NONCE_HEADER = "x-meno-csp-nonce";
-function generateCspNonce() {
-  return randomBytes(16).toString("base64");
-}
-async function handlePageRoute(url, context, req) {
-  const { pageService, componentService, cmsService, injectLiveReload, isEditor, serverPort } = context;
-  const pagePath = url.pathname;
-  const injectEditorAttrs = injectLiveReload === true || req?.headers.get(EDITOR_HEADER) === "1";
-  const cspNonce = generateCspNonce();
-  const i18nConfig = await loadI18nConfig();
-  const { locale, pathWithoutLocale } = parseLocaleFromPath(pagePath, i18nConfig);
-  const slugMappings = pageService.getSlugMappings();
-  const slugIndex = buildSlugIndex(slugMappings);
-  if (cmsService) {
-    const cmsMatch = await cmsService.matchRoute(pathWithoutLocale, locale);
-    if (cmsMatch) {
-      if (injectEditorAttrs && url.searchParams.get("previewDraft") === "1" && cmsMatch.item._filename) {
-        const draft = await cmsService.getDraft(cmsMatch.collection, cmsMatch.item._filename);
-        if (draft) {
-          cmsMatch.item = draft;
-        }
-      }
-      const templatePageContent = await loadPageByFilePath(cmsMatch.pagePath);
-      if (templatePageContent) {
-        const templatesDir = projectPaths.templates();
-        const cmsTemplatePath = "/templates" + cmsMatch.pagePath.replace(templatesDir, "").replace(/\\/g, "/").replace(/\.json$/, "");
-        try {
-          const pageData = parseJSON(templatePageContent);
-          const globalComponentsRecord = componentService.getAllComponents();
-          const baseUrl = `${url.protocol}//${url.host}`;
-          const typedPageData = pageData;
-          if (injectLiveReload) {
-            const result = await generateSSRHTML({
-              pageData: typedPageData,
-              globalComponents: globalComponentsRecord,
-              pagePath,
-              baseUrl,
-              useBuiltBundle: true,
-              locale,
-              slugMappings,
-              cmsContext: { cms: cmsMatch.item },
-              cmsService,
-              cmsTemplatePath,
-              pageLibraries: typedPageData.meta?.libraries,
-              pageCustomCode: typedPageData.meta?.customCode,
-              injectLiveReload,
-              injectEditorAttrs,
-              isEditor,
-              serverPort,
-              returnSeparateJS: true,
-              cspNonce
-            });
-            let finalHtml = result.html;
-            if (result.javascript) {
-              const hash = hashContent2(result.javascript);
-              cacheScript(hash, result.javascript);
-              finalHtml = finalHtml.replace("</body>", `  <script src="/_scripts/${hash}.js" defer></script>
-</body>`);
-            }
-            return new Response(finalHtml, {
-              headers: {
-                "Content-Type": "text/html; charset=utf-8",
-                "Cache-Control": "no-store, max-age=0",
-                "Pragma": "no-cache",
-                "Expires": "0",
-                [CSP_NONCE_HEADER]: cspNonce
-              }
-            });
-          }
-          const ssrHTML = await generateSSRHTML({
-            pageData: typedPageData,
-            globalComponents: globalComponentsRecord,
-            pagePath,
-            baseUrl,
-            useBuiltBundle: false,
-            locale,
-            slugMappings,
-            cmsContext: { cms: cmsMatch.item },
-            cmsService,
-            cmsTemplatePath,
-            pageLibraries: typedPageData.meta?.libraries,
-            pageCustomCode: typedPageData.meta?.customCode,
-            injectEditorAttrs,
-            isEditor,
-            cspNonce
-          });
-          return new Response(ssrHTML, {
-            headers: {
-              "Content-Type": "text/html; charset=utf-8",
-              "Cache-Control": "no-store, max-age=0",
-              "Pragma": "no-cache",
-              "Expires": "0",
-              [CSP_NONCE_HEADER]: cspNonce
-            }
-          });
-        } catch (error) {
-          console.error("Error rendering CMS page:", error);
-          return new Response(generateErrorPage(error, `Error rendering template: ${cmsTemplatePath}`, cspNonce), {
-            headers: {
-              "Content-Type": "text/html; charset=utf-8",
-              "Cache-Control": "no-store",
-              [CSP_NONCE_HEADER]: cspNonce
-            }
-          });
-        }
-      }
-    }
-  }
-  const slug = pathWithoutLocale === "/" ? "" : pathWithoutLocale.substring(1);
-  const pageId = resolveSlugToPageId(slug, locale, slugIndex);
-  let lookupPath;
-  if (pageId) {
-    lookupPath = pageId === "index" ? "/" : `/${pageId}`;
-  } else {
-    lookupPath = pathWithoutLocale;
-  }
-  const isDevelopment = true;
-  if (!isDevelopment) {
-    const staticFilePath = getStaticFilePath(pagePath);
-    if (await fileExists(staticFilePath)) {
-      return serveFile(staticFilePath, {
-        "Content-Type": "text/html; charset=utf-8",
-        "Cache-Control": "public, max-age=31536000"
-        // 1 year cache for static files
-      });
-    }
-  }
-  const pageContent = context.draftPageStore?.get(lookupPath) ?? pageService.getPage(lookupPath);
-  if (pageContent) {
-    try {
-      const pageData = parseJSON(pageContent);
-      const globalComponentsRecord = componentService.getAllComponents();
-      const baseUrl = `${url.protocol}//${url.host}`;
-      if (injectLiveReload) {
-        const result = await generateSSRHTML({
-          pageData,
-          globalComponents: globalComponentsRecord,
-          pagePath,
-          baseUrl,
-          useBuiltBundle: true,
-          locale,
-          slugMappings,
-          cmsService,
-          pageLibraries: pageData.meta?.libraries,
-          pageCustomCode: pageData.meta?.customCode,
-          injectLiveReload,
-          injectEditorAttrs,
-          isEditor,
-          serverPort,
-          returnSeparateJS: true,
-          cspNonce
-        });
-        let finalHtml = result.html;
-        if (result.javascript) {
-          const hash = hashContent2(result.javascript);
-          cacheScript(hash, result.javascript);
-          finalHtml = finalHtml.replace("</body>", `  <script src="/_scripts/${hash}.js" defer></script>
-</body>`);
-        }
-        return new Response(finalHtml, {
-          headers: {
-            "Content-Type": "text/html; charset=utf-8",
-            "Cache-Control": "no-store, max-age=0",
-            "Pragma": "no-cache",
-            "Expires": "0",
-            [CSP_NONCE_HEADER]: cspNonce
-          }
-        });
-      }
-      const ssrHTML = await generateSSRHTML({
-        pageData,
-        globalComponents: globalComponentsRecord,
-        pagePath,
-        baseUrl,
-        useBuiltBundle: false,
-        locale,
-        slugMappings,
-        cmsService,
-        pageLibraries: pageData.meta?.libraries,
-        pageCustomCode: pageData.meta?.customCode,
-        injectEditorAttrs,
-        isEditor,
-        cspNonce
-      });
-      return new Response(ssrHTML, {
-        headers: {
-          "Content-Type": "text/html; charset=utf-8",
-          "Cache-Control": "no-store, max-age=0",
-          "Pragma": "no-cache",
-          "Expires": "0",
-          [CSP_NONCE_HEADER]: cspNonce
-        }
-      });
-    } catch (error) {
-      console.error("Error rendering page:", error);
-      return new Response(generateErrorPage(error, `Error rendering page: ${lookupPath}`, cspNonce), {
-        headers: {
-          "Content-Type": "text/html; charset=utf-8",
-          "Cache-Control": "no-store",
-          [CSP_NONCE_HEADER]: cspNonce
-        }
-      });
-    }
-  } else {
-    return serveFile(packagePaths.indexHtml());
-  }
-}
-async function loadPageByFilePath(filePath) {
-  try {
-    if (await fileExists(filePath)) {
-      return await readTextFile(filePath);
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-// lib/server/routes/static.ts
-async function handleStaticRoute(url, req) {
-  if (url.pathname === "/client-router.js" || url.pathname === "/client-router.tsx") {
-    const preBundledPath = packagePaths.clientRouter().replace(/\.tsx$/, ".js");
-    if (preBundledPath !== packagePaths.clientRouter() && await fileExists(preBundledPath)) {
-      return serveFile(preBundledPath, {
-        "Content-Type": "application/javascript",
-        "Cache-Control": "no-cache, no-store, must-revalidate"
-      });
-    }
-    const result = await bundleFile(packagePaths.clientRouter(), {
-      target: "browser",
-      format: "esm",
-      minify: false,
-      sourcemap: "inline"
-    });
-    if (result.success) {
-      return new Response(result.code, {
-        headers: {
-          "Content-Type": "application/javascript",
-          "Cache-Control": "no-cache, no-store, must-revalidate"
-        }
-      });
-    }
-  }
-  if (url.pathname.endsWith(".tsx") || url.pathname.endsWith(".ts")) {
-    const entrypoint = resolvePackagePath(url.pathname.slice(1));
-    if (!isPathWithinRoot(entrypoint, getPackageRoot())) {
-      return new Response("Forbidden", { status: 403 });
-    }
-    const result = await bundleFile(entrypoint, {
-      target: "browser",
-      format: "esm",
-      minify: false,
-      sourcemap: "inline"
-    });
-    if (result.success) {
-      return new Response(result.code, {
-        headers: {
-          "Content-Type": "application/javascript",
-          "Cache-Control": "no-cache, no-store, must-revalidate"
-        }
-      });
-    }
-  }
-  const decodedPathname = decodeURIComponent(url.pathname);
-  let filePath;
-  let rootPath;
-  if (decodedPathname.startsWith("/fonts/") || decodedPathname.startsWith("/images/") || decodedPathname.startsWith("/icons/") || decodedPathname.startsWith("/assets/") || decodedPathname.startsWith("/libraries/") || decodedPathname.startsWith("/videos/")) {
-    rootPath = getProjectRoot();
-    filePath = resolveProjectPath(decodedPathname.slice(1));
-  } else {
-    rootPath = getPackageRoot();
-    filePath = resolvePackagePath(decodedPathname.slice(1));
-  }
-  if (!isPathWithinRoot(filePath, rootPath)) {
-    return new Response("Forbidden", { status: 403 });
-  }
-  if (await fileExists(filePath)) {
-    const cacheControl = decodedPathname.startsWith("/libraries/") ? "no-cache, no-store, must-revalidate" : "public, max-age=31536000, immutable";
-    return serveFile(filePath, { "Cache-Control": cacheControl });
-  }
-  return void 0;
-}
-
-// lib/server/routes/index.ts
-async function handleRoutes(req, url, server, context) {
-  const startTime = Date.now();
-  const { pageService, componentService, cmsService, cmsProvider } = context;
-  logRequest(req);
-  const corsResponse = handleCorsPreflight(req);
-  if (corsResponse) {
-    logResponseTime(startTime, req);
-    return corsResponse;
-  }
-  try {
-    if (url.pathname === HMR_ROUTE) {
-      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,
-      url,
-      pageService,
-      componentService,
-      cmsContext
-    );
-    if (apiResponse) {
-      logResponseTime(startTime, req);
-      return apiResponse;
-    }
-    if (url.pathname.startsWith("/data/") && url.pathname.endsWith("/index.json") && cmsService) {
-      const match = url.pathname.match(/^\/data\/([^/]+)\/index\.json$/);
-      if (match) {
-        const collectionId = match[1];
-        try {
-          const i18nConfig = await loadI18nConfig();
-          let refererPath = "/";
-          try {
-            const referer = req.headers.get("referer");
-            if (referer) refererPath = new URL(referer).pathname;
-          } catch {
-          }
-          const { locale } = parseLocaleFromPath(refererPath, i18nConfig);
-          const items = await cmsService.queryItems({ collection: collectionId, excludeDraftLocale: locale });
-          logResponseTime(startTime, req);
-          return new Response(JSON.stringify(items), {
-            headers: {
-              "Content-Type": "application/json",
-              "Cache-Control": "no-cache"
-            }
-          });
-        } catch {
-          logResponseTime(startTime, req);
-          return new Response("[]", {
-            headers: { "Content-Type": "application/json" }
-          });
-        }
-      }
-    }
-    if (url.pathname.startsWith("/_scripts/") && url.pathname.endsWith(".js")) {
-      const hash = url.pathname.slice(10, -3);
-      const script = getScript(hash);
-      if (script) {
-        logResponseTime(startTime, req);
-        return new Response(script, {
-          headers: {
-            "Content-Type": "application/javascript",
-            "Cache-Control": "no-cache"
-          }
-        });
-      }
-    }
-    if (url.pathname.startsWith("/images/") || url.pathname.startsWith("/videos/") || url.pathname.startsWith("/assets/") || url.pathname.startsWith("/public/") || url.pathname.startsWith("/icons/")) {
-      const response2 = await handleStaticRoute(url, req);
-      if (response2) {
-        logResponseTime(startTime, req);
-        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);
-      return response2;
-    }
-    const response = await handleStaticRoute(url, req);
-    logResponseTime(startTime, req);
-    return response;
-  } catch (error) {
-    logResponseTime(startTime, req);
-    return handleRouteError(
-      () => Promise.reject(error),
-      `Error handling route: ${url.pathname}`
-    );
-  }
-}
-
-// lib/server/createServer.ts
-init_constants();
-var COLLAB_ROUTE = "/__collab";
-async function createServer(config) {
-  const {
-    port: requestedPort = SERVER_PORT,
-    pageService,
-    componentService,
-    wsManager,
-    cmsService,
-    cmsProvider,
-    draftPageStore,
-    additionalRoutes = [],
-    onWSMessage,
-    injectLiveReload,
-    isEditor,
-    onCollabWSMessage,
-    onCollabWSOpen,
-    onCollabWSClose
-  } = config;
-  const collabClients = /* @__PURE__ */ new WeakSet();
-  const routeContext = {
-    pageService,
-    componentService,
-    cmsService,
-    cmsProvider,
-    injectLiveReload,
-    isEditor,
-    wsManager,
-    draftPageStore
-  };
-  let boundPort;
-  let lastError;
-  for (let portAttempt = 0; portAttempt < MAX_PORT_ATTEMPTS; portAttempt++) {
-    const currentPort = requestedPort + portAttempt;
-    try {
-      const server = await createRuntimeServer({
-        port: currentPort,
-        hostname: "localhost",
-        wsPath: HMR_ROUTE,
-        async fetch(req, upgradeWebSocket) {
-          const url = new URL(req.url);
-          for (const handler of additionalRoutes) {
-            const response2 = await handler(req, url, routeContext);
-            if (response2) {
-              return response2;
-            }
-          }
-          if (url.pathname === HMR_ROUTE) {
-            const success = upgradeWebSocket(req);
-            return success ? void 0 : new Response("WebSocket upgrade failed", { status: 500 });
-          }
-          if (url.pathname === COLLAB_ROUTE && onCollabWSMessage) {
-            const success = upgradeWebSocket(req);
-            return success ? void 0 : new Response("WebSocket upgrade failed", { status: 500 });
-          }
-          const response = await handleRoutes(req, url, null, routeContext);
-          return response || new Response("Not Found", { status: 404 });
-        },
-        websocket: {
-          open(ws) {
-            wsManager.addClient(ws);
-            onCollabWSOpen?.(ws);
-          },
-          message(ws, message) {
-            try {
-              const data = JSON.parse(message);
-              if (data.type === "ping") {
-                ws.send("pong");
-                return;
-              }
-              if (onCollabWSMessage && typeof data.type === "string" && data.type.startsWith("collab:")) {
-                collabClients.add(ws);
-                onCollabWSMessage(ws, data);
-                return;
-              }
-              if (onWSMessage) {
-                onWSMessage(ws, data);
-              }
-            } catch (error) {
-            }
-          },
-          close(ws) {
-            wsManager.removeClient(ws);
-            if (collabClients.has(ws)) {
-              onCollabWSClose?.(ws);
-              collabClients.delete(ws);
-            }
-          }
-        }
-      });
-      if (portAttempt > 0) {
-        console.log(`Warning: Port ${requestedPort} was busy, using port ${server.port} instead`);
-      }
-      routeContext.serverPort = server.port;
-      return { server, port: server.port };
-    } catch (error) {
-      lastError = error;
-      const err = error;
-      if (err?.code === "EADDRINUSE") {
-        if (portAttempt >= MAX_PORT_ATTEMPTS - 1) {
-          console.error(
-            `Failed to start server: All ports from ${requestedPort} to ${requestedPort + MAX_PORT_ATTEMPTS - 1} are busy`
-          );
-          throw error;
-        }
-        continue;
-      }
-      throw error;
-    }
-  }
-  throw lastError || new Error("Failed to start server");
-}
-
-// lib/server/providers/fileSystemPageProvider.ts
-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
-var isJSONFile = (name) => name.endsWith(".json");
-var stripExtension = (name) => {
-  const lastDotIndex = name.lastIndexOf(".");
-  return lastDotIndex > 0 ? name.substring(0, lastDotIndex) : name;
-};
-var mapPageNameToPath2 = (pageName) => {
-  return pageName === "index" ? "/" : `/${pageName}`;
-};
-var mapPathToPageName = (path2) => {
-  return path2 === "/" ? "index" : path2.substring(1);
-};
-
-// lib/server/providers/fileSystemPageProvider.ts
-async function loadJSONFile2(filePath) {
-  try {
-    if (await fileExists(filePath)) {
-      return await readTextFile(filePath);
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-var FileSystemPageProvider = class {
-  constructor(pagesDir, templatesDir) {
-    this.pagesDir = pagesDir;
-    this.templatesDir = templatesDir;
-  }
-  async loadAll() {
-    const pages = /* @__PURE__ */ new Map();
-    if (existsSync4(this.pagesDir)) {
-      await this.scanDirectory(this.pagesDir, "", pages);
-    }
-    if (this.templatesDir && existsSync4(this.templatesDir)) {
-      await this.scanDirectory(this.templatesDir, "templates", pages);
-    }
-    return pages;
-  }
-  /**
-   * Recursively scan a directory for JSON page files
-   * @param dir - Absolute directory path to scan
-   * @param prefix - Relative prefix for page names (e.g., '' for root, 'blog' for blog/)
-   */
-  async scanDirectory(dir, prefix, pages) {
-    const entries = readdirSync3(dir, { withFileTypes: true });
-    const fileEntries = entries.filter((e) => e.isFile() && isJSONFile(e.name));
-    const dirEntries = entries.filter((e) => e.isDirectory());
-    await Promise.all([
-      ...fileEntries.map(async (entry) => {
-        const pageName = prefix ? `${prefix}/${stripExtension(entry.name)}` : stripExtension(entry.name);
-        const content = await loadJSONFile2(join4(dir, entry.name));
-        if (content) {
-          const pagePath = mapPageNameToPath2(pageName);
-          pages.set(pagePath, content);
-        }
-      }),
-      ...dirEntries.map((entry) => {
-        const subPrefix = prefix ? `${prefix}/${entry.name}` : entry.name;
-        return this.scanDirectory(join4(dir, entry.name), subPrefix, pages);
-      })
-    ]);
-  }
-  /**
-   * Resolve a page path to its filesystem file path
-   * Routes /templates/* paths to the templates directory
-   */
-  resolveFilePath(path2) {
-    const pageName = mapPathToPageName(path2);
-    if (this.templatesDir && pageName.startsWith("templates/")) {
-      const templateName = pageName.substring("templates/".length);
-      return join4(this.templatesDir, `${templateName}.json`);
-    }
-    return join4(this.pagesDir, `${pageName}.json`);
-  }
-  /**
-   * Resolve the root directory for cleanup operations
-   * Returns the appropriate root dir (templates or pages) for a given path
-   */
-  resolveRootDir(path2) {
-    const pageName = mapPathToPageName(path2);
-    if (this.templatesDir && pageName.startsWith("templates/")) {
-      return this.templatesDir;
-    }
-    return this.pagesDir;
-  }
-  async get(path2) {
-    const filePath = this.resolveFilePath(path2);
-    return loadJSONFile2(filePath);
-  }
-  async save(path2, content) {
-    const { writeFile: writeFile2 } = await import("fs/promises");
-    const filePath = this.resolveFilePath(path2);
-    const dir = dirname2(filePath);
-    if (!existsSync4(dir)) {
-      mkdirSync3(dir, { recursive: true });
-    }
-    await writeFile2(filePath, content, "utf-8");
-  }
-  async delete(path2) {
-    const { unlink } = await import("fs/promises");
-    const filePath = this.resolveFilePath(path2);
-    const rootDir = this.resolveRootDir(path2);
-    if (existsSync4(filePath)) {
-      await unlink(filePath);
-      let dir = dirname2(filePath);
-      while (dir !== rootDir) {
-        try {
-          const remaining = readdirSync3(dir);
-          if (remaining.length === 0) {
-            rmdirSync3(dir);
-          } else {
-            break;
-          }
-        } catch {
-          break;
-        }
-        dir = dirname2(dir);
-      }
-    }
-  }
-  async exists(path2) {
-    const filePath = this.resolveFilePath(path2);
-    return existsSync4(filePath);
-  }
-  baseDir() {
-    return this.pagesDir;
-  }
-  extension() {
-    return ".json";
-  }
-};
-
-export {
-  PageCache,
-  WebSocketManager,
-  buildLineMap,
-  lineMapToObject,
-  PageService,
-  ComponentService,
-  EnumService,
-  enumService,
-  FileWatcherService,
-  createCorsHeaders,
-  handleCorsPreflight,
-  createErrorResponse,
-  handleRouteError,
-  withErrorHandling,
-  logRequest,
-  logError,
-  logResponseTime,
-  withLogging,
-  jsonResponse,
-  errorResponse,
-  handleCollectionsRoute,
-  handleCollectionSchemaRoute,
-  handleItemsRoute,
-  handleItemRoute,
-  handleCoreApiRoutes,
-  createServer,
-  FileSystemPageProvider
-};
-//# sourceMappingURL=chunk-R6XHAFBF.js.map