@dimm-city/print-md 0.4.1 → 0.5.0-rc.10

package/dist/cli.js

@@ -758,6 +758,15 @@ var init_images = __esm(() => {
   PREFIX_PATTERNS = [/^(?:\.\/|\/)?temp\/images\//, /^(?:\.\/|\/)?images\//];
 });
 
+// ../lib/src/lib/markdown/chapter-id.ts
+function canonicalChapterId(p) {
+  let s = String(p).replace(/\\/g, "/");
+  s = s.replace(/\/{2,}/g, "/");
+  while (s.startsWith("./"))
+    s = s.slice(2);
+  return s;
+}
+
 // ../lib/src/lib/markdown/plugins.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { resolve as resolve2, join } from "node:path";
@@ -911,12 +920,13 @@ async function renderChapters(inputDir, opts = {}) {
   }
   let bodyContent = "";
   for (const file of files) {
-    const filePath = join2(inputDir, file);
+    const chapterId = canonicalChapterId(file);
+    const filePath = join2(inputDir, chapterId);
     try {
       const content = await readFile2(filePath, "utf-8");
       const rendered = md.render(content);
       if (opts.wrapChapters) {
-        const safe = String(file).replace(/&/g, "&").replace(/"/g, """);
+        const safe = chapterId.replace(/&/g, "&").replace(/"/g, """);
         bodyContent += `<div class="pmd-chapter" data-chapter-src="${safe}">
 ${rendered}
 </div>
@@ -22693,7 +22703,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@dimm-city/print-md-lib",
-    version: "0.4.1",
+    version: "0.5.0-rc.10",
     private: true,
     type: "module",
     main: "dist/index.js",
@@ -22724,6 +22734,7 @@ var init_package = __esm(() => {
     },
     dependencies: {
       chokidar: "^5.0.0",
+      diff3: "0.0.3",
       glob: "^13.0.0",
       htmlhint: "^1.9.2",
       "isomorphic-git": "^1.38.4",
@@ -22941,7 +22952,7 @@ var manifest_schema_default = "./manifest.schema-16z94mx1.json";
 var init_manifest_schema = () => {};
 
 // ../lib/src/assets/preview/scripts/pagedjs-interface.js
-var pagedjs_interface_default = "./pagedjs-interface-er3k3jvc.js";
+var pagedjs_interface_default = "./pagedjs-interface-x79je7c5.js";
 var init_pagedjs_interface = () => {};
 
 // ../lib/src/assets/preview/scripts/pagedjs-bridge.js
@@ -22949,7 +22960,7 @@ var pagedjs_bridge_default = "./pagedjs-bridge-k1a8jxtv.js";
 var init_pagedjs_bridge = () => {};
 
 // ../lib/src/assets/preview/scripts/preview-shell.js
-var preview_shell_default = "./preview-shell-663marwv.js";
+var preview_shell_default = "./preview-shell-fx145xzs.js";
 var init_preview_shell = () => {};
 
 // ../lib/src/assets/vendor/paged.polyfill.js
@@ -93538,13 +93549,19 @@ function resolveExternalAssetRoots(inputPath, assets) {
 function resolveDestinationForChange(filePath2, inputPath, tempDir, externalRoots) {
   if (filePath2 === inputPath || filePath2.startsWith(inputPath + path6.sep)) {
     const relativePath = path6.relative(inputPath, filePath2);
-    return { destPath: path6.join(tempDir, relativePath), relativePath };
+    return {
+      destPath: path6.join(tempDir, relativePath),
+      relativePath: relativePath.replace(/\\/g, "/")
+    };
   }
   for (const root2 of externalRoots) {
     if (filePath2 === root2.src || filePath2.startsWith(root2.src + path6.sep)) {
       const relInRoot = path6.relative(root2.src, filePath2);
       const relativePath = path6.join(root2.destName, relInRoot);
-      return { destPath: path6.join(tempDir, relativePath), relativePath };
+      return {
+        destPath: path6.join(tempDir, relativePath),
+        relativePath: relativePath.replace(/\\/g, "/")
+      };
     }
   }
   return null;
@@ -93634,44 +93651,69 @@ function createFileWatcher(state) {
       pollInterval: 50
     }
   });
-  watcher.on("all", async (event, filePath2) => {
-    debug2(`File ${event}: ${filePath2}`);
+  const pendingChanges = new Map;
+  function scheduleRebuild() {
     if (state.rebuildTimer)
       clearTimeout(state.rebuildTimer);
-    state.rebuildTimer = setTimeout(async () => {
-      if (state.isRebuilding)
-        return;
-      state.isRebuilding = true;
-      try {
-        info("Regenerating preview...");
-        const dest = resolveDestinationForChange(filePath2, inputResolved, state.tempDir, externalRoots);
-        if (dest) {
+    state.rebuildTimer = setTimeout(runRebuild, DEBOUNCE.FILE_WATCH);
+  }
+  async function runRebuild() {
+    if (state.isRebuilding)
+      return;
+    const changes = [...pendingChanges.entries()];
+    pendingChanges.clear();
+    if (changes.length === 0)
+      return;
+    state.isRebuilding = true;
+    try {
+      info("Regenerating preview...");
+      const dests = [];
+      for (const [changedPath, changedEvent] of changes) {
+        const dest = resolveDestinationForChange(changedPath, inputResolved, state.tempDir, externalRoots);
+        if (!dest)
+          continue;
+        if (existsSync13(changedPath)) {
           await fsp2.mkdir(path6.dirname(dest.destPath), { recursive: true });
-          await fsp2.copyFile(filePath2, dest.destPath);
+          await fsp2.copyFile(changedPath, dest.destPath);
           debug2(`Updated: ${dest.relativePath}`);
         }
-        if (dest && path6.extname(filePath2).toLowerCase() === ".css") {
-          state.previewServer?.broadcastCssUpdate(dest.relativePath);
-          info(`CSS hot-swapped: ${dest.relativePath}`);
-          return;
-        }
-        const manifest = await loadManifest(state.currentInputPath);
-        const updatedConfig = resolveConfig({}, manifest);
-        state.config = updatedConfig;
-        await generateAndWriteHtml(state.currentInputPath, state.tempDir, updatedConfig);
-        if (incrementalPreviewEnabled() && dest && path6.extname(filePath2).toLowerCase() === ".md") {
-          state.previewServer?.broadcastContentUpdate(dest.relativePath);
-          info(`Chapter updated: ${dest.relativePath}`);
-        } else {
-          state.previewServer?.broadcastReload();
-          info("Preview updated");
+        dests.push({
+          relativePath: dest.relativePath,
+          ext: path6.extname(changedPath).toLowerCase(),
+          event: changedEvent
+        });
+      }
+      if (dests.length === changes.length && dests.length > 0 && dests.every((d) => d.ext === ".css")) {
+        for (const d of dests) {
+          state.previewServer?.broadcastCssUpdate(d.relativePath);
+          info(`CSS hot-swapped: ${d.relativePath}`);
         }
-      } catch (err) {
-        error("Failed to regenerate preview:", err);
-      } finally {
-        state.isRebuilding = false;
+        return;
       }
-    }, DEBOUNCE.FILE_WATCH);
+      const manifest = await loadManifest(state.currentInputPath);
+      const updatedConfig = resolveConfig({}, manifest);
+      state.config = updatedConfig;
+      await generateAndWriteHtml(state.currentInputPath, state.tempDir, updatedConfig);
+      const only = dests.length === 1 ? dests[0] : null;
+      if (incrementalPreviewEnabled() && changes.length === 1 && only && only.ext === ".md" && only.event !== "unlink" && only.event !== "unlinkDir") {
+        state.previewServer?.broadcastContentUpdate(canonicalChapterId(only.relativePath));
+        info(`Chapter updated: ${only.relativePath}`);
+      } else {
+        state.previewServer?.broadcastReload();
+        info(changes.length > 1 ? `Preview updated (${changes.length} files changed — full reload)` : "Preview updated");
+      }
+    } catch (err) {
+      error("Failed to regenerate preview:", err);
+    } finally {
+      state.isRebuilding = false;
+      if (pendingChanges.size > 0)
+        scheduleRebuild();
+    }
+  }
+  watcher.on("all", (event, filePath2) => {
+    debug2(`File ${event}: ${filePath2}`);
+    pendingChanges.set(filePath2, event);
+    scheduleRebuild();
   });
   info("Watching for file changes...");
   return watcher;
@@ -94054,6 +94096,20 @@ async function createPreviewServer(state, port, restartPreviewFn) {
       }
       return;
     }
+    if (url.pathname === "/__log" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk) => {
+        if (body.length < 2048)
+          body += chunk;
+      });
+      req.on("end", () => {
+        if (body)
+          info(`[preview-shell] ${body.slice(0, 1024)}`);
+        res.writeHead(204);
+        res.end();
+      });
+      return;
+    }
     if (url.pathname === "/__chapter") {
       const file = url.searchParams.get("file");
       if (!file || !state.currentInputPath) {
@@ -94379,6 +94435,108 @@ var init_diagnostics = __esm(() => {
 });
 
 // ../lib/src/lib/project-source.ts
+import { stat as stat5, readFile as readFile21 } from "node:fs/promises";
+import os3 from "node:os";
+import path9 from "node:path";
+async function isDirectory2(target) {
+  try {
+    return (await stat5(target)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function parseRemoteUrl(configText) {
+  const sectionRe = /\[remote\s+"([^"]+)"\]([^[]*)/g;
+  let firstUrl;
+  let originUrl;
+  let match;
+  while ((match = sectionRe.exec(configText)) !== null) {
+    const name = match[1];
+    const body = match[2] ?? "";
+    const urlMatch = /^\s*url\s*=\s*(.+?)\s*$/m.exec(body);
+    if (!urlMatch)
+      continue;
+    const url = urlMatch[1];
+    if (!url)
+      continue;
+    if (firstUrl === undefined)
+      firstUrl = url;
+    if (name === "origin") {
+      originUrl = url;
+      break;
+    }
+  }
+  return originUrl ?? firstUrl;
+}
+function parseHeadBranch(headText) {
+  const match = /^ref:\s*refs\/heads\/(.+?)\s*$/m.exec(headText);
+  return match ? match[1] : undefined;
+}
+async function findEnclosingRepoDir(folderPath) {
+  const home = path9.resolve(os3.homedir());
+  let dir = path9.resolve(folderPath);
+  for (let i = 0;i < 64; i++) {
+    const parent = path9.dirname(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+    if (await isDirectory2(path9.join(dir, ".git")))
+      return dir;
+    if (dir === home)
+      return;
+  }
+  return;
+}
+async function readGitDirInfo(gitDir) {
+  let remoteUrl;
+  try {
+    const configText = await readFile21(path9.join(gitDir, "config"), "utf8");
+    remoteUrl = parseRemoteUrl(configText);
+  } catch {
+    remoteUrl = undefined;
+  }
+  let branch;
+  try {
+    const headText = await readFile21(path9.join(gitDir, "HEAD"), "utf8");
+    branch = parseHeadBranch(headText);
+  } catch {
+    branch = undefined;
+  }
+  return { remoteUrl, branch };
+}
+function repoSubPath(repoRoot, folderPath) {
+  const rel = path9.relative(path9.resolve(repoRoot), path9.resolve(folderPath));
+  return rel.split(path9.sep).join("/");
+}
+async function detectProjectSource(folderPath) {
+  const ownGitDir = path9.join(folderPath, ".git");
+  if (await isDirectory2(ownGitDir)) {
+    const { remoteUrl, branch } = await readGitDirInfo(ownGitDir);
+    return {
+      type: "local-git-folder",
+      path: folderPath,
+      repoRoot: folderPath,
+      subPath: "",
+      hasRemote: remoteUrl !== undefined,
+      ...remoteUrl !== undefined ? { remoteUrl } : {},
+      ...branch !== undefined ? { branch } : {}
+    };
+  }
+  const enclosingRepoDir = await findEnclosingRepoDir(folderPath);
+  if (enclosingRepoDir !== undefined) {
+    const { remoteUrl, branch } = await readGitDirInfo(path9.join(enclosingRepoDir, ".git"));
+    return {
+      type: "local-git-folder",
+      path: folderPath,
+      repoRoot: enclosingRepoDir,
+      subPath: repoSubPath(enclosingRepoDir, folderPath),
+      hasRemote: remoteUrl !== undefined,
+      ...remoteUrl !== undefined ? { remoteUrl } : {},
+      ...branch !== undefined ? { branch } : {}
+    };
+  }
+  return { type: "local-folder", path: folderPath };
+}
 function capabilitiesFor(source) {
   switch (source.type) {
     case "local-folder":
@@ -94389,7 +94547,6 @@ function capabilitiesFor(source) {
         canSnapshot: false,
         canViewHistory: false,
         canRestoreSnapshot: false,
-        canPublish: false,
         canSync: false,
         authManagedByApp: false
       };
@@ -94401,7 +94558,6 @@ function capabilitiesFor(source) {
         canSnapshot: true,
         canViewHistory: true,
         canRestoreSnapshot: true,
-        canPublish: source.hasRemote,
         canSync: source.hasRemote,
         authManagedByApp: false
       };
@@ -94413,7 +94569,6 @@ function capabilitiesFor(source) {
         canSnapshot: true,
         canViewHistory: true,
         canRestoreSnapshot: true,
-        canPublish: true,
         canSync: true,
         authManagedByApp: true
       };
@@ -96412,20 +96567,20 @@ var require_ignore = __commonJS((exports, module) => {
   var throwError = (message, Ctor) => {
     throw new Ctor(message);
   };
-  var checkPath = (path9, originalPath, doThrow) => {
-    if (!isString2(path9)) {
+  var checkPath = (path10, originalPath, doThrow) => {
+    if (!isString2(path10)) {
       return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
     }
-    if (!path9) {
+    if (!path10) {
       return doThrow(`path must not be empty`, TypeError);
     }
-    if (checkPath.isNotRelative(path9)) {
+    if (checkPath.isNotRelative(path10)) {
       const r = "`path.relative()`d";
       return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
     }
     return true;
   };
-  var isNotRelative = (path9) => REGEX_TEST_INVALID_PATH.test(path9);
+  var isNotRelative = (path10) => REGEX_TEST_INVALID_PATH.test(path10);
   checkPath.isNotRelative = isNotRelative;
   checkPath.convert = (p10) => p10;
 
@@ -96468,7 +96623,7 @@ var require_ignore = __commonJS((exports, module) => {
     addPattern(pattern) {
       return this.add(pattern);
     }
-    _testOne(path9, checkUnignored) {
+    _testOne(path10, checkUnignored) {
       let ignored = false;
       let unignored = false;
       this._rules.forEach((rule2) => {
@@ -96476,7 +96631,7 @@ var require_ignore = __commonJS((exports, module) => {
         if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
           return;
         }
-        const matched = rule2.regex.test(path9);
+        const matched = rule2.regex.test(path10);
         if (matched) {
           ignored = !negative;
           unignored = negative;
@@ -96488,39 +96643,39 @@ var require_ignore = __commonJS((exports, module) => {
       };
     }
     _test(originalPath, cache2, checkUnignored, slices) {
-      const path9 = originalPath && checkPath.convert(originalPath);
-      checkPath(path9, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
-      return this._t(path9, cache2, checkUnignored, slices);
+      const path10 = originalPath && checkPath.convert(originalPath);
+      checkPath(path10, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+      return this._t(path10, cache2, checkUnignored, slices);
     }
-    _t(path9, cache2, checkUnignored, slices) {
-      if (path9 in cache2) {
-        return cache2[path9];
+    _t(path10, cache2, checkUnignored, slices) {
+      if (path10 in cache2) {
+        return cache2[path10];
       }
       if (!slices) {
-        slices = path9.split(SLASH);
+        slices = path10.split(SLASH);
       }
       slices.pop();
       if (!slices.length) {
-        return cache2[path9] = this._testOne(path9, checkUnignored);
+        return cache2[path10] = this._testOne(path10, checkUnignored);
       }
       const parent = this._t(slices.join(SLASH) + SLASH, cache2, checkUnignored, slices);
-      return cache2[path9] = parent.ignored ? parent : this._testOne(path9, checkUnignored);
+      return cache2[path10] = parent.ignored ? parent : this._testOne(path10, checkUnignored);
     }
-    ignores(path9) {
-      return this._test(path9, this._ignoreCache, false).ignored;
+    ignores(path10) {
+      return this._test(path10, this._ignoreCache, false).ignored;
     }
     createFilter() {
-      return (path9) => !this.ignores(path9);
+      return (path10) => !this.ignores(path10);
     }
     filter(paths) {
       return makeArray(paths).filter(this.createFilter());
     }
-    test(path9) {
-      return this._test(path9, this._testCache, true);
+    test(path10) {
+      return this._test(path10, this._testCache, true);
     }
   }
   var factory = (options) => new Ignore(options);
-  var isPathValid = (path9) => checkPath(path9 && checkPath.convert(path9), path9, RETURN_FALSE);
+  var isPathValid = (path10) => checkPath(path10 && checkPath.convert(path10), path10, RETURN_FALSE);
   factory.isPathValid = isPathValid;
   factory.default = factory;
   module.exports = factory;
@@ -96528,7 +96683,7 @@ var require_ignore = __commonJS((exports, module) => {
     const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
     checkPath.convert = makePosix;
     const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-    checkPath.isNotRelative = (path9) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path9) || isNotRelative(path9);
+    checkPath.isNotRelative = (path10) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path10) || isNotRelative(path10);
   }
 });
 
@@ -96565,7 +96720,7 @@ var require_lib3 = __commonJS((exports, module) => {
 // ../../node_modules/.bun/diff3@0.0.3/node_modules/diff3/onp.js
 var require_onp = __commonJS((exports, module) => {
   module.exports = function(a_, b_) {
-    var a = a_, b = b_, m = a.length, n = b.length, reverse = false, ed2 = null, offset = m + 1, path9 = [], pathposi = [], ses = [], lcs = "", SES_DELETE = -1, SES_COMMON = 0, SES_ADD = 1;
+    var a = a_, b = b_, m = a.length, n = b.length, reverse = false, ed2 = null, offset = m + 1, path10 = [], pathposi = [], ses = [], lcs = "", SES_DELETE = -1, SES_COMMON = 0, SES_ADD = 1;
     var tmp1, tmp2;
     var init = function() {
       if (m >= n) {
@@ -96595,9 +96750,9 @@ var require_onp = __commonJS((exports, module) => {
     var snake = function(k, p10, pp2) {
       var r, x, y;
       if (p10 > pp2) {
-        r = path9[k - 1 + offset];
+        r = path10[k - 1 + offset];
       } else {
-        r = path9[k + 1 + offset];
+        r = path10[k + 1 + offset];
       }
       y = Math.max(p10, pp2);
       x = y - k;
@@ -96605,7 +96760,7 @@ var require_onp = __commonJS((exports, module) => {
         ++x;
         ++y;
       }
-      path9[k + offset] = pathposi.length;
+      path10[k + offset] = pathposi.length;
       pathposi[pathposi.length] = new P(x, y, r);
       return y;
     };
@@ -96663,7 +96818,7 @@ var require_onp = __commonJS((exports, module) => {
         fp2 = {};
         for (i = 0;i < size; ++i) {
           fp2[i] = -1;
-          path9[i] = -1;
+          path10[i] = -1;
         }
         p10 = -1;
         do {
@@ -96677,7 +96832,7 @@ var require_onp = __commonJS((exports, module) => {
           fp2[delta + offset] = snake(delta, fp2[delta - 1 + offset] + 1, fp2[delta + 1 + offset]);
         } while (fp2[delta + offset] !== n);
         ed2 = delta + 2 * p10;
-        r = path9[delta + offset];
+        r = path10[delta + offset];
         epc = [];
         while (r !== -1) {
           epc[epc.length] = new P(pathposi[r].x, pathposi[r].y, null);
@@ -97307,17 +97462,17 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
       const length = Math.ceil((62 + bpath.length + 1) / 8) * 8;
       const written = Buffer.alloc(length);
       const writer = new BufferCursor(written);
-      const stat5 = normalizeStats(entry);
-      writer.writeUInt32BE(stat5.ctimeSeconds);
-      writer.writeUInt32BE(stat5.ctimeNanoseconds);
-      writer.writeUInt32BE(stat5.mtimeSeconds);
-      writer.writeUInt32BE(stat5.mtimeNanoseconds);
-      writer.writeUInt32BE(stat5.dev);
-      writer.writeUInt32BE(stat5.ino);
-      writer.writeUInt32BE(stat5.mode);
-      writer.writeUInt32BE(stat5.uid);
-      writer.writeUInt32BE(stat5.gid);
-      writer.writeUInt32BE(stat5.size);
+      const stat6 = normalizeStats(entry);
+      writer.writeUInt32BE(stat6.ctimeSeconds);
+      writer.writeUInt32BE(stat6.ctimeNanoseconds);
+      writer.writeUInt32BE(stat6.mtimeSeconds);
+      writer.writeUInt32BE(stat6.mtimeNanoseconds);
+      writer.writeUInt32BE(stat6.dev);
+      writer.writeUInt32BE(stat6.ino);
+      writer.writeUInt32BE(stat6.mode);
+      writer.writeUInt32BE(stat6.uid);
+      writer.writeUInt32BE(stat6.gid);
+      writer.writeUInt32BE(stat6.size);
       writer.write(entry.oid, 20, "hex");
       writer.writeUInt16BE(renderCacheEntryFlags(entry));
       writer.write(entry.path, bpath.length, "utf8");
@@ -97362,13 +97517,13 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
     };
   }
   async function updateCachedIndexFile(fs5, filepath, cache2) {
-    const [stat5, rawIndexFile] = await Promise.all([
+    const [stat6, rawIndexFile] = await Promise.all([
       fs5.lstat(filepath),
       fs5.read(filepath)
     ]);
     const index2 = await GitIndex.from(rawIndexFile);
     cache2.map.set(filepath, index2);
-    cache2.stats.set(filepath, stat5);
+    cache2.stats.set(filepath, stat6);
   }
   async function isIndexStale(fs5, filepath, cache2) {
     const savedStats = cache2.stats.get(filepath);
@@ -97412,20 +97567,20 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
       return result;
     }
   }
-  function basename3(path9) {
-    const last = Math.max(path9.lastIndexOf("/"), path9.lastIndexOf("\\"));
+  function basename3(path10) {
+    const last = Math.max(path10.lastIndexOf("/"), path10.lastIndexOf("\\"));
     if (last > -1) {
-      path9 = path9.slice(last + 1);
+      path10 = path10.slice(last + 1);
     }
-    return path9;
+    return path10;
   }
-  function dirname6(path9) {
-    const last = Math.max(path9.lastIndexOf("/"), path9.lastIndexOf("\\"));
+  function dirname6(path10) {
+    const last = Math.max(path10.lastIndexOf("/"), path10.lastIndexOf("\\"));
     if (last === -1)
       return ".";
     if (last === 0)
       return "/";
-    return path9.slice(0, last);
+    return path10.slice(0, last);
   }
   function flatFileListToDirectoryStructure(files) {
     const inodes = new Map;
@@ -97763,15 +97918,15 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
    * SPDX-License-Identifier: LGPL-3.0-or-later
    * Copyright (c) James Prevett and other ZenFS contributors.
    */
-  function normalizeString(path9, aar) {
+  function normalizeString(path10, aar) {
     let res = "";
     let lastSegmentLength = 0;
     let lastSlash = -1;
     let dots = 0;
     let char = "\x00";
-    for (let i = 0;i <= path9.length; ++i) {
-      if (i < path9.length)
-        char = path9[i];
+    for (let i = 0;i <= path10.length; ++i) {
+      if (i < path10.length)
+        char = path10[i];
       else if (char === "/")
         break;
       else
@@ -97805,9 +97960,9 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
           }
         } else {
           if (res.length > 0)
-            res += "/" + path9.slice(lastSlash + 1, i);
+            res += "/" + path10.slice(lastSlash + 1, i);
           else
-            res = path9.slice(lastSlash + 1, i);
+            res = path10.slice(lastSlash + 1, i);
           lastSegmentLength = i - lastSlash - 1;
         }
         lastSlash = i;
@@ -97820,20 +97975,20 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
     }
     return res;
   }
-  function normalize2(path9) {
-    if (!path9.length)
+  function normalize2(path10) {
+    if (!path10.length)
       return ".";
-    const isAbsolute2 = path9[0] === "/";
-    const trailingSeparator = path9.at(-1) === "/";
-    path9 = normalizeString(path9, !isAbsolute2);
-    if (!path9.length) {
+    const isAbsolute2 = path10[0] === "/";
+    const trailingSeparator = path10.at(-1) === "/";
+    path10 = normalizeString(path10, !isAbsolute2);
+    if (!path10.length) {
       if (isAbsolute2)
         return "/";
       return trailingSeparator ? "./" : ".";
     }
     if (trailingSeparator)
-      path9 += "/";
-    return isAbsolute2 ? `/${path9}` : path9;
+      path10 += "/";
+    return isAbsolute2 ? `/${path10}` : path10;
   }
   function join9(...args) {
     if (args.length === 0)
@@ -97941,8 +98096,8 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
   var getPath = (section, subsection, name) => {
     return [lower(section), subsection, lower(name)].filter((a) => a != null).join(".");
   };
-  var normalizePath = (path9) => {
-    const pathSegments = path9.split(".");
+  var normalizePath = (path10) => {
+    const pathSegments = path10.split(".");
     const section = pathSegments.shift();
     const name = pathSegments.pop();
     const subsection = pathSegments.length ? pathSegments.join(".") : undefined;
@@ -97981,23 +98136,23 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
             [name, value] = extractedVariable;
           }
         }
-        const path9 = getPath(section, subsection, name);
-        return { line, isSection, section, subsection, name, value, path: path9 };
+        const path10 = getPath(section, subsection, name);
+        return { line, isSection, section, subsection, name, value, path: path10 };
       }) : [];
     }
     static from(text4) {
       return new GitConfig(text4);
     }
-    async get(path9, getall = false) {
-      const normalizedPath = normalizePath(path9).path;
+    async get(path10, getall = false) {
+      const normalizedPath = normalizePath(path10).path;
       const allValues = this.parsedConfig.filter((config) => config.path === normalizedPath).map(({ section, name, value }) => {
         const fn2 = schema[section] && schema[section][name];
         return fn2 ? fn2(value) : value;
       });
       return getall ? allValues : allValues.pop();
     }
-    async getall(path9) {
-      return this.get(path9, true);
+    async getall(path10) {
+      return this.get(path10, true);
     }
     async getSubsections(section) {
       return this.parsedConfig.filter((config) => config.isSection && config.section === section).map((config) => config.subsection);
@@ -98005,10 +98160,10 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
     async deleteSection(section, subsection) {
       this.parsedConfig = this.parsedConfig.filter((config) => !(config.section === section && config.subsection === subsection));
     }
-    async append(path9, value) {
-      return this.set(path9, value, true);
+    async append(path10, value) {
+      return this.set(path10, value, true);
     }
-    async set(path9, value, append = false) {
+    async set(path10, value, append = false) {
       const {
         section,
         subsection,
@@ -98016,7 +98171,7 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
         path: normalizedPath,
         sectionPath,
         isSection
-      } = normalizePath(path9);
+      } = normalizePath(path10);
       const configIndex = findLastIndex(this.parsedConfig, (config) => config.path === normalizedPath);
       if (value == null) {
         if (configIndex !== -1) {
@@ -98389,13 +98544,13 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
       if (mode === "40000")
         mode = "040000";
       const type = mode2type$1(mode);
-      const path9 = buffer.slice(space + 1, nullchar).toString("utf8");
-      if (path9.includes("\\") || path9.includes("/")) {
-        throw new UnsafeFilepathError(path9);
+      const path10 = buffer.slice(space + 1, nullchar).toString("utf8");
+      if (path10.includes("\\") || path10.includes("/")) {
+        throw new UnsafeFilepathError(path10);
       }
       const oid = buffer.slice(nullchar + 1, nullchar + 21).toString("hex");
       cursor = nullchar + 21;
-      _entries.push({ mode, path: path9, oid, type });
+      _entries.push({ mode, path: path10, oid, type });
     }
     return _entries;
   }
@@ -98450,10 +98605,10 @@ If you're a developer and you believe this is a bug in isomorphic-git, please fi
       return Buffer.concat(entries.map((entry) => {
         const mode = Buffer.from(entry.mode.replace(/^0/, ""));
         const space = Buffer.from(" ");
-        const path9 = Buffer.from(entry.path, "utf8");
+        const path10 = Buffer.from(entry.path, "utf8");
         const nullchar = Buffer.from([0]);
         const oid = Buffer.from(entry.oid, "hex");
-        return Buffer.concat([mode, space, path9, nullchar, oid]);
+        return Buffer.concat([mode, space, path10, nullchar, oid]);
       }));
     }
     entries() {
@@ -100035,21 +100190,21 @@ gpgsig`));
     async stat(entry) {
       if (entry._stat === false) {
         const { fs: fs5, dir } = this;
-        let stat5 = await fs5.lstat(`${dir}/${entry._fullpath}`);
-        if (!stat5) {
+        let stat6 = await fs5.lstat(`${dir}/${entry._fullpath}`);
+        if (!stat6) {
           throw new Error(`ENOENT: no such file or directory, lstat '${entry._fullpath}'`);
         }
-        let type = stat5.isDirectory() ? "tree" : "blob";
-        if (type === "blob" && !stat5.isFile() && !stat5.isSymbolicLink()) {
+        let type = stat6.isDirectory() ? "tree" : "blob";
+        if (type === "blob" && !stat6.isFile() && !stat6.isSymbolicLink()) {
           type = "special";
         }
         entry._type = type;
-        stat5 = normalizeStats(stat5);
-        entry._mode = stat5.mode;
-        if (stat5.size === -1 && entry._actualSize) {
-          stat5.size = entry._actualSize;
+        stat6 = normalizeStats(stat6);
+        entry._mode = stat6.mode;
+        if (stat6.size === -1 && entry._actualSize) {
+          stat6.size = entry._actualSize;
         }
-        entry._stat = stat5;
+        entry._stat = stat6;
       }
       return entry._stat;
     }
@@ -100237,10 +100392,10 @@ gpgsig`));
     } else if (entries.length) {
       await Promise.all(entries.map((entry) => {
         const subpath = join9(filepath, entry);
-        return fs5.lstat(subpath).then((stat5) => {
-          if (!stat5)
+        return fs5.lstat(subpath).then((stat6) => {
+          if (!stat6)
             return;
-          return stat5.isDirectory() ? rmRecursive(fs5, subpath) : fs5.rm(subpath);
+          return stat6.isDirectory() ? rmRecursive(fs5, subpath) : fs5.rm(subpath);
         });
       })).then(() => fs5.rmdir(filepath));
     } else {
@@ -100510,13 +100665,13 @@ gpgsig`));
         dir,
         gitdir: updatedGitdir,
         trees,
-        map: async function(path9, [head, workdir, index2]) {
+        map: async function(path10, [head, workdir, index2]) {
           const staged = !await modified(workdir, index2);
-          const unmerged = unmergedPaths.includes(path9);
+          const unmerged = unmergedPaths.includes(path10);
           const unmodified = !await modified(index2, head);
           if (staged || unmerged) {
             return head ? {
-              path: path9,
+              path: path10,
               mode: await head.mode(),
               oid: await head.oid(),
               type: await head.type(),
@@ -100526,7 +100681,7 @@ gpgsig`));
           if (unmodified)
             return false;
           else
-            throw new IndexResetError(path9);
+            throw new IndexResetError(path10);
         }
       });
       await GitIndexManager.acquire({ fs: fs5, gitdir: updatedGitdir, cache: cache2 }, async function(index2) {
@@ -100772,9 +100927,9 @@ gpgsig`));
     const fulfilledPromises = settledPromises.filter((settle) => settle.status === "fulfilled" && settle.value).map((settle) => settle.value);
     return fulfilledPromises;
   }
-  async function _getConfig({ fs: fs5, gitdir, path: path9 }) {
+  async function _getConfig({ fs: fs5, gitdir, path: path10 }) {
     const config = await GitConfigManager.get({ fs: fs5, gitdir });
-    return config.get(path9);
+    return config.get(path10);
   }
   function assignDefined(target, ...sources) {
     for (const source of sources) {
@@ -102064,14 +102219,14 @@ gpgsig`));
       gitdir,
       trees: [ourTree, baseTree, theirTree],
       map: async function(filepath, [ours, base, theirs]) {
-        const path9 = basename3(filepath);
+        const path10 = basename3(filepath);
         const ourChange = await modified(ours, base);
         const theirChange = await modified(theirs, base);
         switch (`${ourChange}-${theirChange}`) {
           case "false-false": {
             return {
               mode: await base.mode(),
-              path: path9,
+              path: path10,
               oid: await base.oid(),
               type: await base.type()
             };
@@ -102080,14 +102235,14 @@ gpgsig`));
             if (!theirs && await ours.type() === "tree") {
               return {
                 mode: await ours.mode(),
-                path: path9,
+                path: path10,
                 oid: await ours.oid(),
                 type: await ours.type()
               };
             }
             return theirs ? {
               mode: await theirs.mode(),
-              path: path9,
+              path: path10,
               oid: await theirs.oid(),
               type: await theirs.type()
             } : undefined;
@@ -102096,14 +102251,14 @@ gpgsig`));
             if (!ours && await theirs.type() === "tree") {
               return {
                 mode: await theirs.mode(),
-                path: path9,
+                path: path10,
                 oid: await theirs.oid(),
                 type: await theirs.type()
               };
             }
             return ours ? {
               mode: await ours.mode(),
-              path: path9,
+              path: path10,
               oid: await ours.oid(),
               type: await ours.type()
             } : undefined;
@@ -102112,7 +102267,7 @@ gpgsig`));
             if (ours && theirs && await ours.type() === "tree" && await theirs.type() === "tree") {
               return {
                 mode: await ours.mode(),
-                path: path9,
+                path: path10,
                 oid: await ours.oid(),
                 type: "tree"
               };
@@ -102121,7 +102276,7 @@ gpgsig`));
               return mergeBlobs({
                 fs: fs5,
                 gitdir,
-                path: path9,
+                path: path10,
                 ours,
                 base,
                 theirs,
@@ -102167,7 +102322,7 @@ gpgsig`));
                 mode: await theirs.mode(),
                 oid: await theirs.oid(),
                 type: "blob",
-                path: path9
+                path: path10
               };
             }
             if (base && ours && !theirs && await base.type() === "blob" && await ours.type() === "blob") {
@@ -102184,7 +102339,7 @@ gpgsig`));
                 mode: await ours.mode(),
                 oid: await ours.oid(),
                 type: "blob",
-                path: path9
+                path: path10
               };
             }
             if (base && !ours && !theirs && (await base.type() === "blob" || await base.type() === "tree")) {
@@ -102224,11 +102379,11 @@ gpgsig`));
           gitdir,
           trees: [TREE({ ref: results.oid })],
           map: async function(filepath, [entry]) {
-            const path9 = `${dir}/${filepath}`;
+            const path10 = `${dir}/${filepath}`;
             if (await entry.type() === "blob") {
               const mode = await entry.mode();
               const content4 = new TextDecoder().decode(await entry.content());
-              await fs5.write(path9, content4, { mode });
+              await fs5.write(path10, content4, { mode });
             }
             return true;
           }
