@imjp/writenex-astro 0.1.0

package/dist/chunk-7XU5X6CW.js

@@ -0,0 +1,1331 @@
+import {
+  discoverCollections,
+  mergeCollections
+} from "./chunk-CYLDJ3HZ.js";
+import {
+  ApiBadRequestError,
+  ApiMethodNotAllowedError,
+  CollectionDiscoveryError,
+  CollectionNotFoundError,
+  ContentNotFoundError,
+  ImageInvalidTypeError,
+  ImageNotFoundError,
+  PathTraversalError,
+  VersionNotFoundError,
+  clearVersions,
+  createContent,
+  deleteContent,
+  deleteVersion,
+  discoverContentImages,
+  getVersion,
+  getVersions,
+  isValidImageFile,
+  isWritenexError,
+  parseMultipartFormData,
+  restoreVersion,
+  saveVersion,
+  updateContent,
+  uploadImage,
+  wrapError
+} from "./chunk-CF2XXJFF.js";
+import {
+  getCollectionSummaries,
+  getContentFilePath,
+  readContentFile
+} from "./chunk-AAOQHQPU.js";
+
+// src/server/cache.ts
+var DEFAULT_TTL_MS = 5 * 60 * 1e3;
+var DEV_TTL_MS = 30 * 1e3;
+var ServerCache = class {
+  /** Cache for collection discovery results */
+  collectionsCache = null;
+  /** Cache for content summaries, keyed by collection name */
+  contentCache = /* @__PURE__ */ new Map();
+  /** Cache for discovered images, keyed by "collection:contentId" */
+  imagesCache = /* @__PURE__ */ new Map();
+  /** Time-to-live for cache entries in milliseconds */
+  ttl;
+  /** Whether file watcher is integrated (allows longer TTL) */
+  hasWatcher = false;
+  constructor(options = {}) {
+    this.ttl = options.ttl ?? (options.hasWatcher ? DEFAULT_TTL_MS : DEV_TTL_MS);
+    this.hasWatcher = options.hasWatcher ?? false;
+  }
+  /**
+   * Enable file watcher integration
+   *
+   * When watcher is enabled, cache can use longer TTL since
+   * invalidation happens via watcher events.
+   */
+  enableWatcher() {
+    this.hasWatcher = true;
+    this.ttl = DEFAULT_TTL_MS;
+  }
+  /**
+   * Check if a cache entry is still valid
+   */
+  isValid(entry) {
+    if (!entry) return false;
+    return Date.now() - entry.timestamp < this.ttl;
+  }
+  // ==================== Collections Cache ====================
+  /**
+   * Get cached collections if valid
+   *
+   * @returns Cached collections or null if expired/not cached
+   */
+  getCollections() {
+    if (this.isValid(this.collectionsCache)) {
+      return this.collectionsCache.data;
+    }
+    return null;
+  }
+  /**
+   * Set collections cache
+   *
+   * @param collections - Collections to cache
+   */
+  setCollections(collections) {
+    this.collectionsCache = {
+      data: collections,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Invalidate collections cache
+   */
+  invalidateCollections() {
+    this.collectionsCache = null;
+  }
+  // ==================== Content Cache ====================
+  /**
+   * Get cached content summaries for a collection if valid
+   *
+   * @param collection - Collection name
+   * @returns Cached content summaries or null if expired/not cached
+   */
+  getContent(collection) {
+    const entry = this.contentCache.get(collection);
+    if (this.isValid(entry)) {
+      return entry.data;
+    }
+    return null;
+  }
+  /**
+   * Set content cache for a collection
+   *
+   * @param collection - Collection name
+   * @param items - Content summaries to cache
+   */
+  setContent(collection, items) {
+    this.contentCache.set(collection, {
+      data: items,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Invalidate content cache for a specific collection
+   *
+   * @param collection - Collection name to invalidate
+   */
+  invalidateContent(collection) {
+    this.contentCache.delete(collection);
+  }
+  /**
+   * Invalidate all content caches
+   */
+  invalidateAllContent() {
+    this.contentCache.clear();
+  }
+  // ==================== Images Cache ====================
+  /**
+   * Generate cache key for image cache
+   *
+   * @param collection - Collection name
+   * @param contentId - Content ID
+   * @returns Cache key string
+   */
+  getImagesCacheKey(collection, contentId) {
+    return `${collection}:${contentId}`;
+  }
+  /**
+   * Get cached images for a content item if valid
+   *
+   * @param collection - Collection name
+   * @param contentId - Content ID
+   * @returns Cached images or null if expired/not cached
+   */
+  getImages(collection, contentId) {
+    const key = this.getImagesCacheKey(collection, contentId);
+    const entry = this.imagesCache.get(key);
+    if (this.isValid(entry)) {
+      return entry.data;
+    }
+    return null;
+  }
+  /**
+   * Set images cache for a content item
+   *
+   * @param collection - Collection name
+   * @param contentId - Content ID
+   * @param images - Discovered images to cache
+   */
+  setImages(collection, contentId, images) {
+    const key = this.getImagesCacheKey(collection, contentId);
+    this.imagesCache.set(key, {
+      data: images,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Invalidate image cache for a specific content item
+   *
+   * @param collection - Collection name
+   * @param contentId - Content ID
+   */
+  invalidateImages(collection, contentId) {
+    const key = this.getImagesCacheKey(collection, contentId);
+    this.imagesCache.delete(key);
+  }
+  /**
+   * Invalidate all image caches for a collection
+   *
+   * @param collection - Collection name
+   */
+  invalidateCollectionImages(collection) {
+    const prefix = `${collection}:`;
+    for (const key of this.imagesCache.keys()) {
+      if (key.startsWith(prefix)) {
+        this.imagesCache.delete(key);
+      }
+    }
+  }
+  /**
+   * Invalidate all image caches
+   */
+  invalidateAllImages() {
+    this.imagesCache.clear();
+  }
+  // ==================== Bulk Invalidation ====================
+  /**
+   * Invalidate all caches
+   *
+   * Called when a major change occurs that affects everything.
+   */
+  invalidateAll() {
+    this.collectionsCache = null;
+    this.contentCache.clear();
+    this.imagesCache.clear();
+  }
+  /**
+   * Handle file change event from watcher
+   *
+   * Intelligently invalidates only the affected caches.
+   *
+   * @param type - Type of file change (add, change, unlink)
+   * @param collection - Collection that was affected
+   * @param contentId - Optional content ID for targeted image cache invalidation
+   */
+  handleFileChange(type, collection, contentId) {
+    this.invalidateContent(collection);
+    if (contentId) {
+      this.invalidateImages(collection, contentId);
+    } else {
+      this.invalidateCollectionImages(collection);
+    }
+    if (type === "add" || type === "unlink") {
+      this.invalidateCollections();
+    }
+  }
+  // ==================== Stats ====================
+  /**
+   * Get cache statistics for debugging
+   *
+   * @returns Object with cache stats
+   */
+  getStats() {
+    return {
+      collectionsValid: this.isValid(this.collectionsCache),
+      contentCollections: Array.from(this.contentCache.keys()).filter(
+        (key) => this.isValid(this.contentCache.get(key))
+      ),
+      cachedImages: Array.from(this.imagesCache.keys()).filter(
+        (key) => this.isValid(this.imagesCache.get(key))
+      ),
+      ttl: this.ttl,
+      hasWatcher: this.hasWatcher
+    };
+  }
+};
+var globalCache = null;
+function getCache(options) {
+  if (!globalCache) {
+    globalCache = new ServerCache(options);
+  }
+  return globalCache;
+}
+function resetCache() {
+  globalCache = null;
+}
+
+// src/server/routes.ts
+import { createReadStream, existsSync as existsSync2, statSync } from "fs";
+import { join as join2, extname as extname2 } from "path";
+
+// src/server/assets.ts
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join, extname } from "path";
+import { fileURLToPath } from "url";
+function getPackageRoot() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = fileURLToPath(new URL(".", import.meta.url));
+  if (currentFile.endsWith("dist/index.js") || currentDir.endsWith("dist/")) {
+    return join(currentDir, "..");
+  }
+  if (currentDir.includes("/src/")) {
+    return join(currentDir, "..", "..");
+  }
+  return join(currentDir, "..");
+}
+var PACKAGE_ROOT = getPackageRoot();
+var MIME_TYPES = {
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf"
+};
+async function serveEditorHtml(_req, res, context) {
+  const { basePath } = context;
+  const html = generateEditorHtml(basePath);
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "text/html; charset=utf-8");
+  res.setHeader("Cache-Control", "no-cache");
+  res.end(html);
+}
+async function serveAsset(_req, res, assetPath, _context) {
+  const distPath = join(PACKAGE_ROOT, "dist", "client", assetPath);
+  if (!existsSync(distPath)) {
+    console.error("[writenex] Asset not found:", distPath);
+    res.statusCode = 404;
+    res.setHeader("Content-Type", "text/plain");
+    res.end(`Asset not found: ${assetPath}`);
+    return;
+  }
+  const filePath = distPath;
+  try {
+    const content = await readFile(filePath);
+    const ext = extname(assetPath).toLowerCase();
+    const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
+    res.statusCode = 200;
+    res.setHeader("Content-Type", mimeType);
+    res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+    res.end(content);
+  } catch (error) {
+    console.error(`[writenex] Failed to serve asset: ${assetPath}`, error);
+    res.statusCode = 500;
+    res.setHeader("Content-Type", "text/plain");
+    res.end("Failed to read asset");
+  }
+}
+function generateEditorHtml(basePath) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="robots" content="noindex, nofollow">
+  <title>Writenex - Content Editor</title>
+  
+  <!-- Editor styles -->
+  <link rel="stylesheet" href="${basePath}/assets/index.css">
+  <link rel="stylesheet" href="${basePath}/assets/styles.css">
+  
+  <style>
+    /* Critical CSS for initial load */
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    
+    html, body, #root {
+      height: 100%;
+      width: 100%;
+    }
+    
+    body {
+      font-family: 'Plus Jakarta Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+      background-color: #0a0a0a;
+      color: #fafafa;
+    }
+    
+    /* Loading state */
+    .writenex-loading {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      height: 100%;
+      gap: 1rem;
+    }
+    
+    .writenex-loading-spinner {
+      width: 40px;
+      height: 40px;
+      border: 3px solid rgba(59, 130, 246, 0.2);
+      border-top-color: #3b82f6;
+      border-radius: 50%;
+      animation: spin 1s linear infinite;
+    }
+    
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+    
+    .writenex-loading-text {
+      color: #71717a;
+      font-size: 0.875rem;
+    }
+  </style>
+</head>
+<body>
+  <div id="root">
+    <!-- Loading state shown while React loads -->
+    <div class="writenex-loading">
+      <div class="writenex-loading-spinner"></div>
+      <div class="writenex-loading-text">Loading Writenex Editor...</div>
+    </div>
+  </div>
+  
+  <!-- Configuration for the client app -->
+  <script>
+    window.__WRITENEX_CONFIG__ = {
+      basePath: "${basePath}",
+      apiBase: "${basePath}/api",
+    };
+  </script>
+  
+  <!-- Editor application -->
+  <script type="module" src="${basePath}/assets/index.js"></script>
+</body>
+</html>`;
+}
+function getClientDistPath() {
+  return join(PACKAGE_ROOT, "dist", "client");
+}
+function hasClientBundle() {
+  const indexPath = join(getClientDistPath(), "index.js");
+  return existsSync(indexPath);
+}
+
+// src/server/middleware.ts
+function createMiddleware(context) {
+  const { basePath } = context;
+  const apiRouter = createApiRouter(context);
+  return async (req, res, next) => {
+    const url = req.url ?? "";
+    if (!url.startsWith(basePath)) {
+      return next();
+    }
+    const path = url.slice(basePath.length) || "/";
+    try {
+      if (path.startsWith("/api/")) {
+        return await apiRouter(req, res, path.slice(4));
+      }
+      if (path.startsWith("/assets/")) {
+        return await serveAsset(req, res, path.slice(8), context);
+      }
+      return await serveEditorHtml(req, res, context);
+    } catch (error) {
+      const writenexError = isWritenexError(error) ? error : wrapError(error, "API_INTERNAL_ERROR" /* API_INTERNAL_ERROR */);
+      console.error(
+        `[writenex] Middleware error [${writenexError.code}]: ${writenexError.message}`
+      );
+      res.statusCode = writenexError.httpStatus;
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify(writenexError.toJSON()));
+    }
+  };
+}
+function parseQueryParams(url) {
+  const queryIndex = url.indexOf("?");
+  if (queryIndex === -1) return {};
+  const queryString = url.slice(queryIndex + 1);
+  const params = {};
+  for (const pair of queryString.split("&")) {
+    const [key, value] = pair.split("=");
+    if (key) {
+      params[decodeURIComponent(key)] = value ? decodeURIComponent(value) : "";
+    }
+  }
+  return params;
+}
+async function parseJsonBody(req) {
+  return new Promise((resolve) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      if (!body) {
+        resolve(null);
+        return;
+      }
+      try {
+        resolve(JSON.parse(body));
+      } catch {
+        resolve(null);
+      }
+    });
+    req.on("error", () => {
+      resolve(null);
+    });
+  });
+}
+function sendJson(res, data, statusCode = 200) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(data));
+}
+function sendError(res, message, statusCode = 400) {
+  sendJson(res, { error: message }, statusCode);
+}
+function sendWritenexError(res, error) {
+  sendJson(res, error.toJSON(), error.httpStatus);
+}
+
+// src/server/routes.ts
+function createApiRouter(context) {
+  return async (req, res, path) => {
+    const method = req.method?.toUpperCase() ?? "GET";
+    const query = parseQueryParams(req.url ?? "");
+    const pathWithoutQuery = path.split("?")[0] ?? path;
+    const segments = pathWithoutQuery.split("/").filter(Boolean);
+    const params = { query };
+    if (segments[0] === "collections") {
+      if (method === "GET") {
+        return handleGetCollections(req, res, params, context);
+      }
+      return sendWritenexError(
+        res,
+        new ApiMethodNotAllowedError(method, ["GET"])
+      );
+    }
+    if (segments[0] === "config") {
+      if (method === "GET") {
+        if (segments[1] === "path") {
+          return handleGetConfigPath(req, res, params, context);
+        }
+        return handleGetConfig(req, res, params, context);
+      }
+      return sendWritenexError(
+        res,
+        new ApiMethodNotAllowedError(method, ["GET"])
+      );
+    }
+    if (segments[0] === "content") {
+      params.collection = segments[1];
+      params.id = segments[2];
+      switch (method) {
+        case "GET":
+          if (params.id) {
+            return handleGetContent(req, res, params, context);
+          }
+          return handleListContent(req, res, params, context);
+        case "POST":
+          return handleCreateContent(req, res, params, context);
+        case "PUT":
+          return handleUpdateContent(req, res, params, context);
+        case "DELETE":
+          return handleDeleteContent(req, res, params, context);
+        default:
+          return sendWritenexError(
+            res,
+            new ApiMethodNotAllowedError(method, [
+              "GET",
+              "POST",
+              "PUT",
+              "DELETE"
+            ])
+          );
+      }
+    }
+    if (segments[0] === "images") {
+      params.collection = segments[1];
+      params.id = segments[2];
+      if (method === "GET" && params.collection && params.id && segments.length > 3) {
+        const imagePath = segments.slice(3).join("/");
+        return handleServeImage(req, res, params, imagePath, context);
+      }
+      if (method === "GET" && params.collection && params.id) {
+        return handleImageDiscovery(req, res, params, context);
+      }
+      if (method === "POST") {
+        return handleImageUpload(req, res, params, context);
+      }
+      return sendWritenexError(
+        res,
+        new ApiMethodNotAllowedError(method, ["GET", "POST"])
+      );
+    }
+    if (segments[0] === "versions") {
+      params.collection = segments[1];
+      params.id = segments[2];
+      params.versionId = segments[3];
+      const action = segments[4];
+      switch (method) {
+        case "GET":
+          if (params.versionId) {
+            if (action === "diff") {
+              return handleGetVersionDiff(req, res, params, context);
+            }
+            return handleGetVersion(req, res, params, context);
+          }
+          return handleListVersions(req, res, params, context);
+        case "POST":
+          if (params.versionId && action === "restore") {
+            return handleRestoreVersion(req, res, params, context);
+          }
+          if (!params.versionId) {
+            return handleCreateVersion(req, res, params, context);
+          }
+          return sendWritenexError(
+            res,
+            new ApiMethodNotAllowedError(method, ["GET", "POST", "DELETE"])
+          );
+        case "DELETE":
+          if (params.versionId) {
+            return handleDeleteVersion(req, res, params, context);
+          }
+          return handleClearVersions(req, res, params, context);
+        default:
+          return sendWritenexError(
+            res,
+            new ApiMethodNotAllowedError(method, ["GET", "POST", "DELETE"])
+          );
+      }
+    }
+    if (segments[0] === "health") {
+      return sendJson(res, {
+        status: "ok",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return sendError(res, "Not found", 404);
+  };
+}
+var handleGetConfig = async (_req, res, _params, context) => {
+  const { config, trailingSlash } = context;
+  sendJson(res, {
+    images: config.images,
+    editor: config.editor,
+    trailingSlash
+  });
+};
+var handleGetConfigPath = async (_req, res, _params, context) => {
+  const { projectRoot } = context;
+  const { findConfigFile } = await import("./loader-55LWCXHA.js");
+  const configPath = findConfigFile(projectRoot);
+  sendJson(res, {
+    configPath,
+    projectRoot,
+    hasConfigFile: configPath !== null
+  });
+};
+var handleGetCollections = async (_req, res, _params, context) => {
+  const { config, projectRoot } = context;
+  const cache = getCache();
+  try {
+    let collections = cache.getCollections();
+    if (!collections) {
+      const discovered = await discoverCollections(projectRoot);
+      collections = mergeCollections(discovered, config.collections);
+      cache.setCollections(collections);
+    }
+    sendJson(res, { collections });
+  } catch (error) {
+    const wrappedError = isWritenexError(error) ? error : new CollectionDiscoveryError(
+      join2(projectRoot, "src/content"),
+      error instanceof Error ? error : void 0
+    );
+    sendWritenexError(res, wrappedError);
+  }
+};
+var handleListContent = async (_req, res, params, context) => {
+  const { collection, query } = params;
+  const { projectRoot } = context;
+  if (!collection) {
+    return sendWritenexError(
+      res,
+      new ApiBadRequestError("Collection name required")
+    );
+  }
+  const cache = getCache();
+  try {
+    const collectionPath = join2(projectRoot, "src/content", collection);
+    if (!existsSync2(collectionPath)) {
+      return sendWritenexError(res, new CollectionNotFoundError(collection));
+    }
+    const includeDrafts = query.draft === "true";
+    const sortBy = query.sort ?? "pubDate";
+    const sortOrder = query.order ?? "desc";
+    const isDefaultQuery = includeDrafts && sortBy === "pubDate" && sortOrder === "desc";
+    let items = isDefaultQuery ? cache.getContent(collection) : null;
+    if (!items) {
+      items = await getCollectionSummaries(collectionPath, {
+        includeDrafts,
+        sortBy,
+        sortOrder
+      });
+      if (isDefaultQuery) {
+        cache.setContent(collection, items);
+      }
+    }
+    sendJson(res, {
+      items,
+      total: items.length
+    });
+  } catch (error) {
+    console.error("[writenex] List content error:", error);
+    const wrappedError = isWritenexError(error) ? error : wrapError(error, "API_INTERNAL_ERROR" /* API_INTERNAL_ERROR */);
+    sendWritenexError(res, wrappedError);
+  }
+};
+var handleGetContent = async (_req, res, params, context) => {
+  const { collection, id } = params;
+  const { projectRoot } = context;
+  if (!collection || !id) {
+    return sendWritenexError(
+      res,
+      new ApiBadRequestError("Collection and content ID required")
+    );
+  }
+  try {
+    const collectionPath = join2(projectRoot, "src/content", collection);
+    const filePath = getContentFilePath(collectionPath, id);
+    if (!filePath) {
+      return sendWritenexError(res, new ContentNotFoundError(collection, id));
+    }
+    const result = await readContentFile(filePath, collectionPath);
+    if (!result.success || !result.content) {
+      return sendError(res, result.error ?? "Failed to read content", 500);
+    }
+    sendJson(res, result.content);
+  } catch (error) {
+    const wrappedError = isWritenexError(error) ? error : wrapError(error, "API_INTERNAL_ERROR" /* API_INTERNAL_ERROR */);
+    sendWritenexError(res, wrappedError);
+  }
+};
+var handleCreateContent = async (req, res, params, context) => {
+  const { collection } = params;
+  const { projectRoot, config } = context;
+  if (!collection) {
+    return sendError(res, "Collection name required", 400);
+  }
+  try {
+    const body = await parseJsonBody(req);
+    if (!body || typeof body !== "object") {
+      return sendError(res, "Invalid request body", 400);
+    }
+    const {
+      frontmatter,
+      body: contentBody,
+      slug
+    } = body;
+    if (!frontmatter) {
+      return sendError(res, "Frontmatter is required", 400);
+    }
+    const collectionPath = join2(projectRoot, "src/content", collection);
+    const cache = getCache();
+    let filePattern;
+    const configuredCollection = config.collections.find(
+      (c) => c.name === collection
+    );
+    if (configuredCollection?.filePattern) {
+      filePattern = configuredCollection.filePattern;
+    } else {
+      let collections = cache.getCollections();
+      if (!collections) {
+        const discovered = await discoverCollections(projectRoot);
+        collections = mergeCollections(discovered, config.collections);
+        cache.setCollections(collections);
+      }
+      const discoveredCollection = collections.find(
+        (c) => c.name === collection
+      );
+      if (discoveredCollection?.filePattern) {
+        filePattern = discoveredCollection.filePattern;
+      }
+    }
+    const result = await createContent(collectionPath, {
+      frontmatter,
+      body: contentBody ?? "",
+      slug,
+      filePattern
+    });
+    if (!result.success) {
+      return sendError(res, result.error ?? "Failed to create content", 500);
+    }
+    cache.handleFileChange("add", collection);
+    sendJson(res, {
+      success: true,
+      id: result.id,
+      path: result.path
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    sendError(res, `Failed to create content: ${message}`, 500);
+  }
+};
+var handleUpdateContent = async (req, res, params, context) => {
+  const { collection, id } = params;
+  const { projectRoot, config } = context;
+  if (!collection || !id) {
+    return sendWritenexError(
+      res,
+      new ApiBadRequestError("Collection and content ID required")
+    );
+  }
+  try {
+    const body = await parseJsonBody(req);
+    if (!body || typeof body !== "object") {
+      return sendWritenexError(
+        res,
+        new ApiBadRequestError("Invalid request body")
+      );
+    }
+    const {
+      frontmatter,
+      body: contentBody,
+      expectedMtime,
+      forceOverwrite
+    } = body;
+    const collectionPath = join2(projectRoot, "src/content", collection);
+    const filePath = getContentFilePath(collectionPath, id);
+    if (!filePath) {
+      return sendWritenexError(res, new ContentNotFoundError(collection, id));
+    }
+    const result = await updateContent(filePath, collectionPath, {
+      frontmatter,
+      body: contentBody,
+      projectRoot,
+      collection,
+      versionHistoryConfig: config.versionHistory,
+      // Only check mtime if not forcing overwrite
+      expectedMtime: forceOverwrite ? void 0 : expectedMtime
+    });
+    if (!result.success && result.conflict) {
+      return sendWritenexError(res, result.conflict);
+    }
+    if (!result.success) {
+      return sendError(res, result.error ?? "Failed to update content", 500);
+    }
+    const cache = getCache();
+    cache.handleFileChange("change", collection);
+    sendJson(res, {
+      success: true,
+      id: result.id,
+      path: result.path,
+      mtime: result.mtime
+    });
+  } catch (error) {
+    const wrappedError = isWritenexError(error) ? error : wrapError(error, "API_INTERNAL_ERROR" /* API_INTERNAL_ERROR */);
+    sendWritenexError(res, wrappedError);
+  }
+};
+var handleDeleteContent = async (_req, res, params, context) => {
+  const { collection, id } = params;
+  const { projectRoot } = context;
+  if (!collection || !id) {
+    return sendError(res, "Collection and content ID required", 400);
+  }
+  try {
+    const collectionPath = join2(projectRoot, "src/content", collection);
+    const filePath = getContentFilePath(collectionPath, id);
+    if (!filePath) {
+      return sendError(
+        res,
+        `Content '${id}' not found in '${collection}'`,
+        404
+      );
+    }
+    const result = await deleteContent(filePath);
+    if (!result.success) {
+      return sendError(res, result.error ?? "Failed to delete content", 500);
+    }
+    const cache = getCache();
+    cache.handleFileChange("unlink", collection);
+    sendJson(res, {
+      success: true,
+      path: result.path
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    sendError(res, `Failed to delete content: ${message}`, 500);
+  }
+};
+var handleImageUpload = async (req, res, _params, context) => {
+  const { projectRoot, config } = context;
+  try {
+    const chunks = [];
+    for await (const chunk of req) {
+      chunks.push(chunk);
+    }
+    const body = Buffer.concat(chunks);
+    const contentType = req.headers["content-type"] ?? "";
+    if (!contentType.includes("multipart/form-data")) {
+      return sendWritenexError(
+        res,
+        new ApiBadRequestError("Content-Type must be multipart/form-data")
+      );
+    }
+    const { file, fields } = parseMultipartFormData(body, contentType);
+    if (!file) {
+      return sendWritenexError(res, new ApiBadRequestError("No file uploaded"));
+    }
+    if (!fields.collection || !fields.contentId) {
+      return sendWritenexError(
+        res,
+        new ApiBadRequestError("collection and contentId are required")
+      );
+    }
+    if (!isValidImageFile(file.filename)) {
+      return sendWritenexError(
+        res,
+        new ImageInvalidTypeError(file.filename, [
+          ".jpg",
+          ".jpeg",
+          ".png",
+          ".gif",
+          ".webp",
+          ".avif",
+          ".svg"
+        ])
+      );
+    }
+    const result = await uploadImage({
+      filename: file.filename,
+      data: file.data,
+      collection: fields.collection,
+      contentId: fields.contentId,
+      projectRoot,
+      config: config.images
+    });
+    if (!result.success) {
+      return sendError(res, result.error ?? "Failed to upload image", 500);
+    }
+    sendJson(res, {
+      success: true,
+      path: result.path,
+      url: result.url
+    });
+  } catch (error) {
+    const wrappedError = isWritenexError(error) ? error : wrapError(error, "IMAGE_UPLOAD_ERROR" /* IMAGE_UPLOAD_ERROR */);
+    sendWritenexError(res, wrappedError);
+  }
+};
+var handleImageDiscovery = async (_req, res, params, context) => {
+  const { collection, id: contentId } = params;
+  const { projectRoot } = context;
+  if (!collection || !contentId) {
+    return sendError(res, "Collection and content ID required", 400);
+  }
+  const cache = getCache();
+  try {
+    const collectionPath = join2(projectRoot, "src/content", collection);
+    let collections = cache.getCollections();
+    if (!collections) {
+      collections = await discoverCollections(projectRoot);
+      cache.setCollections(collections);
+    }
+    if (!collections.some((c) => c.name === collection)) {
+      return sendError(res, `Collection '${collection}' not found`, 404);
+    }
+    const contentFilePath = getContentFilePath(collectionPath, contentId);
+    if (!contentFilePath) {
+      return sendError(
+        res,
+        `Content '${contentId}' not found in '${collection}'`,
+        404
+      );
+    }
+    let images = cache.getImages(collection, contentId);
+    if (!images) {
+      const result = await discoverContentImages(collectionPath, contentId);
+      if (!result.success) {
+        return sendError(res, result.error ?? "Failed to discover images", 500);
+      }
+      images = result.images;
+      cache.setImages(collection, contentId, images);
+    }
+    sendJson(res, {
+      success: true,
+      images,
+      contentPath: contentFilePath
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    sendError(res, `Failed to discover images: ${message}`, 500);
+  }
+};
+var IMAGE_MIME_TYPES = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml"
+};
+var handleServeImage = async (_req, res, params, imagePath, context) => {
+  const { collection, id: contentId } = params;
+  const { projectRoot } = context;
+  if (!collection || !contentId) {
+    return sendWritenexError(
+      res,
+      new ApiBadRequestError("Collection and content ID required")
+    );
+  }
+  try {
+    const collectionPath = join2(projectRoot, "src/content", collection);
+    const contentFilePath = getContentFilePath(collectionPath, contentId);
+    if (!contentFilePath) {
+      return sendWritenexError(
+        res,
+        new ContentNotFoundError(collection, contentId)
+      );
+    }
+    let fullImagePath;
+    if (contentFilePath.endsWith("/index.md") || contentFilePath.endsWith("/index.mdx")) {
+      const contentFolder = contentFilePath.replace(/\/index\.mdx?$/, "");
+      fullImagePath = join2(contentFolder, imagePath);
+    } else {
+      fullImagePath = join2(collectionPath, contentId, imagePath);
+    }
+    const normalizedPath = join2(fullImagePath);
+    if (!normalizedPath.startsWith(collectionPath)) {
+      return sendWritenexError(
+        res,
+        new PathTraversalError(imagePath, collectionPath)
+      );
+    }
+    if (!existsSync2(fullImagePath)) {
+      return sendWritenexError(res, new ImageNotFoundError(imagePath));
+    }
+    const stats = statSync(fullImagePath);
+    if (!stats.isFile()) {
+      return sendWritenexError(
+        res,
+        new ApiBadRequestError("Requested path is not a file")
+      );
+    }
+    const ext = extname2(fullImagePath).toLowerCase();
+    const mimeType = IMAGE_MIME_TYPES[ext] ?? "application/octet-stream";
+    res.setHeader("Content-Type", mimeType);
+    res.setHeader("Content-Length", stats.size);
+    res.setHeader("Cache-Control", "public, max-age=3600");
+    const stream = createReadStream(fullImagePath);
+    stream.pipe(res);
+  } catch (error) {
+    const wrappedError = isWritenexError(error) ? error : wrapError(error, "API_INTERNAL_ERROR" /* API_INTERNAL_ERROR */);
+    sendWritenexError(res, wrappedError);
+  }
+};
+function getResolvedVersionConfig(config) {
+  return {
+    enabled: config?.enabled ?? true,
+    maxVersions: config?.maxVersions ?? 20,
+    storagePath: config?.storagePath ?? ".writenex/versions"
+  };
+}
+var handleListVersions = async (_req, res, params, context) => {
+  const { collection, id } = params;
+  const { projectRoot, config } = context;
+  if (!collection || !id) {
+    return sendError(res, "Collection and content ID required", 400);
+  }
+  try {
+    const versionConfig = getResolvedVersionConfig(config.versionHistory);
+    const versions = await getVersions(
+      projectRoot,
+      collection,
+      id,
+      versionConfig
+    );
+    sendJson(res, {
+      success: true,
+      versions,
+      total: versions.length
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    sendError(res, `Failed to list versions: ${message}`, 500);
+  }
+};
+var handleGetVersion = async (_req, res, params, context) => {
+  const { collection, id, versionId } = params;
+  const { projectRoot, config } = context;
+  if (!collection || !id || !versionId) {
+    return sendWritenexError(
+      res,
+      new ApiBadRequestError("Collection, content ID, and version ID required")
+    );
+  }
+  try {
+    const versionConfig = getResolvedVersionConfig(config.versionHistory);
+    const version = await getVersion(
+      projectRoot,
+      collection,
+      id,
+      versionId,
+      versionConfig
+    );
+    if (!version) {
+      return sendWritenexError(
+        res,
+        new VersionNotFoundError(collection, id, versionId)
+      );
+    }
+    sendJson(res, {
+      success: true,
+      version
+    });
+  } catch (error) {
+    const wrappedError = isWritenexError(error) ? error : wrapError(error, "API_INTERNAL_ERROR" /* API_INTERNAL_ERROR */);
+    sendWritenexError(res, wrappedError);
+  }
+};
+var handleCreateVersion = async (req, res, params, context) => {
+  const { collection, id } = params;
+  const { projectRoot, config } = context;
+  if (!collection || !id) {
+    return sendError(res, "Collection and content ID required", 400);
+  }
+  try {
+    const versionConfig = getResolvedVersionConfig(config.versionHistory);
+    if (!versionConfig.enabled) {
+      return sendError(res, "Version history is disabled", 400);
+    }
+    const body = await parseJsonBody(req);
+    const label = body && typeof body === "object" && "label" in body ? String(body.label) : void 0;
+    const collectionPath = join2(projectRoot, "src/content", collection);
+    const filePath = getContentFilePath(collectionPath, id);
+    if (!filePath) {
+      return sendError(
+        res,
+        `Content '${id}' not found in '${collection}'`,
+        404
+      );
+    }
+    const readResult = await readContentFile(filePath, collectionPath);
+    if (!readResult.success || !readResult.content) {
+      return sendError(res, readResult.error ?? "Failed to read content", 500);
+    }
+    const result = await saveVersion(
+      projectRoot,
+      collection,
+      id,
+      readResult.content.raw,
+      versionConfig,
+      { label }
+    );
+    if (!result.success) {
+      return sendError(res, result.error ?? "Failed to create version", 500);
+    }
+    sendJson(res, {
+      success: true,
+      version: result.version
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    sendError(res, `Failed to create version: ${message}`, 500);
+  }
+};
+var handleRestoreVersion = async (_req, res, params, context) => {
+  const { collection, id, versionId } = params;
+  const { projectRoot, config } = context;
+  if (!collection || !id || !versionId) {
+    return sendError(
+      res,
+      "Collection, content ID, and version ID required",
+      400
+    );
+  }
+  try {
+    const versionConfig = getResolvedVersionConfig(config.versionHistory);
+    const collectionPath = join2(projectRoot, "src/content", collection);
+    const filePath = getContentFilePath(collectionPath, id);
+    if (!filePath) {
+      return sendError(
+        res,
+        `Content '${id}' not found in '${collection}'`,
+        404
+      );
+    }
+    const result = await restoreVersion(
+      projectRoot,
+      collection,
+      id,
+      versionId,
+      filePath,
+      versionConfig
+    );
+    if (!result.success) {
+      if (result.error?.includes("not found")) {
+        return sendError(res, result.error, 404);
+      }
+      return sendError(res, result.error ?? "Failed to restore version", 500);
+    }
+    const cache = getCache();
+    cache.handleFileChange("change", collection);
+    sendJson(res, {
+      success: true,
+      version: result.version,
+      content: result.content,
+      safetySnapshot: result.safetySnapshot
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    sendError(res, `Failed to restore version: ${message}`, 500);
+  }
+};
+var handleGetVersionDiff = async (_req, res, params, context) => {
+  const { collection, id, versionId } = params;
+  const { projectRoot, config } = context;
+  if (!collection || !id || !versionId) {
+    return sendError(
+      res,
+      "Collection, content ID, and version ID required",
+      400
+    );
+  }
+  try {
+    const versionConfig = getResolvedVersionConfig(config.versionHistory);
+    const version = await getVersion(
+      projectRoot,
+      collection,
+      id,
+      versionId,
+      versionConfig
+    );
+    if (!version) {
+      return sendError(res, `Version '${versionId}' not found`, 404);
+    }
+    const collectionPath = join2(projectRoot, "src/content", collection);
+    const filePath = getContentFilePath(collectionPath, id);
+    if (!filePath) {
+      return sendError(
+        res,
+        `Content '${id}' not found in '${collection}'`,
+        404
+      );
+    }
+    const readResult = await readContentFile(filePath, collectionPath);
+    if (!readResult.success || !readResult.content) {
+      return sendError(
+        res,
+        readResult.error ?? "Failed to read current content",
+        500
+      );
+    }
+    sendJson(res, {
+      success: true,
+      version,
+      current: {
+        content: readResult.content.raw,
+        frontmatter: readResult.content.frontmatter,
+        body: readResult.content.body
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    sendError(res, `Failed to get diff data: ${message}`, 500);
+  }
+};
+var handleDeleteVersion = async (_req, res, params, context) => {
+  const { collection, id, versionId } = params;
+  const { projectRoot, config } = context;
+  if (!collection || !id || !versionId) {
+    return sendError(
+      res,
+      "Collection, content ID, and version ID required",
+      400
+    );
+  }
+  try {
+    const versionConfig = getResolvedVersionConfig(config.versionHistory);
+    const result = await deleteVersion(
+      projectRoot,
+      collection,
+      id,
+      versionId,
+      versionConfig
+    );
+    if (!result.success) {
+      if (result.error?.includes("not found")) {
+        return sendError(res, result.error, 404);
+      }
+      return sendError(res, result.error ?? "Failed to delete version", 500);
+    }
+    sendJson(res, {
+      success: true,
+      version: result.version
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    sendError(res, `Failed to delete version: ${message}`, 500);
+  }
+};
+var handleClearVersions = async (_req, res, params, context) => {
+  const { collection, id } = params;
+  const { projectRoot, config } = context;
+  if (!collection || !id) {
+    return sendError(res, "Collection and content ID required", 400);
+  }
+  try {
+    const versionConfig = getResolvedVersionConfig(config.versionHistory);
+    const result = await clearVersions(
+      projectRoot,
+      collection,
+      id,
+      versionConfig
+    );
+    if (!result.success) {
+      return sendError(res, result.error ?? "Failed to clear versions", 500);
+    }
+    sendJson(res, {
+      success: true
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    sendError(res, `Failed to clear versions: ${message}`, 500);
+  }
+};
+
+export {
+  ServerCache,
+  getCache,
+  resetCache,
+  createApiRouter,
+  serveEditorHtml,
+  serveAsset,
+  getClientDistPath,
+  hasClientBundle,
+  createMiddleware,
+  parseQueryParams,
+  parseJsonBody,
+  sendJson,
+  sendError,
+  sendWritenexError
+};
+//# sourceMappingURL=chunk-7XU5X6CW.js.map