@imjp/writenex-astro 0.1.0 → 1.3.0

package/dist/{chunk-CF2XXJFF.js → chunk-OWYFIQFK.js}

@@ -4,7 +4,7 @@ import {
   isValidPattern,
   readContentFile,
   resolvePatternTokens
-} from "./chunk-AAOQHQPU.js";
+} from "./chunk-TQAYIZOA.js";
 
 // src/core/errors.ts
 var WritenexErrorCode = /* @__PURE__ */ ((WritenexErrorCode2) => {
@@ -260,17 +260,330 @@ function wrapError(error, defaultCode = "UNKNOWN_ERROR" /* UNKNOWN_ERROR */) {
   return new WritenexError(defaultCode, message, { cause });
 }
 
+// src/filesystem/images.ts
+import { existsSync } from "fs";
+import { mkdir, readdir, stat, writeFile } from "fs/promises";
+import { basename, dirname, extname, join, relative } from "path";
+var DEFAULT_IMAGE_CONFIG = {
+  strategy: "colocated",
+  publicPath: "/images",
+  storagePath: "public/images"
+};
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".svg"
+]);
+function isValidImageFile(filename) {
+  const ext = extname(filename).toLowerCase();
+  return SUPPORTED_EXTENSIONS.has(ext);
+}
+function generateUniqueFilename(originalName, _contentId) {
+  const ext = extname(originalName).toLowerCase();
+  const baseName = basename(originalName, ext).toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").substring(0, 50);
+  const timestamp = Date.now().toString(36);
+  return `${baseName}-${timestamp}${ext}`;
+}
+function getColocatedPath(projectRoot, collection, contentId, filename) {
+  const collectionPath = join(projectRoot, "src/content", collection);
+  const imageDir = join(collectionPath, contentId);
+  const storagePath = join(imageDir, filename);
+  const indexMdPath = join(collectionPath, contentId, "index.md");
+  const indexMdxPath = join(collectionPath, contentId, "index.mdx");
+  const isFolderBased = existsSync(indexMdPath) || existsSync(indexMdxPath);
+  const markdownPath = isFolderBased ? `./${filename}` : `./${contentId}/${filename}`;
+  return { storagePath, markdownPath };
+}
+function getPublicPath(projectRoot, collection, filename, config) {
+  const storagePath = join(
+    projectRoot,
+    config.storagePath ?? "public/images",
+    collection,
+    filename
+  );
+  const publicPath = config.publicPath ?? "/images";
+  const url = `${publicPath}/${collection}/${filename}`;
+  return { storagePath, markdownPath: url, url };
+}
+async function uploadImage(options) {
+  const {
+    filename,
+    data,
+    collection,
+    contentId,
+    projectRoot,
+    config = DEFAULT_IMAGE_CONFIG
+  } = options;
+  if (!isValidImageFile(filename)) {
+    return {
+      success: false,
+      error: `Invalid image file type. Supported: ${[...SUPPORTED_EXTENSIONS].join(", ")}`
+    };
+  }
+  const uniqueFilename = generateUniqueFilename(filename, contentId);
+  try {
+    let storagePath;
+    let markdownPath;
+    let url;
+    switch (config.strategy) {
+      case "public": {
+        const paths = getPublicPath(
+          projectRoot,
+          collection,
+          uniqueFilename,
+          config
+        );
+        storagePath = paths.storagePath;
+        markdownPath = paths.markdownPath;
+        url = paths.url;
+        break;
+      }
+      case "colocated":
+      default: {
+        const paths = getColocatedPath(
+          projectRoot,
+          collection,
+          contentId,
+          uniqueFilename
+        );
+        storagePath = paths.storagePath;
+        markdownPath = paths.markdownPath;
+        break;
+      }
+    }
+    const dir = dirname(storagePath);
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    await writeFile(storagePath, data);
+    return {
+      success: true,
+      path: markdownPath,
+      url: url ?? markdownPath
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      success: false,
+      error: `Failed to upload image: ${message}`
+    };
+  }
+}
+function parseMultipartFormData(body, contentType) {
+  const result = { fields: {} };
+  const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^;]+))/);
+  if (!boundaryMatch) {
+    return result;
+  }
+  const boundary = boundaryMatch[1] ?? boundaryMatch[2];
+  if (!boundary) {
+    return result;
+  }
+  const boundaryBuffer = Buffer.from(`--${boundary}`);
+  const parts = splitBuffer(body, boundaryBuffer);
+  for (const part of parts) {
+    if (part.length < 10) continue;
+    const separatorIndex = part.indexOf("\r\n\r\n");
+    if (separatorIndex === -1) continue;
+    const headerSection = part.slice(0, separatorIndex).toString("utf-8");
+    const bodySection = part.slice(separatorIndex + 4);
+    const bodyEnd = bodySection.length - 2;
+    const cleanBody = bodyEnd > 0 ? bodySection.slice(0, bodyEnd) : bodySection;
+    const headers = parseHeaders(headerSection);
+    const disposition = headers["content-disposition"];
+    if (!disposition) continue;
+    const nameMatch = disposition.match(/name="([^"]+)"/);
+    const filenameMatch = disposition.match(/filename="([^"]+)"/);
+    if (filenameMatch) {
+      result.file = {
+        filename: filenameMatch[1] ?? "unknown",
+        data: cleanBody,
+        contentType: headers["content-type"] ?? "application/octet-stream"
+      };
+    } else if (nameMatch) {
+      result.fields[nameMatch[1] ?? ""] = cleanBody.toString("utf-8");
+    }
+  }
+  return result;
+}
+function splitBuffer(buffer, delimiter) {
+  const parts = [];
+  let start = 0;
+  let index;
+  while ((index = buffer.indexOf(delimiter, start)) !== -1) {
+    if (index > start) {
+      parts.push(buffer.slice(start, index));
+    }
+    start = index + delimiter.length;
+  }
+  if (start < buffer.length) {
+    parts.push(buffer.slice(start));
+  }
+  return parts;
+}
+function parseHeaders(headerSection) {
+  const headers = {};
+  const lines = headerSection.split("\r\n");
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim().toLowerCase();
+      const value = line.slice(colonIndex + 1).trim();
+      headers[key] = value;
+    }
+  }
+  return headers;
+}
+var DATE_PREFIX_PATTERN = /^\d{4}-\d{2}-\d{2}-/;
+function getContentImageFolder(collectionPath, contentId, contentFilePath) {
+  const filename = basename(contentFilePath);
+  const contentDir = dirname(contentFilePath);
+  if (filename === "index.md" || filename === "index.mdx") {
+    return contentDir;
+  }
+  const siblingFolderPath = join(collectionPath, contentId);
+  if (existsSync(siblingFolderPath)) {
+    return siblingFolderPath;
+  }
+  return null;
+}
+function detectContentStructure(contentFilePath) {
+  const filename = basename(contentFilePath);
+  if (filename === "index.md" || filename === "index.mdx") {
+    return "folder-based";
+  }
+  const nameWithoutExt = filename.replace(/\.(md|mdx)$/, "");
+  if (DATE_PREFIX_PATTERN.test(nameWithoutExt)) {
+    return "date-prefixed";
+  }
+  return "flat";
+}
+function shouldSkipDirectory(dirName) {
+  return dirName.startsWith(".") || dirName.startsWith("_");
+}
+async function scanDirectoryForImages(dirPath, basePath, options) {
+  const { maxDepth, currentDepth } = options;
+  if (currentDepth >= maxDepth) {
+    return [];
+  }
+  if (!existsSync(dirPath)) {
+    return [];
+  }
+  const images = [];
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        if (shouldSkipDirectory(entry.name)) {
+          continue;
+        }
+        const subImages = await scanDirectoryForImages(entryPath, basePath, {
+          maxDepth,
+          currentDepth: currentDepth + 1,
+          basePath
+        });
+        images.push(...subImages);
+      } else if (entry.isFile()) {
+        if (isValidImageFile(entry.name)) {
+          const fileStat = await stat(entryPath);
+          const extension = extname(entry.name).toLowerCase();
+          const relativePath = calculateRelativePathFromBase(
+            basePath,
+            entryPath
+          );
+          images.push({
+            filename: entry.name,
+            relativePath,
+            absolutePath: entryPath,
+            size: fileStat.size,
+            extension
+          });
+        }
+      }
+    }
+  } catch {
+    return [];
+  }
+  return images;
+}
+function calculateRelativePathFromBase(basePath, targetPath) {
+  const relPath = relative(basePath, targetPath);
+  return `./${relPath}`;
+}
+function calculateRelativePath(contentFilePath, imagePath) {
+  const contentDir = dirname(contentFilePath);
+  const relPath = relative(contentDir, imagePath);
+  if (relPath.startsWith("..")) {
+    return relPath;
+  }
+  return `./${relPath}`;
+}
+var DEFAULT_MAX_DEPTH = 5;
+async function discoverContentImages(collectionPath, contentId, options) {
+  const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+  try {
+    const contentFilePath = getContentFilePath(collectionPath, contentId);
+    if (!contentFilePath) {
+      return {
+        success: false,
+        images: [],
+        error: `Content '${contentId}' not found in collection`
+      };
+    }
+    const imageFolderPath = getContentImageFolder(
+      collectionPath,
+      contentId,
+      contentFilePath
+    );
+    if (!imageFolderPath) {
+      return {
+        success: true,
+        images: []
+      };
+    }
+    const scannedImages = await scanDirectoryForImages(
+      imageFolderPath,
+      imageFolderPath,
+      {
+        maxDepth,
+        currentDepth: 0,
+        basePath: imageFolderPath
+      }
+    );
+    const images = scannedImages.map((img) => ({
+      ...img,
+      relativePath: calculateRelativePath(contentFilePath, img.absolutePath)
+    }));
+    return {
+      success: true,
+      images
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      success: false,
+      images: [],
+      error: `Failed to discover images: ${message}`
+    };
+  }
+}
+
 // src/filesystem/versions.ts
