@imjp/writenex-astro 0.1.0

package/dist/chunk-CF2XXJFF.js

@@ -0,0 +1,1410 @@
+import {
+  generatePathFromPattern,
+  getContentFilePath,
+  isValidPattern,
+  readContentFile,
+  resolvePatternTokens
+} from "./chunk-AAOQHQPU.js";
+
+// src/core/errors.ts
+var WritenexErrorCode = /* @__PURE__ */ ((WritenexErrorCode2) => {
+  WritenexErrorCode2["CONFIG_NOT_FOUND"] = "CONFIG_NOT_FOUND";
+  WritenexErrorCode2["CONFIG_INVALID"] = "CONFIG_INVALID";
+  WritenexErrorCode2["CONFIG_PARSE_ERROR"] = "CONFIG_PARSE_ERROR";
+  WritenexErrorCode2["FS_READ_ERROR"] = "FS_READ_ERROR";
+  WritenexErrorCode2["FS_WRITE_ERROR"] = "FS_WRITE_ERROR";
+  WritenexErrorCode2["FS_DELETE_ERROR"] = "FS_DELETE_ERROR";
+  WritenexErrorCode2["FS_PERMISSION_DENIED"] = "FS_PERMISSION_DENIED";
+  WritenexErrorCode2["FS_PATH_NOT_FOUND"] = "FS_PATH_NOT_FOUND";
+  WritenexErrorCode2["FS_PATH_TRAVERSAL"] = "FS_PATH_TRAVERSAL";
+  WritenexErrorCode2["CONTENT_NOT_FOUND"] = "CONTENT_NOT_FOUND";
+  WritenexErrorCode2["CONTENT_PARSE_ERROR"] = "CONTENT_PARSE_ERROR";
+  WritenexErrorCode2["CONTENT_VALIDATION_ERROR"] = "CONTENT_VALIDATION_ERROR";
+  WritenexErrorCode2["CONTENT_ALREADY_EXISTS"] = "CONTENT_ALREADY_EXISTS";
+  WritenexErrorCode2["CONTENT_INVALID_SLUG"] = "CONTENT_INVALID_SLUG";
+  WritenexErrorCode2["CONTENT_CONFLICT"] = "CONTENT_CONFLICT";
+  WritenexErrorCode2["COLLECTION_NOT_FOUND"] = "COLLECTION_NOT_FOUND";
+  WritenexErrorCode2["COLLECTION_EMPTY"] = "COLLECTION_EMPTY";
+  WritenexErrorCode2["COLLECTION_DISCOVERY_ERROR"] = "COLLECTION_DISCOVERY_ERROR";
+  WritenexErrorCode2["API_BAD_REQUEST"] = "API_BAD_REQUEST";
+  WritenexErrorCode2["API_METHOD_NOT_ALLOWED"] = "API_METHOD_NOT_ALLOWED";
+  WritenexErrorCode2["API_INTERNAL_ERROR"] = "API_INTERNAL_ERROR";
+  WritenexErrorCode2["API_TIMEOUT"] = "API_TIMEOUT";
+  WritenexErrorCode2["IMAGE_INVALID_TYPE"] = "IMAGE_INVALID_TYPE";
+  WritenexErrorCode2["IMAGE_TOO_LARGE"] = "IMAGE_TOO_LARGE";
+  WritenexErrorCode2["IMAGE_UPLOAD_ERROR"] = "IMAGE_UPLOAD_ERROR";
+  WritenexErrorCode2["IMAGE_NOT_FOUND"] = "IMAGE_NOT_FOUND";
+  WritenexErrorCode2["VERSION_NOT_FOUND"] = "VERSION_NOT_FOUND";
+  WritenexErrorCode2["VERSION_MANIFEST_CORRUPT"] = "VERSION_MANIFEST_CORRUPT";
+  WritenexErrorCode2["VERSION_LOCK_TIMEOUT"] = "VERSION_LOCK_TIMEOUT";
+  WritenexErrorCode2["VERSION_SAVE_ERROR"] = "VERSION_SAVE_ERROR";
+  WritenexErrorCode2["VERSION_RESTORE_ERROR"] = "VERSION_RESTORE_ERROR";
+  WritenexErrorCode2["PATTERN_INVALID"] = "PATTERN_INVALID";
+  WritenexErrorCode2["PATTERN_MISSING_TOKEN"] = "PATTERN_MISSING_TOKEN";
+  WritenexErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return WritenexErrorCode2;
+})(WritenexErrorCode || {});
+var ERROR_HTTP_STATUS = {
+  // Configuration errors - 500 (server misconfiguration)
+  ["CONFIG_NOT_FOUND" /* CONFIG_NOT_FOUND */]: 500,
+  ["CONFIG_INVALID" /* CONFIG_INVALID */]: 500,
+  ["CONFIG_PARSE_ERROR" /* CONFIG_PARSE_ERROR */]: 500,
+  // Filesystem errors
+  ["FS_READ_ERROR" /* FS_READ_ERROR */]: 500,
+  ["FS_WRITE_ERROR" /* FS_WRITE_ERROR */]: 500,
+  ["FS_DELETE_ERROR" /* FS_DELETE_ERROR */]: 500,
+  ["FS_PERMISSION_DENIED" /* FS_PERMISSION_DENIED */]: 403,
+  ["FS_PATH_NOT_FOUND" /* FS_PATH_NOT_FOUND */]: 404,
+  ["FS_PATH_TRAVERSAL" /* FS_PATH_TRAVERSAL */]: 400,
+  // Content errors
+  ["CONTENT_NOT_FOUND" /* CONTENT_NOT_FOUND */]: 404,
+  ["CONTENT_PARSE_ERROR" /* CONTENT_PARSE_ERROR */]: 500,
+  ["CONTENT_VALIDATION_ERROR" /* CONTENT_VALIDATION_ERROR */]: 400,
+  ["CONTENT_ALREADY_EXISTS" /* CONTENT_ALREADY_EXISTS */]: 409,
+  ["CONTENT_INVALID_SLUG" /* CONTENT_INVALID_SLUG */]: 400,
+  ["CONTENT_CONFLICT" /* CONTENT_CONFLICT */]: 409,
+  // Collection errors
+  ["COLLECTION_NOT_FOUND" /* COLLECTION_NOT_FOUND */]: 404,
+  ["COLLECTION_EMPTY" /* COLLECTION_EMPTY */]: 404,
+  ["COLLECTION_DISCOVERY_ERROR" /* COLLECTION_DISCOVERY_ERROR */]: 500,
+  // API errors
+  ["API_BAD_REQUEST" /* API_BAD_REQUEST */]: 400,
+  ["API_METHOD_NOT_ALLOWED" /* API_METHOD_NOT_ALLOWED */]: 405,
+  ["API_INTERNAL_ERROR" /* API_INTERNAL_ERROR */]: 500,
+  ["API_TIMEOUT" /* API_TIMEOUT */]: 504,
+  // Image errors
+  ["IMAGE_INVALID_TYPE" /* IMAGE_INVALID_TYPE */]: 400,
+  ["IMAGE_TOO_LARGE" /* IMAGE_TOO_LARGE */]: 413,
+  ["IMAGE_UPLOAD_ERROR" /* IMAGE_UPLOAD_ERROR */]: 500,
+  ["IMAGE_NOT_FOUND" /* IMAGE_NOT_FOUND */]: 404,
+  // Version history errors
+  ["VERSION_NOT_FOUND" /* VERSION_NOT_FOUND */]: 404,
+  ["VERSION_MANIFEST_CORRUPT" /* VERSION_MANIFEST_CORRUPT */]: 500,
+  ["VERSION_LOCK_TIMEOUT" /* VERSION_LOCK_TIMEOUT */]: 503,
+  ["VERSION_SAVE_ERROR" /* VERSION_SAVE_ERROR */]: 500,
+  ["VERSION_RESTORE_ERROR" /* VERSION_RESTORE_ERROR */]: 500,
+  // Pattern errors
+  ["PATTERN_INVALID" /* PATTERN_INVALID */]: 400,
+  ["PATTERN_MISSING_TOKEN" /* PATTERN_MISSING_TOKEN */]: 400,
+  // Unknown
+  ["UNKNOWN_ERROR" /* UNKNOWN_ERROR */]: 500
+};
+var WritenexError = class _WritenexError extends Error {
+  /** Error code for categorization */
+  code;
+  /** HTTP status code for API responses */
+  httpStatus;
+  /** Additional context data for debugging */
+  context;
+  /** Original error if this wraps another error */
+  cause;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "WritenexError";
+    this.code = code;
+    this.httpStatus = ERROR_HTTP_STATUS[code];
+    this.context = options?.context;
+    this.cause = options?.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _WritenexError);
+    }
+  }
+  /**
+   * Convert error to JSON for API responses
+   */
+  toJSON() {
+    return {
+      error: this.message,
+      code: this.code,
+      ...this.context ? { context: this.context } : {}
+    };
+  }
+  /**
+   * Create a user-friendly error message
+   */
+  toUserMessage() {
+    return this.message;
+  }
+};
+var PathTraversalError = class extends WritenexError {
+  constructor(requestedPath, basePath) {
+    super(
+      "FS_PATH_TRAVERSAL" /* FS_PATH_TRAVERSAL */,
+      "Invalid path: attempted path traversal detected",
+      { context: { requestedPath, basePath } }
+    );
+    this.name = "PathTraversalError";
+  }
+};
+var ContentNotFoundError = class extends WritenexError {
+  constructor(collection, contentId) {
+    super(
+      "CONTENT_NOT_FOUND" /* CONTENT_NOT_FOUND */,
+      `Content '${contentId}' not found in collection '${collection}'`,
+      { context: { collection, contentId } }
+    );
+    this.name = "ContentNotFoundError";
+  }
+};
+var ContentConflictError = class extends WritenexError {
+  /** Current content on disk */
+  serverContent;
+  /** Server's current mtime */
+  serverMtime;
+  /** Client's expected mtime */
+  clientMtime;
+  constructor(collection, contentId, serverContent, serverMtime, clientMtime) {
+    super(
+      "CONTENT_CONFLICT" /* CONTENT_CONFLICT */,
+      `Content '${contentId}' in '${collection}' was modified externally. Expected mtime: ${clientMtime}, actual: ${serverMtime}`,
+      {
+        context: {
+          collection,
+          contentId,
+          serverMtime,
+          clientMtime,
+          timeDiff: serverMtime - clientMtime
+        }
+      }
+    );
+    this.name = "ContentConflictError";
+    this.serverContent = serverContent;
+    this.serverMtime = serverMtime;
+    this.clientMtime = clientMtime;
+  }
+  /**
+   * Override toJSON to include conflict-specific data
+   */
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      serverContent: this.serverContent,
+      serverMtime: this.serverMtime,
+      clientMtime: this.clientMtime
+    };
+  }
+};
+var CollectionNotFoundError = class extends WritenexError {
+  constructor(collectionName) {
+    super(
+      "COLLECTION_NOT_FOUND" /* COLLECTION_NOT_FOUND */,
+      `Collection '${collectionName}' not found`,
+      { context: { collectionName } }
+    );
+    this.name = "CollectionNotFoundError";
+  }
+};
+var CollectionDiscoveryError = class extends WritenexError {
+  constructor(contentPath, cause) {
+    super(
+      "COLLECTION_DISCOVERY_ERROR" /* COLLECTION_DISCOVERY_ERROR */,
+      `Failed to discover collections in: ${contentPath}`,
+      { context: { contentPath }, cause }
+    );
+    this.name = "CollectionDiscoveryError";
+  }
+};
+var ApiBadRequestError = class extends WritenexError {
+  constructor(message, details) {
+    super("API_BAD_REQUEST" /* API_BAD_REQUEST */, message, { context: details });
+    this.name = "ApiBadRequestError";
+  }
+};
+var ApiMethodNotAllowedError = class extends WritenexError {
+  constructor(method, allowedMethods) {
+    super(
+      "API_METHOD_NOT_ALLOWED" /* API_METHOD_NOT_ALLOWED */,
+      `Method ${method} not allowed. Allowed: ${allowedMethods.join(", ")}`,
+      { context: { method, allowedMethods } }
+    );
+    this.name = "ApiMethodNotAllowedError";
+  }
+};
+var ImageInvalidTypeError = class extends WritenexError {
+  constructor(filename, supportedTypes) {
+    super(
+      "IMAGE_INVALID_TYPE" /* IMAGE_INVALID_TYPE */,
+      `Invalid image type for '${filename}'. Supported: ${supportedTypes.join(", ")}`,
+      { context: { filename, supportedTypes } }
+    );
+    this.name = "ImageInvalidTypeError";
+  }
+};
+var ImageNotFoundError = class extends WritenexError {
+  constructor(imagePath) {
+    super("IMAGE_NOT_FOUND" /* IMAGE_NOT_FOUND */, `Image not found: ${imagePath}`, {
+      context: { imagePath }
+    });
+    this.name = "ImageNotFoundError";
+  }
+};
+var VersionNotFoundError = class extends WritenexError {
+  constructor(collection, contentId, versionId) {
+    super(
+      "VERSION_NOT_FOUND" /* VERSION_NOT_FOUND */,
+      `Version '${versionId}' not found for content '${contentId}' in '${collection}'`,
+      { context: { collection, contentId, versionId } }
+    );
+    this.name = "VersionNotFoundError";
+  }
+};
+function isWritenexError(error) {
+  return error instanceof WritenexError;
+}
+function wrapError(error, defaultCode = "UNKNOWN_ERROR" /* UNKNOWN_ERROR */) {
+  if (isWritenexError(error)) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  const cause = error instanceof Error ? error : void 0;
+  return new WritenexError(defaultCode, message, { cause });
+}
+
+// src/filesystem/versions.ts
+import {
+  readFile,
+  writeFile,
+  mkdir,
+  readdir,
+  stat,
+  unlink
+} from "fs/promises";
+import { existsSync } from "fs";
+import { join, basename } from "path";
+import matter from "gray-matter";
+var PREVIEW_MAX_LENGTH = 100;
+var GITIGNORE_CONTENT = "*\n";
+var LABEL_FRONTMATTER_KEY = "_writenex_label";
+var LOCK_TIMEOUT_MS = 3e4;
+var LOCK_RETRY_INTERVAL_MS = 50;
+var locks = /* @__PURE__ */ new Map();
+async function acquireLock(storagePath, timeoutMs = LOCK_TIMEOUT_MS) {
+  const startTime = Date.now();
+  while (locks.has(storagePath)) {
+    const existingLock = locks.get(storagePath);
+    if (Date.now() - existingLock.acquiredAt > timeoutMs) {
+      console.warn(
+        `[writenex] Releasing stale lock for ${storagePath} (held for ${Date.now() - existingLock.acquiredAt}ms)`
+      );
+      existingLock.release();
+      locks.delete(storagePath);
+      break;
+    }
+    if (Date.now() - startTime > timeoutMs) {
+      throw new Error(
+        `[writenex] Timeout waiting for lock on ${storagePath} after ${timeoutMs}ms`
+      );
+    }
+    await Promise.race([
+      existingLock.promise,
+      new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS))
+    ]);
+  }
+  let releaseFunc;
+  const lockPromise = new Promise((resolve) => {
+    releaseFunc = resolve;
+  });
+  const lockEntry = {
+    promise: lockPromise,
+    release: releaseFunc,
+    acquiredAt: Date.now()
+  };
+  locks.set(storagePath, lockEntry);
+  return () => {
+    lockEntry.release();
+    locks.delete(storagePath);
+  };
+}
+async function withLock(storagePath, fn) {
+  const release = await acquireLock(storagePath);
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+}
+function generateVersionId() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
+  const randomSuffix = Math.random().toString(36).substring(2, 6);
+  return `${timestamp}-${randomSuffix}`;
+}
+function parseVersionId(versionId) {
+  const withoutSuffix = versionId.replace(/-[a-z0-9]{4}$/, "");
+  const isoString = withoutSuffix.replace(
+    /T(\d{2})-(\d{2})-(\d{2})\.(\d{3})Z/,
+    "T$1:$2:$3.$4Z"
+  );
+  const date = new Date(isoString);
+  return isNaN(date.getTime()) ? null : date;
+}
+function getVersionStoragePath(projectRoot, collection, contentId, config) {
+  return join(projectRoot, config.storagePath, collection, contentId);
+}
+function getVersionFilePath(storagePath, versionId) {
+  return join(storagePath, `${versionId}.md`);
+}
+function getManifestPath(storagePath) {
+  return join(storagePath, "manifest.json");
+}
+function generatePreview(content) {
+  try {
+    const { content: body } = matter(content);
+    const trimmed = body.trim();
+    if (trimmed.length <= PREVIEW_MAX_LENGTH) {
+      return trimmed;
+    }
+    return trimmed.substring(0, PREVIEW_MAX_LENGTH);
+  } catch {
+    const trimmed = content.trim();
+    return trimmed.length <= PREVIEW_MAX_LENGTH ? trimmed : trimmed.substring(0, PREVIEW_MAX_LENGTH);
+  }
+}
+function extractLabelFromContent(content) {
+  try {
+    const { data } = matter(content);
+    const label = data[LABEL_FRONTMATTER_KEY];
+    return typeof label === "string" ? label : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function injectLabelIntoContent(content, label) {
+  try {
+    const { data, content: body } = matter(content);
+    const newData = { ...data, [LABEL_FRONTMATTER_KEY]: label };
+    return matter.stringify(body, newData);
+  } catch {
+    return `---
+${LABEL_FRONTMATTER_KEY}: "${label}"
+---
+
+${content}`;
+  }
+}
+function stripLabelFromContent(content) {
+  try {
+    const { data, content: body } = matter(content);
+    if (LABEL_FRONTMATTER_KEY in data) {
+      const { [LABEL_FRONTMATTER_KEY]: _, ...cleanData } = data;
+      if (Object.keys(cleanData).length === 0) {
+        return body.startsWith("\n") ? body.slice(1) : body;
+      }
+      return matter.stringify(body, cleanData);
+    }
+    return content;
+  } catch {
+    return 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 });
+  }
+  if (!existsSync(gitignorePath)) {
+    await writeFile(gitignorePath, GITIGNORE_CONTENT, "utf-8");
+  }
+}
+async function ensureStorageDirectory(storagePath) {
+  if (!existsSync(storagePath)) {
+    await mkdir(storagePath, { recursive: true });
+  }
+}
+async function readManifest(storagePath) {
+  const manifestPath = getManifestPath(storagePath);
+  if (!existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(manifestPath, "utf-8");
+    const data = JSON.parse(content);
+    if (!data.contentId || !data.collection || !Array.isArray(data.versions)) {
+      console.warn(`[writenex] Corrupted manifest at ${manifestPath}`);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.warn(
+      `[writenex] Failed to read manifest at ${manifestPath}:`,
+      error
+    );
+    return null;
+  }
+}
+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");
+}
+function createEmptyManifest(collection, contentId) {
+  return {
+    contentId,
+    collection,
+    versions: [],
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function recoverManifest(storagePath, collection, contentId) {
+  const manifest = createEmptyManifest(collection, contentId);
+  if (!existsSync(storagePath)) {
+    return manifest;
+  }
+  try {
+    const files = await readdir(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);
+      try {
+        const content = await readFile(filePath, "utf-8");
+        const stats = await stat(filePath);
+        const timestamp = parseVersionId(versionId);
+        if (timestamp) {
+          const label = extractLabelFromContent(content);
+          const entry = {
+            id: versionId,
+            timestamp: timestamp.toISOString(),
+            preview: generatePreview(content),
+            size: stats.size,
+            ...label ? { label } : {}
+          };
+          manifest.versions.push(entry);
+        }
+      } catch {
+        console.warn(`[writenex] Skipping unreadable version file: ${file}`);
+      }
+    }
+    manifest.versions.sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    );
+    manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeManifest(storagePath, manifest);
+    return manifest;
+  } catch (error) {
+    console.warn(`[writenex] Failed to recover manifest:`, error);
+    return manifest;
+  }
+}
+async function getOrRecoverManifest(storagePath, collection, contentId) {
+  const manifest = await readManifest(storagePath);
+  if (manifest) {
+    return manifest;
+  }
+  return recoverManifest(storagePath, collection, contentId);
+}
+async function saveVersion(projectRoot, collection, contentId, content, config, options = {}) {
+  const { label, skipIfIdentical = false } = options;
+  if (!config.enabled) {
+    return { success: true };
+  }
+  const storagePath = getVersionStoragePath(
+    projectRoot,
+    collection,
+    contentId,
+    config
+  );
+  return withLock(storagePath, async () => {
+    try {
+      await ensureGitignore(projectRoot, config);
+      await ensureStorageDirectory(storagePath);
+      const manifest = await getOrRecoverManifest(
+        storagePath,
+        collection,
+        contentId
+      );
+      if (skipIfIdentical && manifest.versions.length > 0) {
+        const lastVersion = manifest.versions[0];
+        if (lastVersion) {
+          const lastVersionPath = getVersionFilePath(
+            storagePath,
+            lastVersion.id
+          );
+          if (existsSync(lastVersionPath)) {
+            try {
+              const lastContent = await readFile(lastVersionPath, "utf-8");
+              if (lastContent === content) {
+                return { success: true, version: lastVersion };
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      const now = /* @__PURE__ */ new Date();
+      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);
+      const entry = {
+        id: versionId,
+        timestamp: now.toISOString(),
+        preview: generatePreview(content),
+        size: stats.size,
+        ...label ? { label } : {}
+      };
+      manifest.versions.unshift(entry);
+      manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await writeManifest(storagePath, manifest);
+      await pruneVersionsInternal(storagePath, config);
+      return { success: true, version: entry };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[writenex] Failed to save version:`, error);
+      return { success: false, error: `Failed to save version: ${message}` };
+    }
+  });
+}
+async function getVersions(projectRoot, collection, contentId, config) {
+  if (!config.enabled) {
+    return [];
+  }
+  try {
+    const storagePath = getVersionStoragePath(
+      projectRoot,
+      collection,
+      contentId,
+      config
+    );
+    if (!existsSync(storagePath)) {
+      return [];
+    }
+    const manifest = await getOrRecoverManifest(
+      storagePath,
+      collection,
+      contentId
+    );
+    return [...manifest.versions].sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    );
+  } catch (error) {
+    console.warn(`[writenex] Failed to get versions:`, error);
+    return [];
+  }
+}
+async function getVersion(projectRoot, collection, contentId, versionId, config) {
+  if (!config.enabled) {
+    return null;
+  }
+  try {
+    const storagePath = getVersionStoragePath(
+      projectRoot,
+      collection,
+      contentId,
+      config
+    );
+    const versionPath = getVersionFilePath(storagePath, versionId);
+    if (!existsSync(versionPath)) {
+      return null;
+    }
+    const rawContent = await readFile(versionPath, "utf-8");
+    const stats = await stat(versionPath);
+    const labelFromContent = extractLabelFromContent(rawContent);
+    const content = stripLabelFromContent(rawContent);
+    const { data: frontmatter, content: body } = matter(content);
+    const timestamp = parseVersionId(versionId);
+    if (!timestamp) {
+      return null;
+    }
+    const manifest = await readManifest(storagePath);
+    const manifestEntry = manifest?.versions.find((v) => v.id === versionId);
+    const label = manifestEntry?.label ?? labelFromContent;
+    return {
+      id: versionId,
+      timestamp: timestamp.toISOString(),
+      preview: generatePreview(content),
+      size: stats.size,
+      content,
+      frontmatter,
+      body: body.trim(),
+      ...label ? { label } : {}
+    };
+  } catch (error) {
+    console.warn(`[writenex] Failed to get version ${versionId}:`, error);
+    return null;
+  }
+}
+async function deleteVersion(projectRoot, collection, contentId, versionId, config) {
+  const storagePath = getVersionStoragePath(
+    projectRoot,
+    collection,
+    contentId,
+    config
+  );
+  return withLock(storagePath, async () => {
+    try {
+      const versionPath = getVersionFilePath(storagePath, versionId);
+      if (!existsSync(versionPath)) {
+        return { success: false, error: `Version not found: ${versionId}` };
+      }
+      const manifest = await getOrRecoverManifest(
+        storagePath,
+        collection,
+        contentId
+      );
+      const entryIndex = manifest.versions.findIndex((v) => v.id === versionId);
+      const entry = entryIndex >= 0 ? manifest.versions[entryIndex] : void 0;
+      await unlink(versionPath);
+      if (entryIndex >= 0) {
+        manifest.versions.splice(entryIndex, 1);
+        manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await writeManifest(storagePath, manifest);
+      }
+      return { success: true, version: entry };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[writenex] Failed to delete version:`, error);
+      return { success: false, error: `Failed to delete version: ${message}` };
+    }
+  });
+}
+async function clearVersions(projectRoot, collection, contentId, config) {
+  const storagePath = getVersionStoragePath(
+    projectRoot,
+    collection,
+    contentId,
+    config
+  );
+  if (!existsSync(storagePath)) {
+    return { success: true };
+  }
+  return withLock(storagePath, async () => {
+    try {
+      const files = await readdir(storagePath);
+      const versionFiles = files.filter(
+        (f) => f.endsWith(".md") && f !== "manifest.json"
+      );
+      for (const file of versionFiles) {
+        const filePath = join(storagePath, file);
+        try {
+          await unlink(filePath);
+        } catch {
+        }
+      }
+      const manifest = createEmptyManifest(collection, contentId);
+      await writeManifest(storagePath, manifest);
+      return { success: true };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[writenex] Failed to clear versions:`, error);
+      return { success: false, error: `Failed to clear versions: ${message}` };
+    }
+  });
+}
+async function pruneVersionsInternal(storagePath, config) {
+  try {
+    if (!existsSync(storagePath)) {
+      return { success: true };
+    }
+    const manifest = await readManifest(storagePath);
+    if (!manifest) {
+      return { success: true };
+    }
+    const labeledVersions = manifest.versions.filter((v) => v.label);
+    const unlabeledVersions = manifest.versions.filter((v) => !v.label);
+    if (unlabeledVersions.length <= config.maxVersions) {
+      return { success: true };
+    }
+    const sortedUnlabeled = [...unlabeledVersions].sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+    const toDelete = sortedUnlabeled.slice(
+      0,
+      unlabeledVersions.length - config.maxVersions
+    );
+    for (const version of toDelete) {
+      const versionPath = getVersionFilePath(storagePath, version.id);
+      try {
+        if (existsSync(versionPath)) {
+          await unlink(versionPath);
+        }
+      } catch {
+      }
+    }
+    const remainingUnlabeled = sortedUnlabeled.slice(
+      unlabeledVersions.length - config.maxVersions
+    );
+    manifest.versions = [...labeledVersions, ...remainingUnlabeled].sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    );
+    manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeManifest(storagePath, manifest);
+    return { success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[writenex] Failed to prune versions:`, error);
+    return { success: false, error: `Failed to prune versions: ${message}` };
+  }
+}
+async function pruneVersions(projectRoot, collection, contentId, config) {
+  const storagePath = getVersionStoragePath(
+    projectRoot,
+    collection,
+    contentId,
+    config
+  );
+  if (!existsSync(storagePath)) {
+    return { success: true };
+  }
+  return withLock(
+    storagePath,
+    () => pruneVersionsInternal(storagePath, config)
+  );
+}
+async function restoreVersion(projectRoot, collection, contentId, versionId, contentFilePath, config, options = {}) {
+  const { safetySnapshotLabel = "Before restore", skipSafetySnapshot = false } = options;
+  try {
+    const versionToRestore = await getVersion(
+      projectRoot,
+      collection,
+      contentId,
+      versionId,
+      config
+    );
+    if (!versionToRestore) {
+      return {
+        success: false,
+        error: `Version not found: ${versionId}`
+      };
+    }
+    let safetySnapshot;
+    if (!skipSafetySnapshot && existsSync(contentFilePath)) {
+      try {
+        const currentContent = await readFile(contentFilePath, "utf-8");
+        const snapshotResult = await saveVersion(
+          projectRoot,
+          collection,
+          contentId,
+          currentContent,
+          config,
+          { label: safetySnapshotLabel }
+        );
+        if (snapshotResult.success && snapshotResult.version) {
+          safetySnapshot = snapshotResult.version;
+        }
+      } catch (error) {
+        console.warn(
+          `[writenex] Failed to create safety snapshot before restore:`,
+          error
+        );
+      }
+    }
+    await writeFile(contentFilePath, versionToRestore.content, "utf-8");
+    return {
+      success: true,
+      version: {
+        id: versionToRestore.id,
+        timestamp: versionToRestore.timestamp,
+        preview: versionToRestore.preview,
+        size: versionToRestore.size,
+        ...versionToRestore.label ? { label: versionToRestore.label } : {}
+      },
+      content: versionToRestore.content,
+      safetySnapshot
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[writenex] Failed to restore version:`, error);
+    return {
+      success: false,
+      error: `Failed to restore version: ${message}`
+    };
+  }
+}
+
+// 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 slugify from "slugify";
+function generateSlug(text) {
+  return slugify(text, {
+    lower: true,
+    strict: true,
+    trim: true
+  });
+}
+function contentExists(slug, collectionPath, filePattern) {
+  const relativePath = generatePathFromPattern(filePattern, { slug });
+  const fullPath = join2(collectionPath, relativePath);
+  if (filePattern.includes("/index.")) {
+    const folderPath = join2(collectionPath, slug);
+    return existsSync2(folderPath);
+  }
+  return existsSync2(fullPath);
+}
+async function generateUniqueSlug(baseSlug, collectionPath, filePattern = "{slug}.md") {
+  let slug = baseSlug;
+  let counter = 2;
+  while (contentExists(slug, collectionPath, filePattern)) {
+    slug = `${baseSlug}-${counter}`;
+    counter++;
+  }
+  return slug;
+}
+function frontmatterToYaml(frontmatter) {
+  const lines = [];
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (typeof value === "string") {
+      if (value.includes(":") || value.includes("#") || value.includes("\n")) {
+        lines.push(`${key}: "${value.replace(/"/g, '\\"')}"`);
+      } else {
+        lines.push(`${key}: ${value}`);
+      }
+    } else if (typeof value === "number" || typeof value === "boolean") {
+      lines.push(`${key}: ${value}`);
+    } else if (value instanceof Date) {
+      lines.push(`${key}: ${value.toISOString().split("T")[0]}`);
+    } else if (Array.isArray(value)) {
+      if (value.length === 0) {
+        lines.push(`${key}: []`);
+      } else {
+        lines.push(`${key}:`);
+        for (const item of value) {
+          lines.push(`  - ${item}`);
+        }
+      }
+    } else if (typeof value === "object") {
+      lines.push(`${key}:`);
+      for (const [subKey, subValue] of Object.entries(value)) {
+        lines.push(`  ${subKey}: ${subValue}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function createFileContent(frontmatter, body) {
+  const yaml = frontmatterToYaml(frontmatter);
+  return `---
+${yaml}
+---
+
+${body}`;
+}
+async function createContent(collectionPath, options) {
+  const {
+    frontmatter,
+    body,
+    slug: customSlug,
+    filePattern = "{slug}.md",
+    customTokens = {}
+  } = options;
+  try {
+    const validation = isValidPattern(filePattern);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: `Invalid file pattern: ${validation.error}`
+      };
+    }
+    const title = frontmatter.title;
+    const baseSlug = customSlug ?? (title ? generateSlug(title) : "untitled");
+    const slug = await generateUniqueSlug(
+      baseSlug,
+      collectionPath,
+      filePattern
+    );
+    const tokens = resolvePatternTokens(filePattern, {
+      slug,
+      frontmatter,
+      customTokens
+    });
+    const relativePath = generatePathFromPattern(filePattern, tokens);
+    const filePath = join2(collectionPath, relativePath);
+    const parentDir = dirname(filePath);
+    if (!existsSync2(parentDir)) {
+      await mkdir2(parentDir, { recursive: true });
+    }
+    const content = createFileContent(frontmatter, body);
+    await writeFile2(filePath, content, "utf-8");
+    return {
+      success: true,
+      id: slug,
+      path: filePath
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to create content: ${message}`
+    };
+  }
+}
+async function updateContent(filePath, collectionPath, options) {
+  const { projectRoot, collection, versionHistoryConfig, expectedMtime } = options;
+  try {
+    const existing = await readContentFile(filePath, collectionPath);
+    if (!existing.success || !existing.content) {
+      return {
+        success: false,
+        error: existing.error ?? "Content not found"
+      };
+    }
+    if (expectedMtime !== void 0 && existing.content.mtime !== void 0) {
+      const mtimeDiff = Math.abs(existing.content.mtime - expectedMtime);
+      if (mtimeDiff > 1) {
+        const conflictError = new ContentConflictError(
+          collection ?? "unknown",
+          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;
+      }
+      case "colocated":
+      default: {
+        const paths = getColocatedPath(
+          projectRoot,
+          collection,
+          contentId,
+          uniqueFilename
+        );
+        storagePath = paths.storagePath;
+        markdownPath = paths.markdownPath;
+        break;
+      }
+    }
+    const dir = dirname2(storagePath);
+    if (!existsSync3(dir)) {
+      await mkdir3(dir, { recursive: true });
+    }
+    await writeFile3(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 = 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;
+  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}`
+    };
+  }
+}
+
+export {
+  WritenexErrorCode,
+  WritenexError,
+  PathTraversalError,
+  ContentNotFoundError,
+  CollectionNotFoundError,
+  CollectionDiscoveryError,
+  ApiBadRequestError,
+  ApiMethodNotAllowedError,
+  ImageInvalidTypeError,
+  ImageNotFoundError,
+  VersionNotFoundError,
+  isWritenexError,
+  wrapError,
+  generateVersionId,
+  parseVersionId,
+  getVersionStoragePath,
+  getVersionFilePath,
+  getManifestPath,
+  generatePreview,
+  ensureGitignore,
+  ensureStorageDirectory,
+  readManifest,
+  writeManifest,
+  createEmptyManifest,
+  recoverManifest,
+  getOrRecoverManifest,
+  saveVersion,
+  getVersions,
+  getVersion,
+  deleteVersion,
+  clearVersions,
+  pruneVersions,
+  restoreVersion,
+  generateSlug,
+  generateUniqueSlug,
+  createContent,
+  updateContent,
+  deleteContent,
+  DEFAULT_IMAGE_CONFIG,
+  isValidImageFile,
+  uploadImage,
+  parseMultipartFormData,
+  getContentImageFolder,
+  detectContentStructure,
+  scanDirectoryForImages,
+  calculateRelativePath,
+  discoverContentImages
+};
+//# sourceMappingURL=chunk-CF2XXJFF.js.map