@jk2908/mdsrc 0.4.1 → 0.6.0

package/dist/index.js

@@ -21,12 +21,16 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 import { realpathSync } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { markdownToHtml } from "satteri";
+import {
+  markdownToHtml,
+  mdxToJs
+} from "satteri";
 
 // src/config.ts
 var NAME = "mdsrc";
 var PKG_NAME = `@jk2908/${NAME}`;
 var GENERATED_DIR = `.${NAME}`;
+var AUTOGEN_MSG = `// auto-generated by ${NAME}`;
 
 // src/logger.ts
 var LEVELS = {
@@ -121,6 +125,9 @@ function capitalise(str) {
 function pluralise(str, count) {
   return count === 1 ? str : str.endsWith("s") ? str : `${str}s`;
 }
+function singularise(str, suffix = "s") {
+  return str.endsWith(suffix) ? str.slice(0, -suffix.length) : str;
+}
 function debounce(fn, wait) {
   let timeoutId = null;
   return (...args) => {
@@ -132,11 +139,6 @@ function debounce(fn, wait) {
     }, wait);
   };
 }
-function dedent(str) {
-  return str.replace(/^\n/, "").replace(/\s+$/, "").split(`
-`).filter(Boolean).map((line) => line.replace(/^\s+/, "")).join(`
-`);
-}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -150,129 +152,155 @@ function deep(obj, path, value) {
   }
   cur[parts.at(-1)] = value;
 }