@@ -102241,7 +102396,7 @@ gpgsig`));
   async function mergeBlobs({
     fs: fs5,
     gitdir,
-    path: path9,
+    path: path10,
     ours,
     base,
     theirs,
@@ -102264,19 +102419,19 @@ gpgsig`));
     if (await ours.oid() === await theirs.oid()) {
       return {
         cleanMerge: true,
-        mergeResult: { mode, path: path9, oid: await ours.oid(), type }
+        mergeResult: { mode, path: path10, oid: await ours.oid(), type }
       };
     }
     if (await ours.oid() === baseOid) {
       return {
         cleanMerge: true,
-        mergeResult: { mode, path: path9, oid: await theirs.oid(), type }
+        mergeResult: { mode, path: path10, oid: await theirs.oid(), type }
       };
     }
     if (await theirs.oid() === baseOid) {
       return {
         cleanMerge: true,
-        mergeResult: { mode, path: path9, oid: await ours.oid(), type }
+        mergeResult: { mode, path: path10, oid: await ours.oid(), type }
       };
     }
     const ourContent = Buffer.from(await ours.content()).toString("utf8");
@@ -102284,7 +102439,7 @@ gpgsig`));
     const { mergedText, cleanMerge } = await mergeDriver({
       branches: [baseName, ourName, theirName],
       contents: [baseContent, ourContent, theirContent],
-      path: path9
+      path: path10
     });
     const oid = await _writeObject({
       fs: fs5,
@@ -102293,7 +102448,7 @@ gpgsig`));
       object: Buffer.from(mergedText, "utf8"),
       dryRun
     });
