@nuasite/cms-sidecar 0.43.0-beta.4 → 0.43.0-beta.8

package/dist/cli.js

@@ -21791,6 +21791,7 @@ var import_parser = __toESM(require_lib(), 1);
 var FIELD_TYPES = [
   "text",
   "textarea",
+  "markdown",
   "date",
   "datetime",
   "time",
@@ -21828,7 +21829,8 @@ var FIELD_HELPER_TYPES = new Set([
   "time",
   "year",
   "month",
-  "textarea"
+  "textarea",
+  "markdown"
 ]);
 var VALID_HINT_KEYS = new Set([
   "min",
@@ -21943,6 +21945,8 @@ function parseConfigSource(source, _sourcePath) {
     const loaderOptions = loaderProperty?.type === "ObjectProperty" ? extractGlobLoaderOptions(loaderProperty.value, bindings) : {};
     const loaderPattern = loaderOptions.pattern;
     const loaderBase = loaderOptions.base;
+    const cmsProperty = decl.properties.find((p) => p.type === "ObjectProperty" && propertyKeyName(p.key) === "cms");
+    const layout = cmsProperty?.type === "ObjectProperty" ? parseCmsLayout(cmsProperty.value, bindings) : undefined;
     const schemaProperty = decl.properties.find((p) => p.type === "ObjectProperty" && propertyKeyName(p.key) === "schema");
     if (!schemaProperty || schemaProperty.type !== "ObjectProperty") {
       if (!loaderPattern)
@@ -21951,7 +21955,8 @@ function parseConfigSource(source, _sourcePath) {
         name: collectionName,
         fields: [],
         loaderPattern,
-        loaderBase
+        loaderBase,
+        layout
       });
       continue;
     }
@@ -21963,7 +21968,8 @@ function parseConfigSource(source, _sourcePath) {
         name: collectionName,
         fields: [],
         loaderPattern,
-        loaderBase
+        loaderBase,
+        layout
       });
       continue;
     }
@@ -21971,13 +21977,69 @@ function parseConfigSource(source, _sourcePath) {
       name: collectionName,
       fields: parseSchemaFields(schemaObject, bindings),
       loaderPattern,
-      loaderBase
+      loaderBase,
+      layout
     });
   }
   return result;
 }
+function parseCmsLayout(node, bindings) {
+  const resolved = resolveExpression(node, bindings);
+  if (resolved.type !== "ObjectExpression")
+    return;
+  const layout = {};
+  for (const prop of resolved.properties) {
+    if (prop.type !== "ObjectProperty")
+      continue;
+    const key = propertyKeyName(prop.key);
+    const value = resolveExpression(prop.value, bindings);
+    if (key === "display") {
+      if (value.type === "StringLiteral" && (value.value === "tabs" || value.value === "sections"))
+        layout.display = value.value;
+    } else if (key === "sidebar") {
+      if (value.type === "ArrayExpression")
+        layout.sidebar = stringArray(value);
+    } else if (key === "sections") {
+      if (value.type === "ArrayExpression") {
+        const sections = value.elements.map((el) => el && el.type !== "SpreadElement" ? parseLayoutSection(resolveExpression(el, bindings)) : null).filter((s) => s !== null);
+        if (sections.length > 0)
+          layout.sections = sections;
+      }
+    }
+  }
+  return Object.keys(layout).length > 0 ? layout : undefined;
+}
+function parseLayoutSection(node) {
+  if (node.type !== "ObjectExpression")
+    return null;
+  let title;
+  let fields = [];
+  let collapsed = false;
+  for (const prop of node.properties) {
+    if (prop.type !== "ObjectProperty")
+      continue;
+    const key = propertyKeyName(prop.key);
+    if (key === "title" && prop.value.type === "StringLiteral")
+      title = prop.value.value;
+    else if (key === "fields" && prop.value.type === "ArrayExpression")
+      fields = stringArray(prop.value);
+    else if (key === "collapsed" && prop.value.type === "BooleanLiteral")
+      collapsed = prop.value.value;
+  }
+  if (title === undefined || fields.length === 0)
+    return null;
+  return collapsed ? { title, fields, collapsed } : { title, fields };
+}
+function stringArray(node) {
+  const out = [];
+  for (const el of node.elements) {
+    if (el?.type === "StringLiteral")
+      out.push(el.value);
+  }
+  return out;
+}
 function isDefineCollectionCallee(callee) {
-  return callee.type === "Identifier" && callee.name === "defineCollection";
+  return callee.type === "Identifier" && (callee.name === "defineCollection" || callee.name === "defineCmsCollection");
 }
 function propertyKeyName(key) {
   if (key.type === "Identifier")
@@ -22127,6 +22189,9 @@ function analyzeBaseCall(node, field, bindings) {
       const hints = parseHintsFromObject(firstArg);
       if (hints)
         field.hints = hints;
+      const layout = parseFieldLayoutFromObject(firstArg);
+      if (layout)
+        field.layout = layout;
     }
     return;
   }