-
-// src/index.ts
-var fileCache = new Map;
-var DEFAULT_COMPILE_OPTIONS = {
-  features: {
-    frontmatter: true
-  }
-};
-async function parse(frontmatter) {
-  if (!frontmatter)
-    return {};
-  const { kind, value } = frontmatter;
-  switch (kind) {
-    case "yaml": {
-      return (await import("yaml")).parse(value);
-    }
-    case "toml": {
-      return (await import("smol-toml")).parse(value);
-    }
-  }
-}
-async function create(dir, buildContext) {
-  const { logger: logger2, compileOptions = {} } = buildContext;
-  const { features, ...restCompileOptions } = compileOptions;
-  try {
-    const files = (await fs.readdir(dir)).filter((file) => path.extname(file) === ".md");
-    const filePaths = files.map((file) => path.join(dir, file));
-    if (!files.length) {
-      console.warn(`mdsrc: ${dir} is empty`);
-      return [];
-    }
-    return Promise.all(filePaths.map(async (filePath) => {
-      const file = path.basename(filePath);
-      const { html, frontmatter: rawFrontmatter } = markdownToHtml(await fs.readFile(filePath, "utf-8"), {
-        features: {
-          ...DEFAULT_COMPILE_OPTIONS.features,
-          ...features
-        },
-        ...restCompileOptions
-      });
-      const frontmatter = await parse(rawFrontmatter);
-      return {
-        ...frontmatter,
-        __mdsrc: {
-          slug: path.basename(file, ".md").toLowerCase().replace(/\s+/g, "-"),
-          filename: file
-        },
-        body: html.trim()
-      };
-    }));
-  } catch (err) {
-    logger2.error("[create]: failed to create entries", err);
-    return [];
-  }
-}
-async function maybeWrite(filePath, content) {
-  const cached = fileCache.get(filePath);
-  if (cached === content) {
-    try {
-      await fs.access(filePath);
-      return false;
-    } catch (err) {
-      if (!(err instanceof Error) || !("code" in err) || err.code !== "ENOENT") {
-        throw err;
-      }
-    }
-  }
-  if (cached === undefined) {
-    try {
-      const current = await fs.readFile(filePath, "utf-8");
-      fileCache.set(filePath, current);
-      if (current === content) {
-        fileCache.set(filePath, content);
-        return false;
-      }
-    } catch (err) {
-      if (!(err instanceof Error) || !("code" in err) || err.code !== "ENOENT") {
-        throw err;
-      }
-    }
-  }
-  await fs.writeFile(filePath, content);
-  fileCache.set(filePath, content);
-  return true;
+function slugify(str) {
+  return str.toLowerCase().replace(/\s/g, "-");
 }
+
+// src/types.ts
+var PRIMITIVE_NAMES = ["string", "number", "boolean", "date", "array"];
+var MODIFIER_NAMES = ["max", "min"];
+
+// src/validate.ts
 function validate(input, schema) {
   const validated = {};
   const issues = [];
   if (typeof input !== "object" || input === null) {
-    issues.push({ message: "Input must be an object" });
+    issues.push({ message: "Input must be an object", code: "INVALID_INPUT" });
     return { issues };
   }
+  const schemaKeys = new Set(Object.keys(schema).map((k) => parseKey(k).key));
+  for (const key in input) {
+    if (!schemaKeys.has(key)) {
+      issues.push({ message: `Unknown key: ${key}`, code: "UNKNOWN_KEY" });
+    }
+  }
+  if (issues.length)
+    return { issues };
   function walk(key, schemaValue, data) {
     const { optional, key: parsedKey } = parseKey(key);
     if (data === undefined) {
       if (!optional) {
-        issues.push({ message: `Missing required key: ${parsedKey}` });
+        issues.push({
+          message: `Missing required key: ${parsedKey}`,
+          code: "MISSING_REQUIRED"
+        });
       }
       return;
     }
     if (typeof schemaValue === "string") {
-      switch (schemaValue) {
-        case "string": {
+      const { types, modifiers } = parseSchemaValue(schemaValue);
+      for (const type of types) {
+        if (type === "string") {
           if (typeof data !== "string") {
-            issues.push({ message: `Key ${parsedKey} must be a string` });
-            return;
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be a string`,
+                code: "INVALID_TYPE"
+              });
+              return;
+            }
+            continue;
+          }
+          if (modifiers.min) {
+            const min = Number(modifiers.min);
+            if (Number.isNaN(min)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.min}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (data.length < min) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be greater than or equal to minimum length (${min})`,
+                  code: "INVALID_LENGTH"
+                });
+                return;
+              }
+              continue;
+            }
+          }
+          if (modifiers.max) {
+            const max = Number(modifiers.max);
+            if (Number.isNaN(max)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.max}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (data.length > max) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be less than or equal to maximum length (${max})`,
+                  code: "INVALID_LENGTH"
+                });
+                return;
+              }
+              continue;
+            }
           }
           deep(validated, parsedKey, data);
-          break;
-        }
-        case "number": {
+          return;
+        } else if (type === "number") {
           let num = data;
           if (typeof data === "string" && !Number.isNaN(Number(data))) {
             num = Number(data);
           }
           if (typeof num !== "number" || Number.isNaN(num)) {
-            issues.push({ message: `Key ${parsedKey} must be a number` });
-            return;
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be a number`,
+                code: "INVALID_TYPE"
+              });
+              return;
+            }
+            continue;
+          }
+          if (modifiers.min) {
+            const min = Number(modifiers.min);
+            if (Number.isNaN(min)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.min}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (num < min) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be greater than or equal to minimum size (${min})`,
+                  code: "INVALID_SIZE"
+                });
+                return;
+              }
+              continue;
+            }
+          }
+          if (modifiers.max) {
+            const max = Number(modifiers.max);
+            if (Number.isNaN(max)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.max}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (num > max) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be less than or equal to maximum size (${max})`,
+                  code: "INVALID_SIZE"
+                });
+                return;
+              }
+              continue;
+            }
           }
           deep(validated, parsedKey, num);
-          break;
-        }
-        case "boolean": {
+          return;
+        } else if (type === "boolean") {
           let bool = data;
           if (typeof data === "string") {
             if (data.toLowerCase() === "true") {
@@ -282,29 +310,151 @@ function validate(input, schema) {
             }
           }
           if (typeof bool !== "boolean") {
-            issues.push({ message: `Key ${parsedKey} must be a boolean` });
-            return;
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be a boolean`,
+                code: "INVALID_TYPE"
+              });
+              return;
+            }
+            continue;
           }
           deep(validated, parsedKey, bool);
-          break;
-        }
-        case "date": {
-          if (typeof data !== "string") {
-            issues.push({ message: `Key ${parsedKey} must be a date` });
-            return;
+          return;
+        } else if (type === "date") {
+          let date;
+          if (data instanceof Date) {
+            date = data;
+          } else if (typeof data === "string" || typeof data === "number") {
+            date = new Date(data);
+          } else {
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be a Date, string or number`,
+                code: "INVALID_TYPE"
+              });
+              return;
+            }
+            continue;
+          }
+          const dt = date.getTime();
+          if (Number.isNaN(dt)) {
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be a valid date`,
+                code: "INVALID_DATE"
+              });
+              return;
+            }
+            continue;
+          }
+          if (modifiers.min) {
+            const min = new Date(Number(modifiers.min));
+            if (Number.isNaN(min.getTime())) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.min}) that could not be converted to instance (Date)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (dt < min.getTime()) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be greater than or equal to minimum date (${min.toISOString()})`,
+                  code: "INVALID_DATE"
+                });
+                return;
+              }
+              continue;
+            }
           }