+import { existsSync as existsSync2 } from "fs";
 import {
+  mkdir as mkdir2,
+  readdir as readdir2,
   readFile,
-  writeFile,
-  mkdir,
-  readdir,
-  stat,
-  unlink
+  stat as stat2,
+  unlink,
+  writeFile as writeFile2
 } from "fs/promises";
-import { existsSync } from "fs";
-import { join, basename } from "path";
+import { basename as basename2, join as join2 } from "path";
 import matter from "gray-matter";
 var PREVIEW_MAX_LENGTH = 100;
 var GITIGNORE_CONTENT = "*\n";
@@ -338,13 +651,13 @@ function parseVersionId(versionId) {
   return isNaN(date.getTime()) ? null : date;
 }
 function getVersionStoragePath(projectRoot, collection, contentId, config) {
-  return join(projectRoot, config.storagePath, collection, contentId);
+  return join2(projectRoot, config.storagePath, collection, contentId);
 }
 function getVersionFilePath(storagePath, versionId) {
-  return join(storagePath, `${versionId}.md`);
+  return join2(storagePath, `${versionId}.md`);
 }
 function getManifestPath(storagePath) {
-  return join(storagePath, "manifest.json");
+  return join2(storagePath, "manifest.json");
 }
 function generatePreview(content) {
   try {
@@ -397,23 +710,23 @@ function stripLabelFromContent(content) {
   }
 }
 async function ensureGitignore(projectRoot, config) {
-  const storageRoot = join(projectRoot, config.storagePath);
-  const gitignorePath = join(storageRoot, ".gitignore");
-  if (!existsSync(storageRoot)) {
-    await mkdir(storageRoot, { recursive: true });
+  const storageRoot = join2(projectRoot, config.storagePath);
+  const gitignorePath = join2(storageRoot, ".gitignore");
+  if (!existsSync2(storageRoot)) {
+    await mkdir2(storageRoot, { recursive: true });
   }
-  if (!existsSync(gitignorePath)) {
-    await writeFile(gitignorePath, GITIGNORE_CONTENT, "utf-8");
+  if (!existsSync2(gitignorePath)) {
+    await writeFile2(gitignorePath, GITIGNORE_CONTENT, "utf-8");
   }
 }
 async function ensureStorageDirectory(storagePath) {
-  if (!existsSync(storagePath)) {
-    await mkdir(storagePath, { recursive: true });
+  if (!existsSync2(storagePath)) {
+    await mkdir2(storagePath, { recursive: true });
   }
 }
 async function readManifest(storagePath) {
   const manifestPath = getManifestPath(storagePath);
-  if (!existsSync(manifestPath)) {
+  if (!existsSync2(manifestPath)) {
     return null;
   }
   try {
@@ -436,7 +749,7 @@ async function writeManifest(storagePath, manifest) {
   await ensureStorageDirectory(storagePath);
   const manifestPath = getManifestPath(storagePath);
   const content = JSON.stringify(manifest, null, 2);
-  await writeFile(manifestPath, content, "utf-8");
+  await writeFile2(manifestPath, content, "utf-8");
 }
 function createEmptyManifest(collection, contentId) {
   return {
@@ -448,20 +761,20 @@ function createEmptyManifest(collection, contentId) {
 }
 async function recoverManifest(storagePath, collection, contentId) {
   const manifest = createEmptyManifest(collection, contentId);
-  if (!existsSync(storagePath)) {
+  if (!existsSync2(storagePath)) {
     return manifest;
   }
   try {
-    const files = await readdir(storagePath);
+    const files = await readdir2(storagePath);
     const versionFiles = files.filter(
       (f) => f.endsWith(".md") && f !== "manifest.json"
     );
     for (const file of versionFiles) {
-      const versionId = basename(file, ".md");
-      const filePath = join(storagePath, file);
+      const versionId = basename2(file, ".md");
+      const filePath = join2(storagePath, file);
       try {
         const content = await readFile(filePath, "utf-8");
-        const stats = await stat(filePath);
+        const stats = await stat2(filePath);
         const timestamp = parseVersionId(versionId);
         if (timestamp) {
           const label = extractLabelFromContent(content);
@@ -523,7 +836,7 @@ async function saveVersion(projectRoot, collection, contentId, content, config,
             storagePath,
             lastVersion.id
           );
-          if (existsSync(lastVersionPath)) {
+          if (existsSync2(lastVersionPath)) {
             try {
               const lastContent = await readFile(lastVersionPath, "utf-8");
               if (lastContent === content) {
@@ -538,8 +851,8 @@ async function saveVersion(projectRoot, collection, contentId, content, config,
       const versionId = now.toISOString().replace(/:/g, "-");
       const versionPath = getVersionFilePath(storagePath, versionId);
       const contentToSave = label ? injectLabelIntoContent(content, label) : content;
-      await writeFile(versionPath, contentToSave, "utf-8");
-      const stats = await stat(versionPath);
+      await writeFile2(versionPath, contentToSave, "utf-8");
+      const stats = await stat2(versionPath);
       const entry = {
         id: versionId,
         timestamp: now.toISOString(),
@@ -570,7 +883,7 @@ async function getVersions(projectRoot, collection, contentId, config) {
       contentId,
       config
     );
-    if (!existsSync(storagePath)) {
+    if (!existsSync2(storagePath)) {
       return [];
     }
     const manifest = await getOrRecoverManifest(
@@ -598,11 +911,11 @@ async function getVersion(projectRoot, collection, contentId, versionId, config)
       config
     );
     const versionPath = getVersionFilePath(storagePath, versionId);
-    if (!existsSync(versionPath)) {
+    if (!existsSync2(versionPath)) {
       return null;
     }
     const rawContent = await readFile(versionPath, "utf-8");
-    const stats = await stat(versionPath);
+    const stats = await stat2(versionPath);
     const labelFromContent = extractLabelFromContent(rawContent);
     const content = stripLabelFromContent(rawContent);
     const { data: frontmatter, content: body } = matter(content);
@@ -638,7 +951,7 @@ async function deleteVersion(projectRoot, collection, contentId, versionId, conf
   return withLock(storagePath, async () => {
     try {
       const versionPath = getVersionFilePath(storagePath, versionId);
-      if (!existsSync(versionPath)) {
+      if (!existsSync2(versionPath)) {
         return { success: false, error: `Version not found: ${versionId}` };
       }
       const manifest = await getOrRecoverManifest(
@@ -669,17 +982,17 @@ async function clearVersions(projectRoot, collection, contentId, config) {
     contentId,
     config
   );
-  if (!existsSync(storagePath)) {
+  if (!existsSync2(storagePath)) {
     return { success: true };
   }
   return withLock(storagePath, async () => {
     try {
-      const files = await readdir(storagePath);
+      const files = await readdir2(storagePath);
       const versionFiles = files.filter(
         (f) => f.endsWith(".md") && f !== "manifest.json"
       );
       for (const file of versionFiles) {
-        const filePath = join(storagePath, file);
+        const filePath = join2(storagePath, file);
         try {
           await unlink(filePath);
         } catch {
@@ -697,7 +1010,7 @@ async function clearVersions(projectRoot, collection, contentId, config) {
 }
 async function pruneVersionsInternal(storagePath, config) {
   try {
-    if (!existsSync(storagePath)) {
+    if (!existsSync2(storagePath)) {
       return { success: true };
     }
     const manifest = await readManifest(storagePath);
@@ -719,7 +1032,7 @@ async function pruneVersionsInternal(storagePath, config) {
     for (const version of toDelete) {
       const versionPath = getVersionFilePath(storagePath, version.id);
       try {
-        if (existsSync(versionPath)) {
+        if (existsSync2(versionPath)) {
           await unlink(versionPath);
         }
       } catch {
@@ -747,7 +1060,7 @@ async function pruneVersions(projectRoot, collection, contentId, config) {
     contentId,
     config
   );
-  if (!existsSync(storagePath)) {
+  if (!existsSync2(storagePath)) {
     return { success: true };
   }
   return withLock(
@@ -772,7 +1085,7 @@ async function restoreVersion(projectRoot, collection, contentId, versionId, con
       };
     }
     let safetySnapshot;
-    if (!skipSafetySnapshot && existsSync(contentFilePath)) {
+    if (!skipSafetySnapshot && existsSync2(contentFilePath)) {
       try {
         const currentContent = await readFile(contentFilePath, "utf-8");
         const snapshotResult = await saveVersion(
@@ -793,7 +1106,7 @@ async function restoreVersion(projectRoot, collection, contentId, versionId, con
         );
       }
     }
-    await writeFile(contentFilePath, versionToRestore.content, "utf-8");
+    await writeFile2(contentFilePath, versionToRestore.content, "utf-8");
     return {
       success: true,
       version: {
@@ -817,9 +1130,9 @@ async function restoreVersion(projectRoot, collection, contentId, versionId, con
 }
 
 // src/filesystem/writer.ts
-import { writeFile as writeFile2, unlink as unlink2, mkdir as mkdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join2, dirname, basename as basename2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir3, readFile as readFile2, stat as stat3, unlink as unlink2, writeFile as writeFile3 } from "fs/promises";
+import { basename as basename3, dirname as dirname2, join as join3 } from "path";
 import slugify from "slugify";
 function generateSlug(text) {
   return slugify(text, {
@@ -830,12 +1143,12 @@ function generateSlug(text) {
 }
 function contentExists(slug, collectionPath, filePattern) {
   const relativePath = generatePathFromPattern(filePattern, { slug });
-  const fullPath = join2(collectionPath, relativePath);
+  const fullPath = join3(collectionPath, relativePath);
   if (filePattern.includes("/index.")) {
-    const folderPath = join2(collectionPath, slug);
-    return existsSync2(folderPath);
+    const folderPath = join3(collectionPath, slug);
+    return existsSync3(folderPath);
   }
-  return existsSync2(fullPath);
+  return existsSync3(fullPath);
 }
 async function generateUniqueSlug(baseSlug, collectionPath, filePattern = "{slug}.md") {
   let slug = baseSlug;
@@ -917,13 +1230,13 @@ async function createContent(collectionPath, options) {
       customTokens
     });
     const relativePath = generatePathFromPattern(filePattern, tokens);
-    const filePath = join2(collectionPath, relativePath);
-    const parentDir = dirname(filePath);
-    if (!existsSync2(parentDir)) {
-      await mkdir2(parentDir, { recursive: true });
+    const filePath = join3(collectionPath, relativePath);
+    const parentDir = dirname2(filePath);
+    if (!existsSync3(parentDir)) {
+      await mkdir3(parentDir, { recursive: true });
     }
     const content = createFileContent(frontmatter, body);
-    await writeFile2(filePath, content, "utf-8");
+    await writeFile3(filePath, content, "utf-8");
     return {
       success: true,
       id: slug,
@@ -955,405 +1268,92 @@ async function updateContent(filePath, collectionPath, options) {
           existing.content.id,
           existing.content.raw,
           existing.content.mtime,
-          expectedMtime
-        );
-        return {
-          success: false,
-          error: conflictError.message,
-          conflict: conflictError
-        };
-      }
-    }
-    const frontmatter = options.frontmatter ? { ...existing.content.frontmatter, ...options.frontmatter } : existing.content.frontmatter;
-    const body = options.body ?? existing.content.body;
-    const newContent = createFileContent(frontmatter, body);
-    const currentContent = existsSync2(filePath) ? await readFile2(filePath, "utf-8") : "";
-    if (newContent === currentContent) {
-      return {
-        success: true,
-        id: existing.content.id,
-        path: filePath,
-        mtime: existing.content.mtime
-      };
-    }
-    if (projectRoot && collection && versionHistoryConfig && versionHistoryConfig.enabled && currentContent) {
-      try {
-        const fileName = basename2(filePath);
-        const contentId = fileName === "index.md" || fileName === "index.mdx" ? basename2(dirname(filePath)) : fileName.replace(/\.(md|mdx)$/, "");
-        const versionResult = await saveVersion(
-          projectRoot,
-          collection,
-          contentId,
-          currentContent,
-          versionHistoryConfig,
-          { skipIfIdentical: true }
-        );
-        if (!versionResult.success) {
-          console.warn(
-            `[writenex] Failed to create version snapshot: ${versionResult.error}`
-          );
-        }
-      } catch (versionError) {
-        console.warn(
-          `[writenex] Version creation error (save will continue):`,
-          versionError
-        );
-      }
-    }
-    await writeFile2(filePath, newContent, "utf-8");
-    const newStats = await stat2(filePath);
-    return {
-      success: true,
-      id: existing.content.id,
-      path: filePath,
-      mtime: newStats.mtimeMs
-    };
-  } catch (error) {
-    if (error instanceof ContentConflictError) {
-      return {
-        success: false,
-        error: error.message,
-        conflict: error
-      };
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      error: `Failed to update content: ${message}`
-    };
-  }
-}
-async function deleteContent(filePath) {
-  try {
-    if (!existsSync2(filePath)) {
-      return {
-        success: false,
-        error: "Content file not found"
-      };
-    }
-    await unlink2(filePath);
-    return {
-      success: true,
-      path: filePath
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      error: `Failed to delete content: ${message}`
-    };
-  }
-}
-
-// src/filesystem/images.ts
-import { writeFile as writeFile3, mkdir as mkdir3, readdir as readdir2, stat as stat3 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3, dirname as dirname2, basename as basename3, extname, relative } from "path";
-var DEFAULT_IMAGE_CONFIG = {
-  strategy: "colocated",
-  publicPath: "/images",
-  storagePath: "public/images"
-};
-var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".jpg",
-  ".jpeg",
-  ".png",
-  ".gif",
-  ".webp",
-  ".avif",
-  ".svg"
-]);
-function isValidImageFile(filename) {
-  const ext = extname(filename).toLowerCase();
-  return SUPPORTED_EXTENSIONS.has(ext);
-}
-function generateUniqueFilename(originalName, _contentId) {
-  const ext = extname(originalName).toLowerCase();
-  const baseName = basename3(originalName, ext).toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").substring(0, 50);
-  const timestamp = Date.now().toString(36);
-  return `${baseName}-${timestamp}${ext}`;
-}
-function getColocatedPath(projectRoot, collection, contentId, filename) {
-  const collectionPath = join3(projectRoot, "src/content", collection);
-  const imageDir = join3(collectionPath, contentId);
-  const storagePath = join3(imageDir, filename);
-  const indexMdPath = join3(collectionPath, contentId, "index.md");
-  const indexMdxPath = join3(collectionPath, contentId, "index.mdx");
-  const isFolderBased = existsSync3(indexMdPath) || existsSync3(indexMdxPath);
-  const markdownPath = isFolderBased ? `./${filename}` : `./${contentId}/${filename}`;
-  return { storagePath, markdownPath };
-}
-function getPublicPath(projectRoot, collection, filename, config) {
-  const storagePath = join3(
-    projectRoot,
-    config.storagePath ?? "public/images",
-    collection,
-    filename
-  );
-  const publicPath = config.publicPath ?? "/images";
-  const url = `${publicPath}/${collection}/${filename}`;
-  return { storagePath, markdownPath: url, url };
-}
-async function uploadImage(options) {
-  const {
-    filename,
-    data,
-    collection,
-    contentId,
-    projectRoot,
-    config = DEFAULT_IMAGE_CONFIG
-  } = options;
-  if (!isValidImageFile(filename)) {
-    return {
-      success: false,
-      error: `Invalid image file type. Supported: ${[...SUPPORTED_EXTENSIONS].join(", ")}`
-    };
-  }
-  const uniqueFilename = generateUniqueFilename(filename, contentId);
-  try {
-    let storagePath;
-    let markdownPath;
-    let url;
-    switch (config.strategy) {
-      case "public": {
-        const paths = getPublicPath(
-          projectRoot,
-          collection,
-          uniqueFilename,
-          config
-        );
-        storagePath = paths.storagePath;
-        markdownPath = paths.markdownPath;
-        url = paths.url;
-        break;
+          expectedMtime
+        );
+        return {
+          success: false,
+          error: conflictError.message,
+          conflict: conflictError
+        };
       }
-      case "colocated":
-      default: {
-        const paths = getColocatedPath(
+    }
+    const frontmatter = options.frontmatter ? { ...existing.content.frontmatter, ...options.frontmatter } : existing.content.frontmatter;
+    const body = options.body ?? existing.content.body;
+    const newContent = createFileContent(frontmatter, body);
+    const currentContent = existsSync3(filePath) ? await readFile2(filePath, "utf-8") : "";
+    if (newContent === currentContent) {
+      return {
+        success: true,
+        id: existing.content.id,
+        path: filePath,
+        mtime: existing.content.mtime
+      };
+    }
+    if (projectRoot && collection && versionHistoryConfig && versionHistoryConfig.enabled && currentContent) {
+      try {
+        const fileName = basename3(filePath);
+        const contentId = fileName === "index.md" || fileName === "index.mdx" ? basename3(dirname2(filePath)) : fileName.replace(/\.(md|mdx)$/, "");
+        const versionResult = await saveVersion(
           projectRoot,
           collection,
           contentId,
-          uniqueFilename
+          currentContent,
+          versionHistoryConfig,
+          { skipIfIdentical: true }
+        );
+        if (!versionResult.success) {
+          console.warn(
+            `[writenex] Failed to create version snapshot: ${versionResult.error}`
+          );
+        }
+      } catch (versionError) {
+        console.warn(
+          `[writenex] Version creation error (save will continue):`,
+          versionError
         );
-        storagePath = paths.storagePath;
-        markdownPath = paths.markdownPath;
-        break;
       }
     }
-    const dir = dirname2(storagePath);
-    if (!existsSync3(dir)) {
-      await mkdir3(dir, { recursive: true });
-    }
-    await writeFile3(storagePath, data);
+    await writeFile3(filePath, newContent, "utf-8");
+    const newStats = await stat3(filePath);
     return {
       success: true,
-      path: markdownPath,
-      url: url ?? markdownPath
+      id: existing.content.id,
+      path: filePath,
+      mtime: newStats.mtimeMs
     };
   } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
+    if (error instanceof ContentConflictError) {
+      return {
+        success: false,
+        error: error.message,
+        conflict: error
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
     return {
       success: false,
-      error: `Failed to upload image: ${message}`
+      error: `Failed to update content: ${message}`
     };
   }
 }
-function parseMultipartFormData(body, contentType) {
-  const result = { fields: {} };
-  const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^;]+))/);
-  if (!boundaryMatch) {
-    return result;
-  }
-  const boundary = boundaryMatch[1] ?? boundaryMatch[2];
-  if (!boundary) {
-    return result;
-  }
-  const boundaryBuffer = Buffer.from(`--${boundary}`);
-  const parts = splitBuffer(body, boundaryBuffer);
-  for (const part of parts) {
-    if (part.length < 10) continue;
-    const separatorIndex = part.indexOf("\r\n\r\n");
-    if (separatorIndex === -1) continue;
-    const headerSection = part.slice(0, separatorIndex).toString("utf-8");
-    const bodySection = part.slice(separatorIndex + 4);
-    const bodyEnd = bodySection.length - 2;
-    const cleanBody = bodyEnd > 0 ? bodySection.slice(0, bodyEnd) : bodySection;
-    const headers = parseHeaders(headerSection);
-    const disposition = headers["content-disposition"];
-    if (!disposition) continue;
-    const nameMatch = disposition.match(/name="([^"]+)"/);
-    const filenameMatch = disposition.match(/filename="([^"]+)"/);
-    if (filenameMatch) {
-      result.file = {
-        filename: filenameMatch[1] ?? "unknown",
-        data: cleanBody,
-        contentType: headers["content-type"] ?? "application/octet-stream"
-      };
-    } else if (nameMatch) {
-      result.fields[nameMatch[1] ?? ""] = cleanBody.toString("utf-8");
-    }
-  }
-  return result;
-}
-function splitBuffer(buffer, delimiter) {
-  const parts = [];
-  let start = 0;
-  let index;
-  while ((index = buffer.indexOf(delimiter, start)) !== -1) {
-    if (index > start) {
-      parts.push(buffer.slice(start, index));
-    }
-    start = index + delimiter.length;
-  }
-  if (start < buffer.length) {
-    parts.push(buffer.slice(start));
-  }
-  return parts;
-}
-function parseHeaders(headerSection) {
-  const headers = {};
-  const lines = headerSection.split("\r\n");
-  for (const line of lines) {
-    const colonIndex = line.indexOf(":");
-    if (colonIndex > 0) {
-      const key = line.slice(0, colonIndex).trim().toLowerCase();
-      const value = line.slice(colonIndex + 1).trim();
-      headers[key] = value;
-    }
-  }
-  return headers;
-}
-var DATE_PREFIX_PATTERN = /^\d{4}-\d{2}-\d{2}-/;
-function getContentImageFolder(collectionPath, contentId, contentFilePath) {
-  const filename = basename3(contentFilePath);
-  const contentDir = dirname2(contentFilePath);
-  if (filename === "index.md" || filename === "index.mdx") {
-    return contentDir;
-  }
-  const siblingFolderPath = join3(collectionPath, contentId);
-  if (existsSync3(siblingFolderPath)) {
-    return siblingFolderPath;
-  }
-  return null;
-}
-function detectContentStructure(contentFilePath) {
-  const filename = basename3(contentFilePath);
-  if (filename === "index.md" || filename === "index.mdx") {
-    return "folder-based";
-  }
-  const nameWithoutExt = filename.replace(/\.(md|mdx)$/, "");
-  if (DATE_PREFIX_PATTERN.test(nameWithoutExt)) {
-    return "date-prefixed";
-  }
-  return "flat";
-}
-function shouldSkipDirectory(dirName) {
-  return dirName.startsWith(".") || dirName.startsWith("_");
-}
-async function scanDirectoryForImages(dirPath, basePath, options) {
-  const { maxDepth, currentDepth } = options;
-  if (currentDepth >= maxDepth) {
-    return [];
-  }
-  if (!existsSync3(dirPath)) {
-    return [];
-  }
-  const images = [];
-  try {
-    const entries = await readdir2(dirPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const entryPath = join3(dirPath, entry.name);
-      if (entry.isDirectory()) {
-        if (shouldSkipDirectory(entry.name)) {
-          continue;
-        }
-        const subImages = await scanDirectoryForImages(entryPath, basePath, {
-          maxDepth,
-          currentDepth: currentDepth + 1,
-          basePath
-        });
-        images.push(...subImages);
-      } else if (entry.isFile()) {
-        if (isValidImageFile(entry.name)) {
-          const fileStat = await stat3(entryPath);
-          const extension = extname(entry.name).toLowerCase();
-          const relativePath = calculateRelativePathFromBase(
-            basePath,
-            entryPath
-          );
-          images.push({
-            filename: entry.name,
-            relativePath,
-            absolutePath: entryPath,
-            size: fileStat.size,
-            extension
-          });
-        }
-      }
-    }
-  } catch {
-    return [];
-  }
-  return images;
-}
-function calculateRelativePathFromBase(basePath, targetPath) {
-  const relPath = relative(basePath, targetPath);
-  return `./${relPath}`;
-}
-function calculateRelativePath(contentFilePath, imagePath) {
-  const contentDir = dirname2(contentFilePath);
-  const relPath = relative(contentDir, imagePath);
-  if (relPath.startsWith("..")) {
-    return relPath;
-  }
-  return `./${relPath}`;
-}
-var DEFAULT_MAX_DEPTH = 5;
-async function discoverContentImages(collectionPath, contentId, options) {
-  const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+async function deleteContent(filePath) {
   try {
-    const contentFilePath = getContentFilePath(collectionPath, contentId);
-    if (!contentFilePath) {
+    if (!existsSync3(filePath)) {
       return {
         success: false,
-        images: [],
-        error: `Content '${contentId}' not found in collection`
-      };
-    }
-    const imageFolderPath = getContentImageFolder(
-      collectionPath,
-      contentId,
-      contentFilePath
-    );
-    if (!imageFolderPath) {
-      return {
-        success: true,
-        images: []
+        error: "Content file not found"
       };
     }
-    const scannedImages = await scanDirectoryForImages(
-      imageFolderPath,
-      imageFolderPath,
-      {
-        maxDepth,
-        currentDepth: 0,
-        basePath: imageFolderPath
-      }
-    );
-    const images = scannedImages.map((img) => ({
-      ...img,
-      relativePath: calculateRelativePath(contentFilePath, img.absolutePath)
-    }));
+    await unlink2(filePath);
     return {
       success: true,
-      images
+      path: filePath
     };
   } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
+    const message = error instanceof Error ? error.message : String(error);
     return {
       success: false,
-      images: [],
-      error: `Failed to discover images: ${message}`
+      error: `Failed to delete content: ${message}`
     };
   }
 }
@@ -1372,6 +1372,15 @@ export {
   VersionNotFoundError,
   isWritenexError,
   wrapError,
+  DEFAULT_IMAGE_CONFIG,
+  isValidImageFile,
+  uploadImage,
+  parseMultipartFormData,
+  getContentImageFolder,
+  detectContentStructure,
+  scanDirectoryForImages,
+  calculateRelativePath,
+  discoverContentImages,
   generateVersionId,
   parseVersionId,
   getVersionStoragePath,
@@ -1396,15 +1405,6 @@ export {
   generateUniqueSlug,
   createContent,
   updateContent,
-  deleteContent,
-  DEFAULT_IMAGE_CONFIG,
-  isValidImageFile,
-  uploadImage,
-  parseMultipartFormData,
-  getContentImageFolder,
-  detectContentStructure,
-  scanDirectoryForImages,
-  calculateRelativePath,
-  discoverContentImages
+  deleteContent
 };
-//# sourceMappingURL=chunk-CF2XXJFF.js.map
+//# sourceMappingURL=chunk-OWYFIQFK.js.map