-    return { cleanMerge, mergeResult: { mode, path: path9, oid, type } };
+    return { cleanMerge, mergeResult: { mode, path: path10, oid, type } };
   }
   var _TreeMap = {
     stage: STAGE,
@@ -102997,7 +103152,7 @@ gpgsig`));
       const remoteHelpers = new Map;
       remoteHelpers.set("http", GitRemoteHTTP);
       remoteHelpers.set("https", GitRemoteHTTP);
-      const parts = parseRemoteUrl({ url });
+      const parts = parseRemoteUrl2({ url });
       if (!parts) {
         throw new UrlParseError(url);
       }
@@ -103007,7 +103162,7 @@ gpgsig`));
       throw new UnknownTransportError(url, parts.transport, parts.transport === "ssh" ? translateSSHtoHTTP(url) : undefined);
     }
   }
-  function parseRemoteUrl({ url }) {
+  function parseRemoteUrl2({ url }) {
     if (url.startsWith("git@")) {
       return {
         transport: "ssh",
@@ -104464,43 +104619,43 @@ gpgsig`));
       throw err;
     }
   }
-  async function getConfig({ fs: fs5, dir, gitdir = join9(dir, ".git"), path: path9 }) {
+  async function getConfig({ fs: fs5, dir, gitdir = join9(dir, ".git"), path: path10 }) {
     try {
       assertParameter("fs", fs5);
       assertParameter("gitdir", gitdir);
-      assertParameter("path", path9);
+      assertParameter("path", path10);
       const fsp3 = new FileSystem(fs5);
       const updatedGitdir = await discoverGitdir({ fsp: fsp3, dotgit: gitdir });
       return await _getConfig({
         fs: fsp3,
         gitdir: updatedGitdir,
-        path: path9
+        path: path10
       });
     } catch (err) {
       err.caller = "git.getConfig";
       throw err;
     }
   }
-  async function _getConfigAll({ fs: fs5, gitdir, path: path9 }) {
+  async function _getConfigAll({ fs: fs5, gitdir, path: path10 }) {
     const config = await GitConfigManager.get({ fs: fs5, gitdir });
-    return config.getall(path9);
+    return config.getall(path10);
   }
   async function getConfigAll({
     fs: fs5,
     dir,
     gitdir = join9(dir, ".git"),
-    path: path9
+    path: path10
   }) {
     try {
       assertParameter("fs", fs5);
       assertParameter("gitdir", gitdir);
-      assertParameter("path", path9);
+      assertParameter("path", path10);
       const fsp3 = new FileSystem(fs5);
       const updatedGitdir = await discoverGitdir({ fsp: fsp3, dotgit: gitdir });
       return await _getConfigAll({
         fs: fsp3,
         gitdir: updatedGitdir,
-        path: path9
+        path: path10
       });
     } catch (err) {
       err.caller = "git.getConfigAll";
@@ -106529,21 +106684,21 @@ gpgsig`));
     fs: _fs,
     dir,
     gitdir = join9(dir, ".git"),
-    path: path9,
+    path: path10,
     value,
     append = false
   }) {
     try {
       assertParameter("fs", _fs);
       assertParameter("gitdir", gitdir);
-      assertParameter("path", path9);
+      assertParameter("path", path10);
       const fs5 = new FileSystem(_fs);
       const updatedGitdir = await discoverGitdir({ fsp: fs5, dotgit: gitdir });
       const config = await GitConfigManager.get({ fs: fs5, gitdir: updatedGitdir });
       if (append) {
-        await config.append(path9, value);
+        await config.append(path10, value);
       } else {
-        await config.set(path9, value);
+        await config.set(path10, value);
       }
       await GitConfigManager.save({ fs: fs5, gitdir: updatedGitdir, config });
     } catch (err) {
@@ -106837,9 +106992,9 @@ gpgsig`));
     const stashMgr = new GitStashManager({ fs: fs5, dir, gitdir });
     const stashRefPath = [stashMgr.refStashPath, stashMgr.refLogsStashPath];
     await acquireLock$1(stashRefPath, async () => {
-      await Promise.all(stashRefPath.map(async (path9) => {
-        if (await fs5.exists(path9)) {
-          return fs5.rm(path9);
+      await Promise.all(stashRefPath.map(async (path10) => {
+        if (await fs5.exists(path10)) {
+          return fs5.rm(path10);
         }
       }));
     });
@@ -106992,13 +107147,13 @@ gpgsig`));
       throw err;
     }
   }