-          const date = new Date(data);
-          if (Number.isNaN(date.getTime())) {
-            issues.push({ message: `Key ${parsedKey} must be a valid date` });
-            return;
+          if (modifiers.max) {
+            const max = new Date(Number(modifiers.max));
+            if (Number.isNaN(max.getTime())) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.max}) that could not be converted to instance (Date)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (dt > max.getTime()) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be less than or equal to maximum date (${max.toISOString()})`,
+                  code: "INVALID_DATE"
+                });
+                return;
+              }
+              continue;
+            }
           }
           deep(validated, parsedKey, date.toISOString());
-          break;
+          return;
+        } else if (type === "array") {
+          if (!Array.isArray(data)) {
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be an array`,
+                code: "INVALID_TYPE"
+              });
+              return;
+            }
+            continue;
+          }
+          if (modifiers.min) {
+            const min = Number(modifiers.min);
+            if (Number.isNaN(min)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.min}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (data.length < min) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be greater than or equal to minimum array length (${min})`,
+                  code: "INVALID_LENGTH"
+                });
+                return;
+              }
+              continue;
+            }
+          }
+          if (modifiers.max) {
+            const max = Number(modifiers.max);
+            if (Number.isNaN(max)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.max}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (data.length > max) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be less than or equal to maximum array length (${max})`,
+                  code: "INVALID_LENGTH"
+                });
+                return;
+              }
+              continue;
+            }
+          }
+          deep(validated, parsedKey, data);
+          return;
         }
       }
+      issues.push({
+        message: `Key ${parsedKey} must be one of: ${types.join(", ")}`,
+        code: "INVALID_TYPE"
+      });
     } else {
       if (!isRecord(data)) {
-        issues.push({ message: `Key ${parsedKey} must be an object` });
+        issues.push({
+          message: `Key ${parsedKey} must be an object`,
+          code: "INVALID_TYPE"
+        });
         return;
       }
       const obj = data;
@@ -325,92 +475,293 @@ function parseKey(k) {
     key: optional ? k.slice(0, -1) : k
   };
 }