@@ -22219,6 +22284,49 @@ function assignHint(hints, key, value) {
       return;
   }
 }
+function parseFieldLayoutFromObject(obj) {
+  const layout = {};
+  for (const prop of obj.properties) {
+    if (prop.type !== "ObjectProperty")
+      continue;
+    const key = propertyKeyName(prop.key);
+    const value = prop.value;
+    switch (key) {
+      case "label":
+        if (value.type === "StringLiteral")
+          layout.label = value.value;
+        break;
+      case "help":
+        if (value.type === "StringLiteral")
+          layout.help = value.value;
+        break;
+      case "group":
+        if (value.type === "StringLiteral")
+          layout.group = value.value;
+        break;
+      case "width":
+        if (value.type === "StringLiteral" && (value.value === "full" || value.value === "half"))
+          layout.width = value.value;
+        break;
+      case "order":
+        if (value.type === "NumericLiteral") {
+          layout.order = value.value;
+        } else if (value.type === "UnaryExpression" && value.operator === "-" && value.argument.type === "NumericLiteral") {
+          layout.order = -value.argument.value;
+        }
+        break;
+      case "sidebar":
+        if (value.type === "BooleanLiteral")
+          layout.sidebar = value.value;
+        break;
+      case "hidden":
+        if (value.type === "BooleanLiteral")
+          layout.hidden = value.value;
+        break;
+    }
+  }
+  return Object.keys(layout).length > 0 ? layout : undefined;
+}
 
 // ../cms-core/src/shared.ts
 function slugifyHref(text) {
@@ -22548,6 +22656,41 @@ async function buildCollectionDefinition(fs, basePath, sources, collectionName,
   assignFieldMetadata(def.fields, allDirectives);
   return def;
 }
+async function buildDataCollectionDefinition(fs, basePath, sources, collectionName, contentDir) {
+  if (sources.length === 0)
+    return null;
+  const sourceBasePath = getCollectionSourceBasePath(basePath, collectionName, contentDir);
+  const fieldMap = new Map;
+  const entryInfos = [];
+  const ext = sources.some((s) => s.relPath.endsWith(".json")) ? "json" : sources.some((s) => s.relPath.endsWith(".yaml")) ? "yaml" : "yml";
+  const fileContents = await Promise.all(sources.map((s) => fs.readFile(path.join(basePath, s.relPath)).catch(() => null)));
+  for (let i = 0;i < sources.length; i++) {
+    const source = sources[i];
+    const raw = fileContents[i];
+    if (raw === null)
+      continue;
+    let data = null;
+    try {
+      data = source.relPath.endsWith(".json") ? JSON.parse(raw) : import_yaml.parse(raw);
+    } catch {
+      continue;
+    }
+    if (!data || typeof data !== "object")
+      continue;
+    const title = typeof data.name === "string" ? data.name : typeof data.title === "string" ? data.title : undefined;
+    entryInfos.push({
+      slug: source.slug,
+      title,
+      sourcePath: path.join(sourceBasePath, source.relPath),
+      data
+    });
+    collectFieldObservations(fieldMap, data, sources.length);
+  }
+  return assembleCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
+    type: "data",
+    fileExtension: ext
+  });
+}
 async function scanCollection(fs, collectionPath, collectionName, contentDir) {
   const dirEntries = await fs.list(collectionPath);
   if (dirEntries.length === 0)
@@ -22585,10 +22728,16 @@ async function scanCollection(fs, collectionPath, collectionName, contentDir) {
 }
 async function scanGlobCollection(fs, collectionName, baseRel, pattern, contentDir) {
   const matches = await fs.glob(path.join(baseRel, pattern));
-  const sources = matches.filter((rel) => rel.endsWith(".md") || rel.endsWith(".mdx")).map((rel) => path.relative(baseRel, rel)).filter((relToBase) => !relToBase.split("/").some((seg) => seg.startsWith("_") || seg.startsWith("."))).map((relToBase) => ({ slug: relToBase.replace(/\.(md|mdx)$/, ""), relPath: relToBase }));
-  if (sources.length === 0)
-    return null;
-  return await buildCollectionDefinition(fs, baseRel, sources, collectionName, contentDir);
+  const rels = matches.map((rel) => path.relative(baseRel, rel)).filter((relToBase) => !relToBase.split("/").some((seg) => seg.startsWith("_") || seg.startsWith(".")));
+  const mdSources = rels.filter((relToBase) => relToBase.endsWith(".md") || relToBase.endsWith(".mdx")).map((relToBase) => ({ slug: relToBase.replace(/\.(md|mdx)$/, ""), relPath: relToBase }));
+  if (mdSources.length > 0) {
+    return await buildCollectionDefinition(fs, baseRel, mdSources, collectionName, contentDir);
+  }
+  const dataSources = rels.filter((relToBase) => /\.(ya?ml|json)$/.test(relToBase)).map((relToBase) => ({ slug: relToBase.replace(/\.(ya?ml|json)$/, ""), relPath: relToBase }));
+  if (dataSources.length > 0) {
+    return await buildDataCollectionDefinition(fs, baseRel, dataSources, collectionName, contentDir);
+  }
+  return null;
 }
 function applyParsedConfig(collections, parsed) {
   for (const [collectionName, parsedColl] of parsed) {
@@ -22606,8 +22755,29 @@ function applyParsedConfig(collections, parsed) {
         continue;
       applyParsedFieldOverrides(field, pf);
     }
+    if (parsedColl.layout)
+      def.layout = parsedColl.layout;
   }
 }
+function applyParsedFieldLayout(field, pf) {
+  const layout = pf.layout;
+  if (!layout)
+    return;
+  if (layout.label !== undefined)
+    field.label = layout.label;
+  if (layout.help !== undefined)
+    field.help = layout.help;
+  if (layout.group !== undefined)
+    field.group = layout.group;
+  if (layout.width !== undefined)
+    field.width = layout.width;
+  if (layout.order !== undefined)
+    field.order = layout.order;
+  if (layout.sidebar)
+    field.position = "sidebar";
+  if (layout.hidden)
+    field.hidden = true;
+}
 function applyParsedFieldOverrides(field, pf) {
   if (pf.type) {
     field.type = pf.type;
@@ -22621,6 +22791,7 @@ function applyParsedFieldOverrides(field, pf) {
   if (pf.astroImage)
     field.astroImage = true;
   field.required = pf.required;
+  applyParsedFieldLayout(field, pf);
   if (pf.fields) {
     const existingByName = new Map((field.fields ?? []).map((f) => [f.name, f]));
     field.fields = pf.fields.map((subPf) => {
@@ -22649,6 +22820,7 @@ function parsedFieldToFieldDefinition(pf) {
     fd.astroImage = true;
   if (pf.fields)
     fd.fields = pf.fields.map(parsedFieldToFieldDefinition);
+  applyParsedFieldLayout(fd, pf);
   return fd;
 }
 function applyCollectionOrderBy(collections, parsed) {
@@ -22874,38 +23046,7 @@ async function scanDataCollection(fs, collectionPath, collectionName, contentDir
     if (entry)
       sources.push(entry);
   }
-  if (sources.length === 0)
-    return null;
-  const fieldMap = new Map;
-  const entryInfos = [];
-  const ext = sources.some((s) => s.relPath.endsWith(".json")) ? "json" : sources.some((s) => s.relPath.endsWith(".yaml")) ? "yaml" : "yml";
-  const fileContents = await Promise.all(sources.map((s) => fs.readFile(path.join(collectionPath, s.relPath)).catch(() => null)));
-  for (let i = 0;i < sources.length; i++) {
-    const source = sources[i];
-    const raw = fileContents[i];
-    if (raw === null)
-      continue;
-    let data = null;
-    try {
-      data = source.relPath.endsWith(".json") ? JSON.parse(raw) : import_yaml.parse(raw);
-    } catch {
-      continue;
-    }
-    if (!data || typeof data !== "object")
-      continue;
-    const title = typeof data.name === "string" ? data.name : typeof data.title === "string" ? data.title : undefined;
-    entryInfos.push({
-      slug: source.slug,
-      title,
-      sourcePath: path.join(contentDir, collectionName, source.relPath),
-      data
-    });
-    collectFieldObservations(fieldMap, data, sources.length);
-  }
-  return assembleCollectionDefinition(collectionName, contentDir, fieldMap, entryInfos, sources.length, {
-    type: "data",
-    fileExtension: ext
-  });
+  return await buildDataCollectionDefinition(fs, collectionPath, sources, collectionName, contentDir);
 }
 async function scanCollections(fs, contentDir = "src/content", parseCache = new Map) {
   const collections = {};
@@ -23190,6 +23331,123 @@ function extractPreviewWidth(content) {
 }
 // ../cms-core/src/handlers/entry-ops.ts
 var import_yaml2 = __toESM(require_dist(), 1);
+
+// ../cms-core/src/media/local.ts
+import { randomUUID } from "crypto";
+import fs from "fs/promises";
+import path3 from "path";
+function createLocalStorageAdapter(options = {}) {
+  const dir = path3.resolve(options.dir ?? "public/uploads");
+  const urlPrefix = (options.urlPrefix ?? "/uploads").replace(/\/$/, "");
+  return {
+    staticFiles: { urlPrefix, dir },
+    async list(opts) {
+      const limit = opts?.limit ?? 50;
+      const offset = opts?.cursor ? parseInt(opts.cursor, 10) : 0;
+      const folder = opts?.folder ?? "";
+      const targetDir = folder ? path3.join(dir, folder) : dir;
+      await fs.mkdir(targetDir, { recursive: true });
+      const entries = await fs.readdir(targetDir, { withFileTypes: true });
+      const folders = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({
+        name: e.name,
+        path: folder ? `${folder}/${e.name}` : e.name
+      })).sort((a, b) => a.name.localeCompare(b.name));
+      const files = entries.filter((e) => e.isFile() && !e.name.startsWith("."));
+      const withStats = await Promise.all(files.map(async (f) => {
+        const filePath = path3.join(targetDir, f.name);
+        const stat = await fs.stat(filePath);
+        return { name: f.name, stat };
+      }));
+      withStats.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+      const slice = withStats.slice(offset, offset + limit);
+      const hasMore = offset + limit < withStats.length;
+      const urlFolder = folder ? `/${folder}` : "";
+      const items = slice.map((f) => {
+        const ext = path3.extname(f.name).toLowerCase();
+        const contentType = mimeFromExt(ext);
+        return {
+          id: folder ? `${folder}/${f.name}` : f.name,
+          url: `${urlPrefix}${urlFolder}/${f.name}`,
+          filename: f.name,
+          contentType,
+          uploadedAt: f.stat.mtime.toISOString(),
+          folder: folder || undefined
+        };
+      });
+      return {
+        items,
+        folders,
+        hasMore,
+        cursor: hasMore ? String(offset + limit) : undefined
+      };
+    },
+    async upload(file, filename, contentType, uploadOpts) {
+      const folder = uploadOpts?.folder ?? "";
+      const targetDir = folder ? path3.join(dir, folder) : dir;
+      await fs.mkdir(targetDir, { recursive: true });
+      const ext = getFileExtension(filename);
+      const uuid = randomUUID();
+      const newFilename = `${uuid}${ext ? `.${ext}` : ""}`;
+      const filePath = path3.join(targetDir, newFilename);
+      await fs.writeFile(filePath, file);
+      const urlFolder = folder ? `/${folder}` : "";
+      const id = folder ? `${folder}/${newFilename}` : newFilename;
+      return {
+        success: true,
+        url: `${urlPrefix}${urlFolder}/${newFilename}`,
+        filename: newFilename,
+        id
+      };
+    },
+    async delete(id) {
+      const safePath = id.split("/").map((s) => path3.basename(s)).join("/");
+      const filePath = path3.join(dir, safePath);
+      try {
+        await fs.unlink(filePath);
+        return { success: true };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, error: message };
+      }
+    },
+    async createFolder(folder) {
+      const segments = folder.split("/").filter(Boolean);
+      if (segments.some((s) => s === ".." || s === ".")) {
+        return { success: false, error: "Invalid folder name" };
+      }
+      try {
+        await fs.mkdir(path3.join(dir, ...segments), { recursive: true });
+        return { success: true };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, error: message };
+      }
+    }
+  };
+}
+function getFileExtension(filename) {
+  const parts = filename.split(".");
+  const ext = parts.length > 1 ? parts.pop()?.toLowerCase() ?? "" : "";
+  return /^[a-z0-9]+$/.test(ext) ? ext : "";
+}
+var MIME_BY_EXT = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".pdf": "application/pdf"
+};
+function mimeFromExt(ext) {
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+
+// ../cms-core/src/handlers/entry-ops.ts
 var MARKDOWN_EXTENSIONS = ["md", "mdx"];
 function fileExtension(filePath) {
   const idx = filePath.lastIndexOf(".");
@@ -23199,8 +23457,18 @@ function isDataFile(filePath) {
   const ext = fileExtension(filePath);
   return ext === "json" || ext === "yaml" || ext === "yml";
 }
+async function resolveCollectionDir(deps, collection) {
+  const parsed = await parseContentConfig(deps.fs, deps.parseCache);
+  const loaderBase = parsed.get(collection)?.loaderBase;
+  if (loaderBase) {
+    const normalized = loaderBase.replace(/^\.\/+/, "").replace(/[/\\]+$/, "");
+    if (normalized)
+      return normalized;
+  }
+  return `${deps.contentDir}/${collection}`;
+}
 async function resolveEntryPath(deps, collection, slug) {
-  const base = `${deps.contentDir}/${collection}`;
+  const base = await resolveCollectionDir(deps, collection);
   const flatExts = ["md", "mdx", "json", "yaml", "yml"];
   for (const ext of flatExts) {
     const candidate = `${base}/${slug}.${ext}`;
@@ -23214,6 +23482,36 @@ async function resolveEntryPath(deps, collection, slug) {
   }
   return null;
 }
+function resolveRelativePath(baseDir, rel) {
+  const out = rel.startsWith("/") ? [] : baseDir.split("/").filter(Boolean);
+  for (const seg of rel.replace(/^\/+/, "").split("/")) {
+    if (seg === "" || seg === ".")
+      continue;
+    if (seg === "..") {
+      if (out.length === 0)
+        return null;
+      out.pop();
+      continue;
+    }
+    out.push(seg);
+  }
+  return out.join("/");
+}
+function extOf(filePath) {
+  const idx = filePath.lastIndexOf(".");
+  return idx >= 0 ? filePath.slice(idx).toLowerCase() : "";
+}
+async function getEntryAsset(deps, collection, slug, assetPath) {
+  const sourcePath = await resolveEntryPath(deps, collection, slug);
+  if (!sourcePath)
+    return null;
+  const lastSlash = sourcePath.lastIndexOf("/");
+  const baseDir = lastSlash >= 0 ? sourcePath.slice(0, lastSlash) : "";
+  const resolved = resolveRelativePath(baseDir, assetPath);
+  if (!resolved || !await deps.fs.exists(resolved))
+    return null;
+  return { bytes: await deps.fs.readBytes(resolved), contentType: mimeFromExt(extOf(resolved)) };
+}
 function parseFrontmatter2(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -23331,7 +23629,7 @@ async function detectCollectionMarkdownLayout(deps, collection) {
   return "flat";
 }
 async function inferLayoutFromExistingEntries(deps, collection) {
-  const collectionPath = `${deps.contentDir}/${collection}`;
+  const collectionPath = await resolveCollectionDir(deps, collection);
   const dirEntries = await deps.fs.list(collectionPath);
   if (dirEntries.length === 0)
     return null;
@@ -23405,7 +23703,8 @@ async function createEntry(deps, input) {
   }
   const isData = ext === "json" || ext === "yaml" || ext === "yml";
   const layout = isData ? "flat" : await detectCollectionMarkdownLayout(deps, collection);
-  const sourcePath = layout === "index" ? `${deps.contentDir}/${collection}/${normalizedSlug}/index.${ext}` : `${deps.contentDir}/${collection}/${normalizedSlug}.${ext}`;
+  const collectionDir = await resolveCollectionDir(deps, collection);
+  const sourcePath = layout === "index" ? `${collectionDir}/${normalizedSlug}/index.${ext}` : `${collectionDir}/${normalizedSlug}.${ext}`;
   let fileContent;
   if (isData) {
     fileContent = ext === "json" ? JSON.stringify({ ...frontmatter }, null, 2) + `
@@ -23816,27 +24115,30 @@ function parseRedirectLines(lines) {
 }
 
 // ../cms-core/src/core.ts
-function createCmsCore(fs, opts = {}) {
+function createCmsCore(fs2, opts = {}) {
   const contentDir = opts.contentDir ?? "src/content";
   const componentDirs = opts.componentDirs ?? ["src/components"];
   const parseCache = new Map;
   const entryDeps = {
-    fs,
+    fs: fs2,
     contentDir,
     parseCache,
     componentDirs,
-    resolveComponentDefinitions: () => scanComponentDefinitions(fs, componentDirs)
+    resolveComponentDefinitions: () => scanComponentDefinitions(fs2, componentDirs)
   };
   return {
     scanCollections() {
-      return scanCollections(fs, contentDir, parseCache);
+      return scanCollections(fs2, contentDir, parseCache);
     },
     scanComponents() {
-      return scanComponentDefinitions(fs, componentDirs);
+      return scanComponentDefinitions(fs2, componentDirs);
     },
     getEntry(collection, slug) {
       return getEntry(entryDeps, collection, slug);
     },
+    getEntryAsset(collection, slug, assetPath) {
+      return getEntryAsset(entryDeps, collection, slug, assetPath);
+    },
     createEntry(input) {
       return createEntry(entryDeps, input);
     },
@@ -23856,28 +24158,28 @@ function createCmsCore(fs, opts = {}) {
       return removeArrayItem(entryDeps, input);
     },
     createPage(input) {
-      return createPage({ fs }, input);
+      return createPage({ fs: fs2 }, input);
     },
     duplicatePage(input) {
-      return duplicatePage({ fs }, input);
+      return duplicatePage({ fs: fs2 }, input);
     },
     deletePage(input) {
-      return deletePage({ fs }, input);
+      return deletePage({ fs: fs2 }, input);
     },
     getLayouts() {
-      return getLayouts({ fs });
+      return getLayouts({ fs: fs2 });
     },
     listRedirects() {
-      return listRedirects({ fs });
+      return listRedirects({ fs: fs2 });
     },
     addRedirect(input) {
-      return addRedirect({ fs }, input);
+      return addRedirect({ fs: fs2 }, input);
     },
     updateRedirect(input) {
-      return updateRedirect({ fs }, input);
+      return updateRedirect({ fs: fs2 }, input);
     },
     deleteRedirect(input) {
-      return deleteRedirect({ fs }, input);
+      return deleteRedirect({ fs: fs2 }, input);
     },
     media: opts.media
   };
@@ -23916,14 +24218,14 @@ function globToRegExp(glob) {
   return new RegExp(`^${re}$`);
 }
 // ../cms-core/src/fs/node-fs.ts
-import fs from "fs/promises";
-import path3 from "path";
+import fs2 from "fs/promises";
+import path4 from "path";
 function resolveWithinRoot(root, filePath) {
-  const resolvedRoot = path3.resolve(root);
+  const resolvedRoot = path4.resolve(root);
   const isAbsoluteFs = filePath.startsWith(resolvedRoot);
   const normalizedPath = !isAbsoluteFs && filePath.startsWith("/") ? filePath.slice(1) : filePath;
-  const fullPath = path3.isAbsolute(normalizedPath) ? path3.resolve(normalizedPath) : path3.resolve(resolvedRoot, normalizedPath);
-  if (!fullPath.startsWith(resolvedRoot + path3.sep) && fullPath !== resolvedRoot) {
+  const fullPath = path4.isAbsolute(normalizedPath) ? path4.resolve(normalizedPath) : path4.resolve(resolvedRoot, normalizedPath);
+  if (!fullPath.startsWith(resolvedRoot + path4.sep) && fullPath !== resolvedRoot) {
     throw new Error(`Path traversal detected: ${filePath}`);
   }
   return fullPath;
@@ -23934,17 +24236,17 @@ function isNodeError(error) {
 async function walkFiles(absRoot, absDir) {
   let dirEntries;
   try {
-    dirEntries = await fs.readdir(absDir, { withFileTypes: true });
+    dirEntries = await fs2.readdir(absDir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const entry of dirEntries) {
-    const abs = path3.join(absDir, entry.name);
+    const abs = path4.join(absDir, entry.name);
     if (entry.isDirectory()) {
       out.push(...await walkFiles(absRoot, abs));
     } else if (entry.isFile()) {
-      out.push(path3.relative(absRoot, abs).split(path3.sep).join("/"));
+      out.push(path4.relative(absRoot, abs).split(path4.sep).join("/"));
     }
   }
   return out;
@@ -23963,35 +24265,38 @@ function staticPrefixDir(pattern) {
   return staticSegments.join("/");
 }
 function createNodeFs(root) {
-  const resolvedRoot = path3.resolve(root);
+  const resolvedRoot = path4.resolve(root);
   const resolve = (p) => resolveWithinRoot(resolvedRoot, p);
   return {
     async readFile(filePath) {
-      return fs.readFile(resolve(filePath), "utf-8");
+      return fs2.readFile(resolve(filePath), "utf-8");
+    },
+    async readBytes(filePath) {
+      return fs2.readFile(resolve(filePath));
     },
     async writeFile(filePath, content) {
       const fullPath = resolve(filePath);
-      await fs.mkdir(path3.dirname(fullPath), { recursive: true });
+      await fs2.mkdir(path4.dirname(fullPath), { recursive: true });
       const tempPath = `${fullPath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
       try {
-        await fs.writeFile(tempPath, content, "utf-8");
-        await fs.rename(tempPath, fullPath);
+        await fs2.writeFile(tempPath, content, "utf-8");
+        await fs2.rename(tempPath, fullPath);
       } catch (error) {
-        await fs.rm(tempPath, { force: true });
+        await fs2.rm(tempPath, { force: true });
         throw error;
       }
     },
     async rename(from, to) {
       const fullTo = resolve(to);
-      await fs.mkdir(path3.dirname(fullTo), { recursive: true });
-      await fs.rename(resolve(from), fullTo);
+      await fs2.mkdir(path4.dirname(fullTo), { recursive: true });
+      await fs2.rename(resolve(from), fullTo);
     },
     async remove(filePath) {
-      await fs.rm(resolve(filePath), { force: true });
+      await fs2.rm(resolve(filePath), { force: true });
     },
     async exists(filePath) {
       try {
-        await fs.access(resolve(filePath));
+        await fs2.access(resolve(filePath));
         return true;
       } catch {
         return false;
@@ -23999,7 +24304,7 @@ function createNodeFs(root) {
     },
     async list(dir) {
       try {
-        const entries = await fs.readdir(resolve(dir), { withFileTypes: true });
+        const entries = await fs2.readdir(resolve(dir), { withFileTypes: true });
         return entries.map((entry) => ({ name: entry.name, isDirectory: entry.isDirectory() }));
       } catch (error) {
         if (isNodeError(error) && error.code === "ENOENT")
@@ -24015,7 +24320,7 @@ function createNodeFs(root) {
       return files.filter((rel) => matcher.test(rel));
     },
     async stat(filePath) {
-      const s = await fs.stat(resolve(filePath));
+      const s = await fs2.stat(resolve(filePath));
       return { mtimeMs: s.mtimeMs, size: s.size };
     }
   };
@@ -24083,120 +24388,6 @@ function createContemberStorageAdapter(options) {
     }
   };
 }
-// ../cms-core/src/media/local.ts
-import { randomUUID } from "crypto";
-import fs2 from "fs/promises";
-import path4 from "path";
-function createLocalStorageAdapter(options = {}) {
-  const dir = path4.resolve(options.dir ?? "public/uploads");
-  const urlPrefix = (options.urlPrefix ?? "/uploads").replace(/\/$/, "");
-  return {
-    staticFiles: { urlPrefix, dir },
-    async list(opts) {
-      const limit = opts?.limit ?? 50;
-      const offset = opts?.cursor ? parseInt(opts.cursor, 10) : 0;
-      const folder = opts?.folder ?? "";
-      const targetDir = folder ? path4.join(dir, folder) : dir;
-      await fs2.mkdir(targetDir, { recursive: true });
-      const entries = await fs2.readdir(targetDir, { withFileTypes: true });
-      const folders = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({
-        name: e.name,
-        path: folder ? `${folder}/${e.name}` : e.name
-      })).sort((a, b) => a.name.localeCompare(b.name));
-      const files = entries.filter((e) => e.isFile() && !e.name.startsWith("."));
-      const withStats = await Promise.all(files.map(async (f) => {
-        const filePath = path4.join(targetDir, f.name);
-        const stat = await fs2.stat(filePath);
-        return { name: f.name, stat };
-      }));
-      withStats.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
-      const slice = withStats.slice(offset, offset + limit);
-      const hasMore = offset + limit < withStats.length;
-      const urlFolder = folder ? `/${folder}` : "";
-      const items = slice.map((f) => {
-        const ext = path4.extname(f.name).toLowerCase();
-        const contentType = mimeFromExt(ext);
-        return {
-          id: folder ? `${folder}/${f.name}` : f.name,
-          url: `${urlPrefix}${urlFolder}/${f.name}`,
-          filename: f.name,
-          contentType,
-          uploadedAt: f.stat.mtime.toISOString(),
-          folder: folder || undefined
-        };
-      });
-      return {
-        items,
-        folders,
-        hasMore,
-        cursor: hasMore ? String(offset + limit) : undefined
-      };
-    },
-    async upload(file, filename, contentType, uploadOpts) {
-      const folder = uploadOpts?.folder ?? "";
-      const targetDir = folder ? path4.join(dir, folder) : dir;
-      await fs2.mkdir(targetDir, { recursive: true });
-      const ext = getFileExtension(filename);
-      const uuid = randomUUID();
-      const newFilename = `${uuid}${ext ? `.${ext}` : ""}`;
-      const filePath = path4.join(targetDir, newFilename);
-      await fs2.writeFile(filePath, file);
-      const urlFolder = folder ? `/${folder}` : "";
-      const id = folder ? `${folder}/${newFilename}` : newFilename;
-      return {
-        success: true,
-        url: `${urlPrefix}${urlFolder}/${newFilename}`,
-        filename: newFilename,
-        id
-      };
-    },
-    async delete(id) {
-      const safePath = id.split("/").map((s) => path4.basename(s)).join("/");
-      const filePath = path4.join(dir, safePath);
-      try {
-        await fs2.unlink(filePath);
-        return { success: true };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { success: false, error: message };
-      }
-    },
-    async createFolder(folder) {
-      const segments = folder.split("/").filter(Boolean);
-      if (segments.some((s) => s === ".." || s === ".")) {
-        return { success: false, error: "Invalid folder name" };
-      }
-      try {
-        await fs2.mkdir(path4.join(dir, ...segments), { recursive: true });
-        return { success: true };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { success: false, error: message };
-      }
-    }
-  };
-}
-function getFileExtension(filename) {
-  const parts = filename.split(".");
-  const ext = parts.length > 1 ? parts.pop()?.toLowerCase() ?? "" : "";
-  return /^[a-z0-9]+$/.test(ext) ? ext : "";
-}
-var MIME_BY_EXT = {
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".svg": "image/svg+xml",
-  ".ico": "image/x-icon",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".pdf": "application/pdf"
-};
-function mimeFromExt(ext) {
-  return MIME_BY_EXT[ext] ?? "application/octet-stream";
-}
 // ../cms-core/src/media/project-images.ts
 var IMAGE_EXTENSIONS2 = new Set(Object.entries(MIME_BY_EXT).filter(([, mime]) => mime.startsWith("image/")).map(([ext]) => ext));
 // ../cms-core/src/media/s3.ts
@@ -24424,12 +24615,14 @@ var SIDECAR_FEATURES = [
   "entry.crud",
   "entry.rename",
   "entry.array",
+  "entry.asset",
   "entry.optimistic-concurrency",
   "pages.crud",
   "pages.list",
   "pages.layouts",
   "redirects.crud",
-  "media"
+  "media",
+  "components"
 ];
 var API_PREFIX = "/cms/v1";
 var DEFAULT_LIMIT = 50;
@@ -24591,6 +24784,10 @@ function createServer(opts) {
     const map = await core.scanCollections();
     return map[name] ?? null;
   }
+  async function scanComponentsList() {
+    const map = await core.scanComponents();
+    return Object.values(map).sort((a, b) => a.name.localeCompare(b.name));
+  }
   async function entryDetail(collection, slug) {
     const result = await core.getEntry(collection, slug);
     if (!result)
@@ -24610,6 +24807,15 @@ function createServer(opts) {
     };
     return json(entry);
   }
+  async function assetResponse(collection, slug, url) {
+    const assetPath = url.searchParams.get("path");
+    if (assetPath === null || assetPath === "")
+      return error("validation", 'A "path" query parameter is required');
+    const asset = await core.getEntryAsset(collection, slug, assetPath);
+    if (!asset)
+      return error("not_found", `Asset not found for ${collection}/${slug}: ${assetPath}`);
+    return new Response(asset.bytes, { headers: { "content-type": asset.contentType, "cache-control": "no-cache" } });
+  }
   async function patchEntry(collection, slug, body) {
     const existing = await core.getEntry(collection, slug);
     if (!existing)
@@ -24674,6 +24880,10 @@ function createServer(opts) {
           return json(model);
         }
         break;
+      case "components":
+        if (method === "GET")
+          return json(await scanComponentsList());
+        break;
       case "collections":
         return routeCollections(method, tail, req, url);
       case "pages":
@@ -24715,6 +24925,8 @@ function createServer(opts) {
         return addArrayRoute(collection, slug, req);
       if (action === "array" && method === "DELETE")
         return removeArrayRoute(collection, slug, req);
+      if (action === "asset" && method === "GET")
+        return assetResponse(collection, slug, url);
     }
     return error("not_found", `No route: ${method} /cms/v1/collections/${tail.join("/")}`);
   }