-  async function getOidAtPath({ fs: fs5, cache: cache2, gitdir: updatedGitdir, tree, path: path9 }) {
-    if (typeof path9 === "string")
-      path9 = path9.split("/");
-    const dirname7 = path9.shift();
+  async function getOidAtPath({ fs: fs5, cache: cache2, gitdir: updatedGitdir, tree, path: path10 }) {
+    if (typeof path10 === "string")
+      path10 = path10.split("/");
+    const dirname7 = path10.shift();
     for (const entry of tree) {
       if (entry.path === dirname7) {
-        if (path9.length === 0) {
+        if (path10.length === 0) {
           return entry.oid;
         }
         const { type, object } = await _readObject({
@@ -107009,10 +107164,10 @@ gpgsig`));
         });
         if (type === "tree") {
           const tree2 = GitTree.from(object);
-          return getOidAtPath({ fs: fs5, cache: cache2, gitdir: updatedGitdir, tree: tree2, path: path9 });
+          return getOidAtPath({ fs: fs5, cache: cache2, gitdir: updatedGitdir, tree: tree2, path: path10 });
         }
         if (type === "blob") {
-          throw new ObjectTypeError(entry.oid, type, "blob", path9.join("/"));
+          throw new ObjectTypeError(entry.oid, type, "blob", path10.join("/"));
         }
       }
     }
@@ -107597,18 +107752,59 @@ gpgsig`));
 // ../lib/src/lib/source-provider.ts
 var exports_source_provider = {};
 __export(exports_source_provider, {
+  withRepoLock: () => withRepoLock,
+  snapshotWorkingTreeUnlocked: () => snapshotWorkingTreeUnlocked,
+  restoreVersionWithBackup: () => restoreVersionWithBackup,
   providerFor: () => providerFor,
-  gitDirFor: () => gitDirFor
+  isNoChangesError: () => isNoChangesError,
+  isGitInternalPath: () => isGitInternalPath,
+  hasPendingChanges: () => hasPendingChanges,
+  gitScopeFor: () => gitScopeFor,
+  gitDirFor: () => gitDirFor,
+  gitAuthor: () => gitAuthor,
+  autoSnapshotDelayMs: () => autoSnapshotDelayMs,
+  RESTORE_BACKUP_MESSAGE: () => RESTORE_BACKUP_MESSAGE,
+  HISTORY_PAGE_LIMIT: () => HISTORY_PAGE_LIMIT,
+  AUTO_SNAPSHOT_MIN_MINUTES: () => AUTO_SNAPSHOT_MIN_MINUTES,
+  AUTO_SNAPSHOT_MESSAGE: () => AUTO_SNAPSHOT_MESSAGE,
+  AUTO_SNAPSHOT_MAX_MINUTES: () => AUTO_SNAPSHOT_MAX_MINUTES,
+  AUTO_SNAPSHOT_DEFAULT_MINUTES: () => AUTO_SNAPSHOT_DEFAULT_MINUTES
 });
 import * as fs5 from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
+function gitScopeFor(source) {
+  return { dir: source.repoRoot || source.path, subPath: source.subPath || "" };
+}
+function withRepoLock(projectDir, fn2) {
+  const key = path10.resolve(projectDir);
+  const prev = repoQueues.get(key) ?? Promise.resolve();
+  const run2 = prev.then(fn2, fn2);
+  repoQueues.set(key, run2.catch(() => {
+    return;
+  }));
+  return run2;
+}
 function gitAuthor(name) {
   const n = (name ?? "").trim();
   return { name: n || DEFAULT_AUTHOR, email: DEFAULT_EMAIL };
 }
-async function stageAll(dir) {
-  const status = await import_isomorphic_git.default.statusMatrix({ fs: fs5, dir });
-  await Promise.all(status.map(([filepath, , worktreeStatus]) => worktreeStatus === 0 ? import_isomorphic_git.default.remove({ fs: fs5, dir, filepath }) : import_isomorphic_git.default.add({ fs: fs5, dir, filepath })));
+async function stageAll(dir, subPath, cache2) {
+  const status = await import_isomorphic_git.default.statusMatrix({
+    fs: fs5,
+    dir,
+    cache: cache2,
+    ...subPath ? { filepaths: [subPath] } : {}
+  });
+  await Promise.all(status.map(([filepath, , worktreeStatus]) => worktreeStatus === 0 ? import_isomorphic_git.default.remove({ fs: fs5, dir, filepath, cache: cache2 }) : import_isomorphic_git.default.add({ fs: fs5, dir, filepath, cache: cache2 })));
+}
+async function hasPendingChanges(dir, subPath, cache2 = {}) {
+  const status = await import_isomorphic_git.default.statusMatrix({
+    fs: fs5,
+    dir,
+    cache: cache2,
+    ...subPath ? { filepaths: [subPath] } : {}
+  });
+  return status.some(([, head, worktree, stage]) => !(head === 1 && worktree === 1 && stage === 1));
 }
 
 class LocalFolderSourceProvider {
@@ -107620,20 +107816,29 @@ class LocalFolderSourceProvider {
   }
   async initVersionHistory(options) {
     const dir = options.projectDir;
-    await import_isomorphic_git.default.init({ fs: fs5, dir, defaultBranch: DEFAULT_BRANCH });
-    await stageAll(dir);
-    await import_isomorphic_git.default.commit({
-      fs: fs5,
-      dir,
-      message: options.initialMessage?.trim() || "Created project",
-      author: gitAuthor(options.authorName)
+    if (await findEnclosingRepoDir(dir) !== undefined) {
+      throw new Error("This folder is already inside a versioned project, so print-md " + "won't create a separate history here.");
+    }
+    return withRepoLock(dir, async () => {
+      const cache2 = {};
+      await import_isomorphic_git.default.init({ fs: fs5, dir, defaultBranch: DEFAULT_BRANCH });
+      await stageAll(dir, undefined, cache2);
+      await import_isomorphic_git.default.commit({
+        fs: fs5,
+        dir,
+        cache: cache2,
+        message: options.initialMessage?.trim() || "Created project",
+        author: gitAuthor(options.authorName)
+      });
+      return {
+        type: "local-git-folder",
+        path: dir,
+        repoRoot: dir,
+        subPath: "",
+        hasRemote: false,
+        branch: DEFAULT_BRANCH
+      };
     });
-    return {
-      type: "local-git-folder",
-      path: dir,
-      hasRemote: false,
-      branch: DEFAULT_BRANCH
-    };
   }
   snapshot() {
     return Promise.reject(new Error("This project has no version history yet. Enable version history first."));
@@ -107641,6 +107846,9 @@ class LocalFolderSourceProvider {
   listHistory() {
     return Promise.resolve([]);
   }
+  listHistoryPage() {
+    return Promise.resolve({ entries: [], hasMore: false });
+  }
   restore() {
     return Promise.reject(new Error("This project has no version history yet. Enable version history first."));
   }
@@ -107649,56 +107857,115 @@ class LocalFolderSourceProvider {
 class LocalGitSourceProvider {
   source;
   capabilities;
+  scope;
   constructor(source) {
     this.source = source;
     this.capabilities = capabilitiesFor(source);
+    this.scope = gitScopeFor(source);
   }
   async initVersionHistory(options) {
-    await this.snapshot({
-      projectDir: options.projectDir,
-      message: options.initialMessage?.trim() || "Created project",
-      authorName: options.authorName
-    }).catch(() => {
-      return;
-    });
+    try {
+      await this.snapshot({
+        projectDir: options.projectDir,
+        message: options.initialMessage?.trim() || "Created project",
+        authorName: options.authorName
+      });
+    } catch (e) {
+      if (!isNoChangesError(e))
+        throw e;
+    }
     return this.source;
   }
-  async snapshot(options) {
-    const dir = options.projectDir;
-    await stageAll(dir);
-    const author = gitAuthor(options.authorName);
-    const id2 = await import_isomorphic_git.default.commit({
-      fs: fs5,
-      dir,
-      message: options.message,
-      author
+  snapshot(options) {
+    return withRepoLock(this.scope.dir, () => this.snapshotUnlocked(options));
+  }
+  snapshotUnlocked(options) {
+    return snapshotWorkingTreeUnlocked({
+      ...options,
+      repoRoot: this.scope.dir,
+      ...this.scope.subPath ? { subPath: this.scope.subPath } : {}
     });
+  }
+  async listHistory(projectDir) {
+    return (await this.listHistoryPage(projectDir)).entries;
+  }
+  async listHistoryPage(_projectDir, options = {}) {
+    const { dir, subPath } = this.scope;
+    const limit = Math.min(500, Math.max(1, options.limit ?? HISTORY_PAGE_LIMIT));
+    const before = options.before;
+    let commits;
+    try {
+      commits = await import_isomorphic_git.default.log({
+        fs: fs5,
+        dir,
+        cache: {},
+        depth: limit + 2,
+        ...before ? { ref: before } : {},
+        ...subPath ? { filepath: subPath, force: true } : {}
+      });
+    } catch (e) {
+      if (before && e?.code === "NotFoundError") {
+        return { entries: [], hasMore: false };
+      }
+      throw e;
+    }
+    let filtered = before ? commits.filter((c) => c.oid !== before) : commits;
+    const hasMore = filtered.length > limit;
+    if (hasMore)
+      filtered = filtered.slice(0, limit);
     return {
-      id: id2,
-      message: options.message,
-      timestamp: Date.now(),
-      author: author.name
+      entries: filtered.map((c) => ({
+        id: c.oid,
+        message: c.commit.message.trim(),
+        timestamp: c.commit.author.timestamp * 1000,
+        author: c.commit.author.name
+      })),
+      hasMore
     };
   }
-  async listHistory(projectDir) {
-    const commits = await import_isomorphic_git.default.log({ fs: fs5, dir: projectDir });
-    return commits.map((c) => ({
-      id: c.oid,
-      message: c.commit.message.trim(),
-      timestamp: c.commit.author.timestamp * 1000,
-      author: c.commit.author.name
-    }));
+  restore(options) {
+    return withRepoLock(this.scope.dir, () => this.restoreUnlocked(options));
   }
-  async restore(options) {
+  async restoreUnlocked(options) {
+    const { dir, subPath } = this.scope;
     await import_isomorphic_git.default.checkout({
       fs: fs5,
-      dir: options.projectDir,
+      dir,
+      cache: {},
       ref: options.id,
       force: true,
-      noUpdateHead: true
+      noUpdateHead: true,
+      ...subPath ? { filepaths: [subPath] } : {}
     });
   }
 }
+async function snapshotWorkingTreeUnlocked(options) {
+  const dir = options.repoRoot ?? options.projectDir;
+  const subPath = options.subPath || undefined;
+  const cache2 = {};
+  if (!await hasPendingChanges(dir, subPath, cache2)) {
+    throw new Error("No changes since the last snapshot — there is nothing new to save.");
+  }
+  await stageAll(dir, subPath, cache2);
+  const author = gitAuthor(options.authorName);
+  const id2 = await import_isomorphic_git.default.commit({
+    fs: fs5,
+    dir,
+    cache: cache2,
+    message: options.message,
+    author
+  });
+  const [head] = await import_isomorphic_git.default.log({ fs: fs5, dir, cache: cache2, depth: 1 });
+  return {
+    id: id2,
+    message: options.message,
+    timestamp: head ? head.commit.author.timestamp * 1000 : Date.now(),
+    author: author.name
+  };
+}
+function isNoChangesError(e) {
+  return e instanceof Error && /no changes since the last snapshot/i.test(e.message);
+}
 function providerFor(source) {
   switch (source.type) {
     case "local-folder":
@@ -107710,18 +107977,58 @@ function providerFor(source) {
   }
 }
 function gitDirFor(projectDir) {
-  return path9.join(projectDir, ".git");
+  return path10.join(projectDir, ".git");
 }
-var import_isomorphic_git, DEFAULT_AUTHOR = "print-md", DEFAULT_EMAIL = "noreply@print-md.local", DEFAULT_BRANCH = "main";
+function autoSnapshotDelayMs(policy) {
+  const enabled = policy?.autoSnapshot ?? true;
+  if (!enabled)
+    return null;
+  const raw = policy?.autoSnapshotMinutes;
+  const minutes = typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? raw : AUTO_SNAPSHOT_DEFAULT_MINUTES;
+  const clamped = Math.min(AUTO_SNAPSHOT_MAX_MINUTES, Math.max(AUTO_SNAPSHOT_MIN_MINUTES, minutes));
+  return clamped * 60000;
+}
+function isGitInternalPath(p10) {
+  return p10.split(/[\\/]+/).some((segment) => segment === ".git");
+}
+async function restoreVersionWithBackup(options) {
+  const { projectDir, id: id2, authorName } = options;
+  const source = await detectProjectSource(projectDir);
+  if (source.type !== "local-git-folder") {
+    throw new Error("This project has no version history yet. Enable version history first.");
+  }
+  const provider = new LocalGitSourceProvider(source);
+  const scope = gitScopeFor(source);
+  return withRepoLock(scope.dir, async () => {
+    let backupId;
+    if (await hasPendingChanges(scope.dir, scope.subPath || undefined)) {
+      const backup = await provider.snapshotUnlocked({
+        projectDir,
+        message: RESTORE_BACKUP_MESSAGE,
+        authorName
+      });
+      backupId = backup.id;
+    }
+    try {
+      await provider.restoreUnlocked({ projectDir, id: id2 });
+    } catch (cause) {
+      throw new Error(backupId ? "The restore could not be completed, but your work is safe — it was " + `automatically saved as a backup snapshot (${backupId.slice(0, 7)}) ` + "and appears in your version history." : "The restore could not be completed. Your project files were not changed.", { cause });
+    }
+    return { restoredId: id2, backupId };
+  });
+}
+var import_isomorphic_git, HISTORY_PAGE_LIMIT = 100, DEFAULT_AUTHOR = "print-md", DEFAULT_EMAIL = "noreply@print-md.local", DEFAULT_BRANCH = "main", repoQueues, RESTORE_BACKUP_MESSAGE = "Automatic backup before restoring an earlier version", AUTO_SNAPSHOT_MESSAGE = "Automatic snapshot", AUTO_SNAPSHOT_MIN_MINUTES = 5, AUTO_SNAPSHOT_MAX_MINUTES, AUTO_SNAPSHOT_DEFAULT_MINUTES = 10;
 var init_source_provider = __esm(() => {
   init_project_source();
   import_isomorphic_git = __toESM(require_isomorphic_git(), 1);
+  repoQueues = new Map;
+  AUTO_SNAPSHOT_MAX_MINUTES = 24 * 60;
 });
 
 // ../lib/src/lib/project-scaffold.ts
-import { access as access2, copyFile as copyFile2, mkdir as mkdir6, readFile as readFile21, writeFile as writeFile7 } from "node:fs/promises";
+import { access as access2, copyFile as copyFile2, mkdir as mkdir6, readFile as readFile22, writeFile as writeFile7 } from "node:fs/promises";
 import { constants as FS } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 function slugifyProjectName(name) {
   return name.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -107739,7 +108046,7 @@ async function scaffoldProject(options) {
     throw new CreateProjectErrorImpl("invalid-name", `Could not derive a valid folder name from "${name}".`);
   }
   const parentDir = options.parentDir;
-  if (!parentDir || !path10.isAbsolute(parentDir)) {
+  if (!parentDir || !path11.isAbsolute(parentDir)) {
     throw new CreateProjectErrorImpl("parent-not-writable", "The save location must be an absolute path.");
   }
   try {
@@ -107747,7 +108054,7 @@ async function scaffoldProject(options) {
   } catch {
     throw new CreateProjectErrorImpl("parent-not-writable", `The chosen save location can't be written to: ${parentDir}`);
   }
-  const projectDir = path10.join(parentDir, folderName);
+  const projectDir = path11.join(parentDir, folderName);
   let targetExists = true;
   try {
     await access2(projectDir, FS.F_OK);
@@ -107762,14 +108069,14 @@ async function scaffoldProject(options) {
     const tplManifest = await getAssetPath(`templates/${template}/manifest.yaml`);
     const tplChapter = await getAssetPath(`templates/${template}/chapter-01.md`);
     await mkdir6(projectDir, { recursive: true });
-    await mkdir6(path10.join(projectDir, "assets"), { recursive: true });
-    await copyFile2(tplManifest, path10.join(projectDir, "manifest.yaml"));
-    await copyFile2(tplChapter, path10.join(projectDir, "chapter-01.md"));
+    await mkdir6(path11.join(projectDir, "assets"), { recursive: true });
+    await copyFile2(tplManifest, path11.join(projectDir, "manifest.yaml"));
+    await copyFile2(tplChapter, path11.join(projectDir, "chapter-01.md"));
   } catch (e) {
     throw new CreateProjectErrorImpl("scaffold-io", `Could not create the project files: ${e instanceof Error ? e.message : String(e)}`);
   }
-  const manifestPath = path10.join(projectDir, "manifest.yaml");
-  const openFile = path10.join(projectDir, "chapter-01.md");
+  const manifestPath = path11.join(projectDir, "manifest.yaml");
+  const openFile = path11.join(projectDir, "chapter-01.md");
   const author = (options.author ?? "").trim() || DEFAULT_AUTHOR2;
   const outputPdf = `${slug}.pdf`;
   const substitutions = {
@@ -107813,7 +108120,7 @@ async function scaffoldProject(options) {
   return result;
 }
 async function fillTemplateFile(filePath2, substitutions) {
-  let text4 = await readFile21(filePath2, "utf8");
+  let text4 = await readFile22(filePath2, "utf8");
   for (const [token, value] of Object.entries(substitutions)) {
     text4 = text4.split(token).join(value);
   }
@@ -107832,6 +108139,119 @@ var init_project_scaffold = __esm(() => {
   };
 });
 
+// ../lib/src/lib/remote-auth/token-store.ts
+import { chmod, mkdir as mkdir7, readFile as readFile23, writeFile as writeFile8 } from "node:fs/promises";
+import os4 from "node:os";
+import path12 from "node:path";
+function defaultConfigDir() {
+  const override = process.env.PRINT_MD_CONFIG_DIR?.trim();
+  if (override)
+    return override;
+  if (process.platform === "win32" && process.env.APPDATA) {
+    return path12.join(process.env.APPDATA, "print-md");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME?.trim();
+  return path12.join(xdg || path12.join(os4.homedir(), ".config"), "print-md");
+}
+
+class FileTokenStore {
+  filePath;
+  queue = Promise.resolve();
+  constructor(filePath2) {
+    this.filePath = filePath2 ?? path12.join(defaultConfigDir(), "credentials.json");
+  }
+  async read() {
+    try {
+      const raw = await readFile23(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && parsed.credentials)
+        return parsed;
+    } catch {}
+    return { version: 1, credentials: {} };
+  }
+  async write(data) {
+    await mkdir7(path12.dirname(this.filePath), { recursive: true });
+    await writeFile8(this.filePath, JSON.stringify(data, null, 2), {
+      encoding: "utf8",
+      mode: 384
+    });
+    await chmod(this.filePath, 384);
+  }
+  enqueue(fn2) {
+    const run2 = this.queue.then(fn2, fn2);
+    this.queue = run2.catch(() => {
+      return;
+    });
+    return run2;
+  }
+  get(host) {
+    return this.enqueue(async () => {
+      const data = await this.read();
+      return data.credentials[normalizeHost(host)] ?? null;
+    });
+  }
+  set(host, credential) {
+    return this.enqueue(async () => {
+      const data = await this.read();
+      data.credentials[normalizeHost(host)] = credential;
+      await this.write(data);
+    });
+  }
+  delete(host) {
+    return this.enqueue(async () => {
+      const data = await this.read();
+      delete data.credentials[normalizeHost(host)];
+      await this.write(data);
+    });
+  }
+  list() {
+    return this.enqueue(async () => {
+      const data = await this.read();
+      return Object.values(data.credentials);
+    });
+  }
+}
+function normalizeHost(host) {
+  return host.trim().toLowerCase();
+}
+var init_token_store = () => {};
+// ../lib/src/lib/remote-auth/github-repos.ts
+var init_github_repos = () => {};
+
+// ../lib/src/lib/remote-auth/clone.ts
+var init_clone = __esm(() => {
+  init_source_provider();
+  init_token_store();
+});
+
+// ../lib/src/lib/remote-auth/test-access.ts
+var init_test_access = __esm(() => {
+  init_token_store();
+});
+
+// ../lib/src/lib/remote-auth/generic-auth.ts
+var init_generic_auth = __esm(() => {
+  init_test_access();
+});
+
+// ../lib/src/lib/remote-auth/diagnose.ts
+var init_diagnose = __esm(() => {
+  init_project_source();
+  init_generic_auth();
+  init_test_access();
+  init_token_store();
+});
+
+// ../lib/src/lib/remote-auth/sync.ts
+var import_diff3;
+var init_sync = __esm(() => {
+  init_project_source();
+  init_clone();
+  init_source_provider();
+  init_token_store();
+  import_diff3 = __toESM(require_diff3(), 1);
+});
+
 // ../lib/src/api/index.ts
 var init_api = __esm(() => {
   init_build_runner();
@@ -107841,6 +108261,13 @@ var init_api = __esm(() => {
   init_project_source();
   init_project_scaffold();
   init_source_provider();
+  init_token_store();
+  init_github_repos();
+  init_clone();
+  init_test_access();
+  init_generic_auth();
+  init_diagnose();
+  init_sync();
 });
 
 // ../lib/src/index.ts
@@ -107854,6 +108281,7 @@ var init_src = __esm(() => {
   init_tool_check();
   init_registry();
   init_manifest();
+  init_image_inspect();
   init_printsafe();
   init_printsafe();
   init_api();
@@ -107936,7 +108364,7 @@ __export(exports_preview, {
   default: () => preview_default
 });
 import { defineCommand as defineCommand2 } from "citty";
-import path11 from "node:path";
+import path13 from "node:path";
 import fs6 from "node:fs";
 function resolvePort(raw) {
   if (raw === undefined || raw === "")
@@ -107992,7 +108420,7 @@ var init_preview = __esm(() => {
       "skip-post-validate": { type: "boolean", description: "Skip post-build PDF/X validation (pdfx only)" }
     },
     async run({ args }) {
-      const inputPath = args.input ? path11.resolve(args.input) : undefined;
+      const inputPath = args.input ? path13.resolve(args.input) : undefined;
       if (inputPath !== undefined) {
         if (!fs6.existsSync(inputPath) || !fs6.statSync(inputPath).isDirectory()) {
           log.error(`Input directory does not exist: ${inputPath}`);
@@ -108055,7 +108483,7 @@ __export(exports_build, {
   default: () => build_default
 });
 import { defineCommand as defineCommand3 } from "citty";
-import path12 from "node:path";
+import path14 from "node:path";
 function parseFormat2(raw) {
   if (raw === undefined || raw === "")
     return "pdf";
@@ -108103,7 +108531,7 @@ var init_build = __esm(() => {
       const { outDir, pdfFileOverride } = splitOutPath(typeof args.out === "string" ? args.out : undefined, format);
       try {
         await runBuild({
-          inputDir: path12.resolve(args.input ?? "."),
+          inputDir: path14.resolve(args.input ?? "."),
           format,
           outDir,
           pdfFileOverride,
@@ -108300,7 +108728,7 @@ __export(exports_preflight, {
   buildPreflightPayload: () => buildPreflightPayload
 });
 import { defineCommand as defineCommand7 } from "citty";
-import { mkdir as mkdir7, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir8, writeFile as writeFile9 } from "node:fs/promises";
 import { basename as basename3, dirname as dirname6, extname, join as join10, resolve as resolve15 } from "node:path";
 function computeStatus(errors, warnings, missingTools, skippedRequired) {
   if (errors > 0 || skippedRequired)
@@ -108476,10 +108904,10 @@ var init_preflight = __esm(() => {
       const baseName = typeof args.name === "string" && args.name.trim().length > 0 ? args.name.trim() : defaultReportName(pdfPath);
       const jsonPath = join10(reportDir, `${baseName}.json`);
       const markdownPath = join10(reportDir, `${baseName}.md`);
-      await mkdir7(reportDir, { recursive: true });
-      await writeFile8(jsonPath, `${JSON.stringify(payload, null, 2)}
+      await mkdir8(reportDir, { recursive: true });
+      await writeFile9(jsonPath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
-      await writeFile8(markdownPath, toPreflightMarkdown(payload), "utf8");
+      await writeFile9(markdownPath, toPreflightMarkdown(payload), "utf8");
       log.info(`Preflight status: ${payload.status}`);
       log.info(`JSON report: ${jsonPath}`);
       log.info(`Markdown report: ${markdownPath}`);
@@ -108501,7 +108929,7 @@ var SUBCOMMANDS = {
   audit: () => Promise.resolve().then(() => (init_audit(), exports_audit)).then((m) => m.default),
   preflight: () => Promise.resolve().then(() => (init_preflight(), exports_preflight)).then((m) => m.default)
 };
-var VERSION = "0.4.1";
+var VERSION = "0.5.0-rc.10";
 var main = defineCommand8({
   meta: {
     name: "print-md",