-function schemaValueToType(schema) {
+function parseSchemaValue(value) {
+  if (isRecord(value))
+    throw new Error("Cannot parse object schema values");
+  const parts = value.split("|");
+  const types = [];
+  const modifiers = {};
+  for (const p of parts) {
+    if (p.indexOf("=") > -1) {
+      const [m, v] = p.split("=");
+      if (!isModifierName(m))
+        throw new Error(`Unrecognised modifier: ${m}`);
+      modifiers[m] = v;
+    } else {
+      if (!isPrimitive(p))
+        throw new Error(`Unrecognised type: ${p}`);
+      types.push(p);
+    }
+  }
+  return { types, modifiers };
+}
+function isModifierName(name) {
+  return MODIFIER_NAMES.some((n) => n === name);
+}
+function isPrimitive(name) {
+  return PRIMITIVE_NAMES.some((n) => n === name);
+}
+
+// src/index.ts
+var DEFAULT_COMPILE_OPTIONS = {
+  features: {
+    frontmatter: true
+  }
+};
+var ACCEPTED_EXTENSIONS = ["md", "mdx"];
+async function parse(frontmatter) {
+  if (!frontmatter)
+    return {};
+  const { kind, value } = frontmatter;
+  switch (kind) {
+    case "yaml": {
+      return (await import("yaml")).parse(value);
+    }
+    case "toml": {
+      return (await import("smol-toml")).parse(value);
+    }
+  }
+}
+async function create(dir, buildContext) {
+  const { logger: logger2, compileOptions = {} } = buildContext;
+  const { features, ...restCompileOptions } = compileOptions;
+  try {
+    const files = (await fs.readdir(dir)).filter((file) => ACCEPTED_EXTENSIONS.some((e) => `.${e}` === path.extname(file)));
+    const filePaths = files.map((file) => path.join(dir, file));
+    if (!files.length) {
+      logger2.warn(`mdsrc: ${dir} is empty`);
+      return [];
+    }
+    const parserArgs = {
+      features: {
+        ...DEFAULT_COMPILE_OPTIONS.features,
+        ...features
+      },
+      ...restCompileOptions
+    };
+    return Promise.all(filePaths.map(async (filePath) => {
+      const file = path.basename(filePath);
+      const ext = path.extname(filePath);
+      const md = ext === ".md";
+      const content = await fs.readFile(filePath, "utf-8");
+      let res = ext === ".md" ? markdownToHtml(content, parserArgs) : mdxToJs(content, parserArgs);
+      if (res instanceof Promise)
+        res = await res;
+      const frontmatter = await parse(res.frontmatter);
+      const body = "html" in res ? res.html : res.code;
+      const slug = slugify(path.basename(file, md ? ".md" : ".mdx"));
+      return md ? {
+        ...frontmatter,
+        __mdsrc: { slug, filename: file, type: "md" },
+        html: body.trim()
+      } : {
+        ...frontmatter,
+        __mdsrc: { slug, filename: file, type: "mdx" },
+        code: body.trim()
+      };
+    }));
+  } catch (err) {
+    logger2.error("[create]: failed to create entries", err);
+    throw err;
+  }
+}
+function isENOENT(err) {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+var fileCache = new Map;
+var FILE_CACHE_MAX_SIZE = 100;
+function setFileCache(filePath, content) {
+  fileCache.delete(filePath);
+  if (fileCache.size >= FILE_CACHE_MAX_SIZE) {
+    const lru = fileCache.keys().next().value;
+    if (lru !== undefined) {
+      fileCache.delete(lru);
+    }
+  }
+  fileCache.set(filePath, content);
+}
+function getFileCache(filePath) {
+  const content = fileCache.get(filePath);
+  if (content !== undefined) {
+    setFileCache(filePath, content);
+  }
+  return content;
+}
+async function maybeWrite(filePath, content) {
+  const cached = getFileCache(filePath);
+  if (cached !== content) {
+    await fs.writeFile(filePath, content);
+    setFileCache(filePath, content);
+    return true;
+  }
+  try {
+    if (await fs.readFile(filePath, "utf-8") === content) {
+      setFileCache(filePath, content);
+      return false;
+    }
+  } catch (err) {
+    if (!isENOENT(err))
+      throw err;
+  }
+  await fs.writeFile(filePath, content);
+  setFileCache(filePath, content);
+  return true;
+}
+function schemaToType(schema) {
   const fields = Object.entries(schema).map(([k, v]) => {
     const { key, optional } = parseKey(k);
     let type;
     if (typeof v === "string") {
-      type = v === "date" ? "string" : v;
+      type = v === "date" ? "string" : v === "array" ? "any[]" : v;
     } else {
-      type = schemaValueToType(v);
+      type = schemaToType(v);
     }
     return `${key}${optional ? "?" : ""}: ${type}`;
   }).join(`
   `);
   return `{ ${fields} }`;
 }
+async function getManifest(outDir) {
+  return fs.readFile(path.join(outDir, "manifest.json"), "utf-8").then(JSON.parse).then((manifest) => {
+    if (!isRecord(manifest))
+      return null;
+    const entries = Object.entries(manifest).filter((entry) => typeof entry[0] === "string" && Array.isArray(entry[1]) && entry[1].every((value) => typeof value === "string"));
+    return Object.fromEntries(entries);
+  }).catch(() => null);
+}
+async function cleanup(outDir, manifest, prevManifest) {
+  if (!prevManifest)
+    return false;
+  const files = new Set(Object.values(manifest).flat());
+  const prevFiles = Object.values(prevManifest).flat();
+  const staleDirs = new Set;
+  let cleaned = false;
+  for (const filePath of prevFiles) {
+    if (files.has(filePath))
+      continue;
+    await fs.rm(filePath, { force: true });
+    fileCache.delete(filePath);
+    staleDirs.add(path.dirname(filePath));
+    cleaned = true;
+  }
+  for (const dir of [...staleDirs].toSorted((a, b) => b.length - a.length)) {
+    if (dir === outDir)
+      continue;
+    try {
+      if ((await fs.readdir(dir)).length)
+        continue;
+    } catch (err) {
+      if (!isENOENT(err))
+        throw err;
+      continue;
+    }
+    await fs.rm(dir, { recursive: true, force: true });
+    cleaned = true;
+  }
+  return cleaned;
+}
 async function build(src, buildContext) {
   const { logger: logger2, outDir } = buildContext;
   let names = [];
   const collections = {};
+  const manifest = {};
   try {
     if (!outDir)
       throw new Error("Output directory is not defined");
     await fs.mkdir(outDir, { recursive: true });
+    const prevManifest = await getManifest(outDir);
     for (const collection of src) {
       const raw = await create(path.join(process.cwd(), collection.dir), buildContext);
-      const validated = await Promise.all(raw.map(async (item) => {
-        try {
-          const { body, __mdsrc, ...metadata } = item;
-          const res = validate(metadata, collection.schema);
-          if (res.issues)
-            throw new Error(JSON.stringify(res.issues, null, 2));
-          return {
-            ...res.value,
-            body,
-            __mdsrc
-          };
-        } catch (err) {
-          logger2.error(`[buildStart]: failed to validate item in ${collection.name}`, err);
-          return null;
-        }
-      }));
+      const validated = raw.map((item) => {
+        const { html, code, __mdsrc, ...metadata } = item;
+        const res = validate(metadata, collection.schema);
+        if (res.issues)
+          throw new Error(JSON.stringify(res.issues, null, 2));
+        return __mdsrc.type === "md" ? { ...res.value, __mdsrc, html } : { ...res.value, __mdsrc, code };
+      });
       collections[collection.name] = {
-        items: validated.filter((e) => e !== null),
+        items: validated,
         schema: collection.schema
       };
+      manifest[collection.name] = [];
     }
     names = Object.keys(collections);
     const promises = [];
-    promises.push(maybeWrite(path.join(outDir, "types.ts"), `
+    promises.push(maybeWrite(path.join(outDir, "types.ts"), ` ${AUTOGEN_MSG}
+
+					import type { Collection } from '${PKG_NAME}'
+				
 					${names.map((name) => `
-								export type ${capitalise(name)} = ${schemaValueToType(collections[name].schema)} & {
-									body: string,
-									__mdsrc: {
-										slug: string
-										filename: string
-									},
-								}
+								export type ${capitalise(singularise(name))} = ${schemaToType(collections[name].schema)} & {
+									html?: string,
+									Component?: any,
+								} & Collection.Metadata
 							`).join(`
 
 `)}`.trim()));
-    promises.push(maybeWrite(path.join(outDir, "index.d.ts"), `	
-					import type { ${names.map((name) => capitalise(name)).join(", ")} } from './types.js'
+    promises.push(maybeWrite(path.join(outDir, "index.d.ts"), `	${AUTOGEN_MSG}
+
+					import type { ${names.map((name) => capitalise(singularise(name))).join(", ")} } from './types.js'
 
 					${names.map((name) => `
-								export const all${capitalise(pluralise(name, 2))}: ${capitalise(name)}[]
+								export const all${capitalise(pluralise(name, 2))}: ${capitalise(singularise(name))}[]
 							`).join(`
 
 `)}
 
 					declare module '${PKG_NAME}' {
 						${names.map((name) => `
-									export const all${capitalise(pluralise(name, 2))}: ${capitalise(name)}[]
+									export const all${capitalise(pluralise(name, 2))}: ${capitalise(singularise(name))}[]
 								`).join(`
 
 `)}
 					}
 				`.trim()));
     for (const name of names) {
-      const collection = collections[name]?.items;
+      const collection = collections[name]?.items ?? [];
       const fileName = toModuleName(name);
-      promises.push(maybeWrite(path.join(outDir, `${fileName}.js`), `export const all${capitalise(pluralise(name, 2))} = ${collection?.length ? JSON.stringify(collection) : "[]"}`.trim()));
+      const filePath = `${fileName}.js`;
+      const imports = [];
+      const entries = [];
+      if (collection.some(isMdx)) {
+        await fs.mkdir(path.join(outDir, fileName), { recursive: true });
+      }
+      for (let i = 0;i < collection.length; i++) {
+        const item = collection[i];
+        if (isMdx(item)) {
+          const slug = item.__mdsrc.slug;
+          const fullPath2 = path.join(outDir, fileName, `${slug}.js`);
+          manifest[name].push(fullPath2);
+          promises.push(maybeWrite(fullPath2, item.code));
+          const importName = `C${i}`;
+          imports.push(`import ${importName} from './${fileName}/${slug}.js'`);
+          const { code, ...rest } = item;
+          entries.push(`{ ...${JSON.stringify(rest)}, Component: ${importName} }`);
+        } else {
+          entries.push(JSON.stringify(item));
+        }
+      }
+      const fullPath = path.join(outDir, filePath);
+      manifest[name].push(fullPath);
+      promises.push(maybeWrite(fullPath, `	${AUTOGEN_MSG}
+		
+						${imports.join(`
+`)}
+
+						export const all${capitalise(pluralise(name, 2))} = [${entries.join(`,
+`)}]`.trim()));
     }
-    promises.push(maybeWrite(path.join(outDir, "index.js"), names.map((name) => `export * from './${toModuleName(name)}.js'`).join(`
-`)));
+    promises.push(maybeWrite(path.join(outDir, "index.js"), `${AUTOGEN_MSG}
+				
+					${names.map((name) => `
+								export * from './${toModuleName(name)}.js'
+							`).join(`
+`)}`));
+    promises.push(maybeWrite(path.join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2)));
     const writes = await Promise.all(promises);
+    const cleaned = await cleanup(outDir, manifest, prevManifest);
     buildContext.names = names;
-    return writes.some((changed) => changed);
+    return writes.some((c) => c) || cleaned;
   } catch (err) {
     logger2.error("[build]: failed to generate data", err);
     throw err;
@@ -506,15 +857,13 @@ function mdsrc(config) {
       server.watcher.on("add", (p) => rebuild("add", p)).on("change", (p) => rebuild("change", p)).on("unlink", (p) => rebuild("unlink", p));
     },
     resolveId(id) {
-      if (id === PKG_NAME) {
+      if (id === PKG_NAME)
         return path.join(outDir, "index.js");
-      }
       if (id.startsWith(`${PKG_NAME}/`)) {
         const subpath = id.slice(PKG_NAME.length + 1);
         const match = buildContext.names.find((name) => name === subpath || toModuleName(name) === subpath);
-        if (match) {
+        if (match)
           return path.join(outDir, `${toModuleName(match)}.js`);
-        }
       }
       return null;
     }
@@ -523,42 +872,24 @@ function mdsrc(config) {
 function toModuleName(name) {
   return name.toLowerCase();
 }
-if (import.meta.vitest) {
-  const { it, expect, describe } = import.meta.vitest;
-  const now = Date.now();
-  const yaml = {
-    kind: "yaml",
-    value: dedent(`
-			title: mdsrc
-			date: ${now}
-		`)
-  };
-  const toml = {
-    kind: "toml",
-    value: dedent(`
-			title = "mdsrc"
-			date = ${now}
-		`)
-  };
-  describe("markdown parsing", () => {
-    it("parses frontmatter", async () => {
-      for (const f of [yaml, toml]) {
-        const frontmatter = await parse(f);
-        expect(frontmatter).toEqual({
-          title: "mdsrc",
-          date: now
-        });
-      }
-    });
-    it("returns empty object for missing frontmatter", async () => {
-      const frontmatter = await parse(null);
-      expect(frontmatter).toEqual({});
-    });
-  });
+function isMdx(item) {
+  return item.__mdsrc.type === "mdx";
 }
 export {
+  toModuleName,
+  setFileCache,
+  schemaToType,
+  parse,
+  maybeWrite,
+  isENOENT,
+  getManifest,
+  getFileCache,
+  fileCache,
   mdsrc as default,
-  create
+  create,
+  cleanup,
+  FILE_CACHE_MAX_SIZE,
+  DEFAULT_COMPILE_OPTIONS
 };
 
-//# debugId=0F1D108961D2552964756E2164756E21
+//# debugId=708A8C4A969C717264756E2164756E21