@zeropress/build-pages 0.5.6 → 0.6.2

package/dist/prebuild.js

@@ -3524,6 +3524,7 @@ import { fileURLToPath } from "node:url";
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
 var rootDir = process.cwd();
 var sourceDir = resolveEnvPath(["ZEROPRESS_BUILD_PAGES_SOURCE"], "docs");
+var publicDir = resolveEnvPath(["ZEROPRESS_BUILD_PAGES_PUBLIC_DIR"], sourceDir);
 var defaultConfigPath = path.join(sourceDir, ".zeropress", "config.json");
 var configPath = resolveOptionalEnvPath(["ZEROPRESS_BUILD_PAGES_CONFIG"], defaultConfigPath);
 var outDir = path.join(rootDir, ".zeropress");
@@ -3534,7 +3535,13 @@ var skipUntitledMarkdown = readBooleanEnv("ZEROPRESS_SKIP_UNTITLED_MARKDOWN");
 var copyMarkdownSource = readBooleanEnv("ZEROPRESS_COPY_MARKDOWN_SOURCE", true);
 var FRONT_PAGE_TYPES = /* @__PURE__ */ new Set(["theme_index", "markdown", "html"]);
 var BUILD_PAGES_CONFIG_SCHEMA_URL = "https://zeropress.dev/schemas/zeropress-build-pages.config.v0.1.schema.json";
-var PREVIEW_DATA_SCHEMA_URL = "https://zeropress.dev/schemas/preview-data.v0.5.schema.json";
+var PREVIEW_DATA_SCHEMA_URL = "https://zeropress.dev/schemas/preview-data.v0.6.schema.json";
+var FRONT_MATTER_DATA_KEY_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*(?:-[a-zA-Z0-9_]+)*$/;
+var FRONT_MATTER_DATA_MAX_DEPTH = 4;
+var FRONT_MATTER_DATA_MAX_KEYS = 64;
+var FRONT_MATTER_DATA_MAX_ARRAY_LENGTH = 256;
+var FRONT_MATTER_DISCOVERABILITY_VALUES = /* @__PURE__ */ new Set(["default", "noindex", "delist"]);
+var markdownDiscoverExcludeRoots = buildMarkdownDiscoverExcludeRoots();
 var PrebuildMarkdownError = class extends Error {
   constructor(sourcePath, reason, expected = "", code = "invalid_markdown") {
     super(reason);
@@ -3608,6 +3615,8 @@ async function main() {
       ...frontMatter.meta,
       ...copyMarkdownSource ? { source_markdown_url: buildSourceMarkdownUrl(sourcePath) } : {}
     },
+    ...frontMatter.data !== void 0 ? { data: frontMatter.data } : {},
+    ...frontMatter.discoverability !== "default" ? { discoverability: frontMatter.discoverability } : {},
     content: rewriteMarkdownLinks(bodyMarkdown, sourcePath, routeBySourcePath),
     document_type: "markdown",
     excerpt: frontMatter.description || extractExcerpt(bodyMarkdown, title),
@@ -3621,7 +3630,7 @@ async function main() {
   const customHtml = await buildCustomHtmlData(customHtmlConfig);
   const previewData = {
     $schema: PREVIEW_DATA_SCHEMA_URL,
-    version: "0.5",
+    version: "0.6",
     generator: "zeropress-build-pages",
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     site,
@@ -3719,18 +3728,21 @@ function buildSiteData(config, frontPage) {
     title: configuredSite.title,
     description: configuredSite.description,
     url: configuredSite.url,
-    mediaBaseUrl: "",
+    media_base_url: "",
     locale: "en-US",
-    postsPerPage: 10,
-    dateFormat: "YYYY-MM-DD",
-    timeFormat: "HH:mm",
+    posts_per_page: 10,
+    datetime_display: "static",
+    date_style: "medium",
+    time_style: "none",
     timezone: "UTC",
     permalinks: defaultPermalinks(),
     front_page: frontPage,
     post_index: {
       enabled: false
     },
-    disallowComments: true,
+    disallow_comments: true,
+    expose_generator: configuredSite.expose_generator !== false,
+    search: configuredSite.search !== false,
     indexing: configuredSite.indexing !== false
   };
   if (configuredSite.footer) {
@@ -3759,11 +3771,13 @@ function normalizeSiteConfig(value) {
     );
   }
   const configuredSite = isPlainObject(value) ? value : {};
-  assertKnownConfigKeys(configuredSite, ["title", "description", "url", "indexing", "footer"], "site");
+  assertKnownConfigKeys(configuredSite, ["title", "description", "url", "expose_generator", "search", "indexing", "footer"], "site");
   const site = {
     title: readConfigString(configuredSite.title, "Documentation"),
     description: readConfigString(configuredSite.description, "A documentation site."),
     url: readEnv("ZEROPRESS_SITE_URL", readConfigString(configuredSite.url, "")),
+    expose_generator: readConfigBoolean(configuredSite.expose_generator, true, "site.expose_generator"),
+    search: readConfigBoolean(configuredSite.search, true, "site.search"),
     indexing: readConfigBoolean(configuredSite.indexing, true, "site.indexing")
   };
   const footer = normalizeFooter(configuredSite.footer);
@@ -3785,19 +3799,11 @@ function normalizeFooter(value) {
   if (copyrightText) {
     footer.copyright_text = copyrightText;
   }
-  if (value.attribution !== void 0 && !isPlainObject(value.attribution)) {
-    throw new PrebuildConfigError("site.footer.attribution must be an object.");
-  }
-  if (isPlainObject(value.attribution)) {
-    assertKnownConfigKeys(value.attribution, ["enabled"], "site.footer.attribution");
-    if (value.attribution.enabled !== void 0 && typeof value.attribution.enabled !== "boolean") {
-      throw new PrebuildConfigError("site.footer.attribution.enabled must be a boolean when provided.");
+  if (value.attribution !== void 0) {
+    if (typeof value.attribution !== "boolean") {
+      throw new PrebuildConfigError("site.footer.attribution must be a boolean when provided.");
     }
-  }
-  if (isPlainObject(value.attribution) && typeof value.attribution.enabled === "boolean") {
-    footer.attribution = {
-      enabled: value.attribution.enabled
-    };
+    footer.attribution = value.attribution;
   }
   return Object.keys(footer).length ? footer : void 0;
 }
@@ -4143,9 +4149,23 @@ function normalizeMenuItem(item, pathLabel) {
     url,
     type: readConfigString(item.type, "custom"),
     target: readConfigString(item.target, "_self"),
+    ...item.meta !== void 0 ? { meta: normalizeMenuItemMeta(item.meta, `${pathLabel}.meta`) } : {},
     children: Array.isArray(item.children) ? item.children.map((child, index) => normalizeMenuItem(child, `${pathLabel}.children[${index}]`)) : []
   };
 }
+function normalizeMenuItemMeta(value, pathLabel) {
+  if (!isPlainObject(value)) {
+    throw new PrebuildConfigError(`${pathLabel} must be an object when provided.`);
+  }
+  const meta = {};
+  for (const [key, metaValue] of Object.entries(value)) {
+    if (!isPreviewMetaValue(metaValue)) {
+      throw new PrebuildConfigError(`${pathLabel}.${key} must be a string, number, boolean, or null.`);
+    }
+    meta[key] = metaValue;
+  }
+  return meta;
+}
 function defaultMenus() {
   return {
     primary: {
@@ -4168,6 +4188,7 @@ function buildPrebuildReport({
   return {
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     source_dir: formatSourcePath(sourceDir),
+    public_dir: formatSourcePath(publicDir),
     config_path: formatSourcePath(configPath),
     build_pages_config_path: formatSourcePath(buildPagesConfigPath),
     preview_data_path: formatSourcePath(previewDataPath),
@@ -4193,7 +4214,8 @@ function buildPrebuildReport({
 function printPrebuildSummary(report) {
   const lines = [
     "ZeroPress build report",
-    `- Public root: ${report.source_dir}`,
+    `- Source root: ${report.source_dir}`,
+    `- Public root: ${report.public_dir}`,
     `- Markdown discovered: ${report.markdown.discovered}`,
     `- Markdown pages generated: ${report.markdown.generated_pages}`,
     `- Markdown skipped: ${report.markdown.skipped}`,
@@ -4262,7 +4284,9 @@ function normalizePublishedFrontMatter(frontMatter, sourcePath) {
     title: normalizeFrontMatterTitle(frontMatter.title, sourcePath),
     description: normalizeFrontMatterDescription(frontMatter.description, sourcePath),
     path: normalizeFrontMatterRoutePath(frontMatter.path, sourcePath),
-    meta: normalizeFrontMatterMeta(frontMatter.meta, sourcePath)
+    discoverability: normalizeFrontMatterDiscoverability(frontMatter.discoverability, sourcePath),
+    meta: normalizeFrontMatterMeta(frontMatter.meta, sourcePath),
+    data: normalizeFrontMatterData(frontMatter.data, sourcePath)
   };
 }
 function normalizeFrontMatterTitle(value, sourcePath) {
@@ -4305,11 +4329,24 @@ function normalizeFrontMatterRoutePath(value, sourcePath) {
     throw new PrebuildMarkdownError(
       sourcePath,
       "front matter path must be a safe generated route path.",
-      "  path: guides/install\n  path: spec/preview-data-v0.5"
+      "  path: guides/install\n  path: spec/preview-data-v0.6"
     );
   }
   return routePath;
 }
+function normalizeFrontMatterDiscoverability(value, sourcePath) {
+  if (value === void 0) {
+    return "default";
+  }
+  if (typeof value === "string" && FRONT_MATTER_DISCOVERABILITY_VALUES.has(value)) {
+    return value;
+  }
+  throw new PrebuildMarkdownError(
+    sourcePath,
+    `front matter discoverability must be one of: ${Array.from(FRONT_MATTER_DISCOVERABILITY_VALUES).join(", ")}.`,
+    "  discoverability: default\n  discoverability: noindex\n  discoverability: delist"
+  );
+}
 function isSafeRoutePathSegment(segment) {
   return /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/.test(segment) && !segment.includes("..");
 }
@@ -4336,7 +4373,88 @@ function normalizeFrontMatterMeta(value, sourcePath) {
   return meta;
 }
 function isPreviewMetaValue(value) {
-  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value) || typeof value === "boolean";
+}
+function normalizeFrontMatterData(value, sourcePath) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isPlainObject(value)) {
+    throw new PrebuildMarkdownError(
+      sourcePath,
+      "front matter data must be an object when provided."
+    );
+  }
+  validateFrontMatterDataObject(value, sourcePath, "data", 0);
+  return value;
+}
+function validateFrontMatterDataValue(value, sourcePath, pathLabel, depth) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new PrebuildMarkdownError(
+        sourcePath,
+        `front matter ${pathLabel} must be a finite number.`
+      );
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    validateFrontMatterDataArray(value, sourcePath, pathLabel, depth);
+    return;
+  }
+  if (isPlainObject(value)) {
+    validateFrontMatterDataObject(value, sourcePath, pathLabel, depth);
+    return;
+  }
+  throw new PrebuildMarkdownError(
+    sourcePath,
+    `front matter ${pathLabel} must be JSON-safe structured data.`
+  );
+}
+function validateFrontMatterDataObject(object, sourcePath, pathLabel, depth) {
+  if (depth > FRONT_MATTER_DATA_MAX_DEPTH) {
+    throw new PrebuildMarkdownError(
+      sourcePath,
+      `front matter ${pathLabel} nesting must not exceed ${FRONT_MATTER_DATA_MAX_DEPTH} container levels.`
+    );
+  }
+  const entries = Object.entries(object);
+  if (entries.length > FRONT_MATTER_DATA_MAX_KEYS) {
+    throw new PrebuildMarkdownError(
+      sourcePath,
+      `front matter ${pathLabel} must not contain more than ${FRONT_MATTER_DATA_MAX_KEYS} keys.`
+    );
+  }
+  for (const [key, dataValue] of entries) {
+    const childLabel = `${pathLabel}.${key}`;
+    if (!FRONT_MATTER_DATA_KEY_PATTERN.test(key)) {
+      throw new PrebuildMarkdownError(
+        sourcePath,
+        `front matter ${childLabel} uses an invalid key.`
+      );
+    }
+    validateFrontMatterDataValue(dataValue, sourcePath, childLabel, depth + 1);
+  }
+}
+function validateFrontMatterDataArray(array, sourcePath, pathLabel, depth) {
+  if (depth > FRONT_MATTER_DATA_MAX_DEPTH) {
+    throw new PrebuildMarkdownError(
+      sourcePath,
+      `front matter ${pathLabel} nesting must not exceed ${FRONT_MATTER_DATA_MAX_DEPTH} container levels.`
+    );
+  }
+  if (array.length > FRONT_MATTER_DATA_MAX_ARRAY_LENGTH) {
+    throw new PrebuildMarkdownError(
+      sourcePath,
+      `front matter ${pathLabel} must not contain more than ${FRONT_MATTER_DATA_MAX_ARRAY_LENGTH} items.`
+    );
+  }
+  array.forEach((dataValue, index) => {
+    validateFrontMatterDataValue(dataValue, sourcePath, `${pathLabel}[${index}]`, depth + 1);
+  });
 }
 function formatFrontMatterValue(value) {
   if (typeof value === "string") {
@@ -4385,6 +4503,9 @@ async function listMarkdownFiles(dir) {
       continue;
     }
     const entryPath = path.join(dir, entry.name);
+    if (isMarkdownDiscoverExcluded(entryPath)) {
+      continue;
+    }
     if (entry.isDirectory()) {
       files.push(...await listMarkdownFiles(entryPath));
       continue;
@@ -4395,6 +4516,18 @@ async function listMarkdownFiles(dir) {
   }
   return files.sort((left, right) => left.localeCompare(right));
 }
+function buildMarkdownDiscoverExcludeRoots() {
+  if (samePath(sourceDir, publicDir) || !isPathInside(sourceDir, publicDir)) {
+    return [];
+  }
+  return [publicDir];
+}
+function isMarkdownDiscoverExcluded(entryPath) {
+  return markdownDiscoverExcludeRoots.some((excludeRoot) => samePath(entryPath, excludeRoot) || isPathInside(excludeRoot, entryPath));
+}
+function samePath(firstPath, secondPath) {
+  return path.resolve(firstPath) === path.resolve(secondPath);
+}
 function shouldIgnoreMarkdownDiscoverEntry(name) {
   const basename = String(name || "");
   const lowerName = basename.toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeropress/build-pages",
-  "version": "0.5.6",
+  "version": "0.6.2",
   "description": "ZeroPress Markdown build action and CLI for static hosting",
   "type": "module",
   "license": "MIT",
@@ -40,7 +40,7 @@
     "node": ">=18.18.0"
   },
   "dependencies": {
-    "@zeropress/build": "0.5.2",
+    "@zeropress/build": "0.6.2",
     "gray-matter": "4.0.3"
   },
   "devDependencies": {

package/schemas/zeropress-build-pages.config.v0.1.schema.json

@@ -50,6 +50,18 @@
           "description": "Canonical site URL. Use an empty string or omit this field for local builds without canonical output.",
           "markdownDescription": "Canonical site URL. Use an empty string or omit this field for local builds without canonical output."
         },
+        "expose_generator": {
+          "type": "boolean",
+          "default": true,
+          "description": "Whether generated HTML should expose the ZeroPress generator meta tag. Set false for white-label sites.",
+          "markdownDescription": "Whether generated HTML should expose `<meta name=\"generator\" content=\"ZeroPress\">`. Set `false` for white-label sites."
+        },
+        "search": {
+          "type": "boolean",
+          "default": true,
+          "description": "Whether native ZeroPress search should be enabled when the selected theme supports search UI. Set false to omit native search artifacts and hide theme search UI.",
+          "markdownDescription": "Whether native ZeroPress search should be enabled when the selected theme supports search UI. Set `false` to omit native search artifacts and hide theme search UI."
+        },
         "indexing": {
           "type": "boolean",
           "default": true,
@@ -74,17 +86,6 @@
           "markdownDescription": "Footer copyright or legal text. ZeroPress does not add a copyright symbol automatically."
         },
         "attribution": {
-          "$ref": "#/$defs/siteFooterAttribution"
-        }
-      }
-    },
-    "siteFooterAttribution": {
-      "type": "object",
-      "additionalProperties": false,
-      "description": "Optional ZeroPress attribution display policy for themes.",
-      "markdownDescription": "Optional ZeroPress attribution display policy for themes.",
-      "properties": {
-        "enabled": {
           "type": "boolean",
           "description": "When false, bundled themes hide the Published with ZeroPress attribution. Missing or true means attribution may be shown.",
           "markdownDescription": "When `false`, bundled themes hide the Published with ZeroPress attribution. Missing or `true` means attribution may be shown."
@@ -227,6 +228,12 @@
         "$ref": "#/$defs/menu"
       }
     },
+    "previewMeta": {
+      "type": "object",
+      "additionalProperties": {
+        "type": ["string", "number", "boolean", "null"]
+      }
+    },
     "menu": {
       "type": "object",
       "additionalProperties": false,
@@ -248,6 +255,8 @@
       "type": "object",
       "additionalProperties": false,
       "required": ["title", "url"],
+      "description": "Menu item copied into generated preview-data.",
+      "markdownDescription": "Menu item copied into generated preview-data.",
       "properties": {
         "title": {
           "type": "string",
@@ -267,6 +276,9 @@
           "enum": ["_self", "_blank"],
           "default": "_self"
         },
+        "meta": {
+          "$ref": "#/$defs/previewMeta"
+        },
         "children": {
           "type": "array",
           "items": {
@@ -285,6 +297,8 @@
         "title": "ZeroPress Public Docs",
         "description": "Public documentation.",
         "url": "https://zeropress.dev",
+        "expose_generator": true,
+        "search": true,
         "indexing": true
       },
       "front_page": {
@@ -303,7 +317,14 @@
           "name": "Primary Menu",
           "items": [
             { "title": "Home", "url": "/" },
-            { "title": "Docs", "url": "/docs/" }
+            {
+              "title": "Docs",
+              "url": "/docs/",
+              "meta": {
+                "icon": "book-open",
+                "badge": "New"
+              }
+            }
           ]
         }
       }

package/src/action.js

@@ -2,6 +2,7 @@ import { runBuildPages } from './index.js';
 
 const options = {
   source: input('source') || './docs',
+  publicDir: input('public-dir'),
   destination: input('destination') || './_site',
   theme: input('theme') || 'docs',
   themePath: input('theme-path'),
@@ -21,7 +22,7 @@ try {
 }
 
 function input(name) {
-  return process.env[`INPUT_${name.toUpperCase().replace(/-/g, '_')}`]?.trim() || '';
+  return process.env[`INPUT_${name.toUpperCase()}`]?.trim() || '';
 }
 
 function booleanInput(name, fallback) {

package/src/index.js

@@ -39,6 +39,8 @@ export async function runBuildPages(options) {
   const cwd = path.resolve(options.cwd || process.cwd());
   const copyMarkdownSource = options.copyMarkdownSource !== false;
   const sourceDir = path.resolve(cwd, options.source);
+  const publicDirExplicit = hasExplicitPublicDir(options);
+  const publicDir = publicDirExplicit ? path.resolve(cwd, options.publicDir) : sourceDir;
   const destinationDir = path.resolve(cwd, options.destination);
   const generatedDir = path.join(cwd, '.zeropress');
   const stagingDir = path.join(cwd, STAGING_DIR);
@@ -48,18 +50,23 @@ export async function runBuildPages(options) {
   assertBuildPagesPathLayout({
     cwd,
     sourceDir,
+    publicDir,
+    publicDirExplicit,
     destinationDir,
     themeDir,
     generatedDir,
   });
   await assertDirectory(sourceDir, 'Source directory');
+  await assertPublicDirectory(publicDir, publicDirExplicit);
+  await assertDestinationPath(destinationDir);
   await fs.rm(generatedDir, { recursive: true, force: true });
   await fs.mkdir(generatedDir, { recursive: true });
 
   const env = {
     ...process.env,
     ZEROPRESS_BUILD_PAGES_SOURCE: sourceDir,
-    ZEROPRESS_PUBLIC_DIR: sourceDir,
+    ZEROPRESS_BUILD_PAGES_PUBLIC_DIR: publicDir,
+    ZEROPRESS_PUBLIC_DIR: publicDir,
     ZEROPRESS_SKIP_UNTITLED_MARKDOWN: String(Boolean(options.skipUntitledMarkdown)),
     ZEROPRESS_COPY_MARKDOWN_SOURCE: String(copyMarkdownSource),
   };
@@ -85,10 +92,13 @@ export async function runBuildPages(options) {
   await fs.rm(destinationDir, { recursive: true, force: true });
   await fs.rm(stagingDir, { recursive: true, force: true });
   await fs.mkdir(stagingDir, { recursive: true });
-  await copyPublicStaging(sourceDir, stagingDir, {
+  await copyPublicStaging(publicDir, stagingDir, {
     excludePaths: [destinationDir, themeDir, generatedDir],
     copyMarkdownSource,
   });
+  if (copyMarkdownSource) {
+    await copySourceMarkdownFiles(sourceDir, stagingDir, previewData);
+  }
 
   const previousPublicDir = process.env.ZEROPRESS_PUBLIC_DIR;
   process.env.ZEROPRESS_PUBLIC_DIR = stagingDir;
@@ -137,6 +147,7 @@ export function parseArgs(argv) {
 
     const valueOptions = new Set([
       '--source',
+      '--public-dir',
       '--destination',
       '--theme',
       '--theme-path',
@@ -167,6 +178,7 @@ export function parseArgs(argv) {
 
   return {
     source,
+    publicDir: flags['public-dir'] || '',
     destination,
     theme: flags.theme || DEFAULT_THEME,
     themePath: flags['theme-path'] || '',
@@ -186,6 +198,7 @@ Usage:
 
 Options:
   --source <dir>                Dedicated source directory (required)
+  --public-dir <dir>            Public passthrough directory (default: source)
   --destination <dir>           Output directory (required)
   --theme docs                  Bundled theme name (default: docs)
   --theme-path <dir>            Custom ZeroPress theme directory
@@ -208,6 +221,10 @@ function resolveThemeDir(cwd, options) {
   throw new Error(`Unknown bundled theme: ${options.theme}`);
 }
 
+function hasExplicitPublicDir(options) {
+  return typeof options.publicDir === 'string' && Boolean(options.publicDir.trim());
+}
+
 async function assertDirectory(dir, label) {
   let stat;
   try {
@@ -223,7 +240,55 @@ async function assertDirectory(dir, label) {
   }
 }
 
-function assertBuildPagesPathLayout({ cwd, sourceDir, destinationDir, themeDir, generatedDir }) {
+async function assertPublicDirectory(publicDir, explicit) {
+  if (!explicit) {
+    return;
+  }
+
+  let stat;
+  try {
+    stat = await fs.lstat(publicDir);
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      throw new Error(`Public directory not found: ${publicDir}`);
+    }
+    throw error;
+  }
+
+  if (stat.isSymbolicLink()) {
+    throw new Error(`Public directory must not be a symbolic link: ${publicDir}`);
+  }
+
+  if (!stat.isDirectory()) {
+    throw new Error(`Public path is not a directory: ${publicDir}`);
+  }
+}
+
+async function assertDestinationPath(destinationDir) {
+  let stat;
+  try {
+    stat = await fs.lstat(destinationDir);
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return;
+    }
+    throw error;
+  }
+
+  if (!stat.isDirectory()) {
+    throw new Error(`Destination path is not a directory: ${destinationDir}`);
+  }
+}
+
+function assertBuildPagesPathLayout({
+  cwd,
+  sourceDir,
+  publicDir,
+  publicDirExplicit,
+  destinationDir,
+  themeDir,
+  generatedDir,
+}) {
   if (samePath(sourceDir, cwd)) {
     throw new Error(
       'Source directory must be a dedicated content directory, not the current working directory. '
@@ -231,11 +296,36 @@ function assertBuildPagesPathLayout({ cwd, sourceDir, destinationDir, themeDir,
     );
   }
 
+  if (publicDirExplicit && samePath(publicDir, cwd)) {
+    throw new Error(
+      'Public directory must be a dedicated asset directory, not the current working directory. '
+      + `Received: ${formatPath(cwd, publicDir)}`,
+    );
+  }
+
   assertNoPathOverlap(cwd, 'Source directory', sourceDir, 'internal .zeropress working directory', generatedDir);
   assertNoPathOverlap(cwd, 'Destination directory', destinationDir, 'internal .zeropress working directory', generatedDir);
   assertNoPathOverlap(cwd, 'Theme directory', themeDir, 'internal .zeropress working directory', generatedDir);
+  if (!samePath(publicDir, sourceDir)) {
+    assertNoPathOverlap(cwd, 'Public directory', publicDir, 'internal .zeropress working directory', generatedDir);
+    assertNoPathOverlap(cwd, 'Public directory', publicDir, 'destination directory', destinationDir);
+    assertNoPathOverlap(cwd, 'Public directory', publicDir, 'theme directory', themeDir);
+  }
   assertNoPathOverlap(cwd, 'Source directory', sourceDir, 'destination directory', destinationDir);
   assertNoPathOverlap(cwd, 'Source directory', sourceDir, 'theme directory', themeDir);
+  assertSourceIsNotInsidePublicDirectory(cwd, sourceDir, publicDir);
+}
+
+function assertSourceIsNotInsidePublicDirectory(cwd, sourceDir, publicDir) {
+  if (samePath(sourceDir, publicDir) || !isPathInside(publicDir, sourceDir)) {
+    return;
+  }
+
+  throw new Error(
+    'Source directory must not be inside the public directory. '
+    + `Source directory: ${formatPath(cwd, sourceDir)}; `
+    + `Public directory: ${formatPath(cwd, publicDir)}`,
+  );
 }
 
 function assertNoPathOverlap(cwd, firstLabel, firstPath, secondLabel, secondPath) {
@@ -282,6 +372,67 @@ async function copyPublicStaging(sourceDir, targetDir, options) {
   }
 }
 
+async function copySourceMarkdownFiles(sourceDir, targetDir, previewData) {
+  const markdownUrls = new Set();
+
+  for (const page of previewData?.content?.pages || []) {
+    const sourceMarkdownUrl = page?.meta?.source_markdown_url;
+    if (typeof sourceMarkdownUrl === 'string' && sourceMarkdownUrl) {
+      markdownUrls.add(sourceMarkdownUrl);
+    }
+  }
+
+  for (const sourceMarkdownUrl of markdownUrls) {
+    const relativePath = sourceMarkdownUrlToRelativePath(sourceMarkdownUrl);
+    if (!relativePath) {
+      continue;
+    }
+
+    const sourcePath = path.join(sourceDir, relativePath);
+    if (!isPathInside(sourceDir, sourcePath)) {
+      continue;
+    }
+
+    const targetPath = path.join(targetDir, relativePath);
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.copyFile(sourcePath, targetPath);
+  }
+}
+
+function sourceMarkdownUrlToRelativePath(sourceMarkdownUrl) {
+  if (
+    !sourceMarkdownUrl.startsWith('/')
+    || sourceMarkdownUrl.includes('?')
+    || sourceMarkdownUrl.includes('#')
+  ) {
+    return '';
+  }
+
+  const rawSegments = sourceMarkdownUrl.slice(1).split('/');
+  const segments = [];
+  for (const rawSegment of rawSegments) {
+    if (!rawSegment) {
+      return '';
+    }
+
+    let segment;
+    try {
+      segment = decodeURIComponent(rawSegment);
+    } catch {
+      return '';
+    }
+
+    if (!segment || segment === '.' || segment === '..' || segment.includes('/') || segment.includes('\\')) {
+      return '';
+    }
+
+    segments.push(segment);
+  }
+
+  const relativePath = segments.join('/');
+  return relativePath.toLowerCase().endsWith('.md') ? relativePath : '';
+}
+
 function shouldIgnorePublicEntry(name) {
   const basename = String(name || '');
   const lowerName = basename.toLowerCase();