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

package/dist/cli.js

@@ -22693,7 +22693,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.1",
     private: true,
     type: "module",
     main: "dist/index.js",
@@ -22724,6 +22724,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",
@@ -94379,6 +94380,69 @@ var init_diagnostics = __esm(() => {
 });
 
 // ../lib/src/lib/project-source.ts
+import { stat as stat5, readFile as readFile21 } from "node:fs/promises";
+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 detectProjectSource(folderPath) {
+  const gitDir = path9.join(folderPath, ".git");
+  if (!await isDirectory2(gitDir)) {
+    return { type: "local-folder", path: folderPath };
+  }
+  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 {
+    type: "local-git-folder",
+    path: folderPath,
+    hasRemote: remoteUrl !== undefined,
+    ...remoteUrl !== undefined ? { remoteUrl } : {},
+    ...branch !== undefined ? { branch } : {}
+  };
+}
 function capabilitiesFor(source) {
   switch (source.type) {
     case "local-folder":
@@ -96412,20 +96476,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 +96532,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 +96540,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 +96552,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 +96592,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 +96629,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 +96659,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 +96669,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 +96727,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 +96741,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 +97371,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 +97426,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 +97476,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 +97827,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 +97869,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 +97884,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 +98005,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 +98045,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 +98069,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 +98080,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 +98453,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 +98514,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 +100099,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 +100301,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 +100574,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 +100590,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 +100836,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 +102128,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 +102144,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 +102160,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 +102176,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 +102185,7 @@ gpgsig`));
               return mergeBlobs({
                 fs: fs5,
                 gitdir,
-                path: path9,
+                path: path10,
                 ours,
                 base,
                 theirs,
@@ -102167,7 +102231,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 +102248,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 +102288,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 +102305,7 @@ gpgsig`));
   async function mergeBlobs({
     fs: fs5,
     gitdir,
-    path: path9,
+    path: path10,
     ours,
     base,
     theirs,
@@ -102264,19 +102328,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 +102348,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 +102357,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 +103061,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 +103071,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 +104528,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 +106593,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 +106901,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 +107056,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 +107073,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,11 +107661,26 @@ 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
+  hasPendingChanges: () => hasPendingChanges,
+  gitDirFor: () => gitDirFor,
+  gitAuthor: () => gitAuthor,
+  RESTORE_BACKUP_MESSAGE: () => RESTORE_BACKUP_MESSAGE
 });
 import * as fs5 from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
+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 };
@@ -107610,6 +107689,10 @@ 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 hasPendingChanges(dir) {
+  const status = await import_isomorphic_git.default.statusMatrix({ fs: fs5, dir });
+  return status.some(([, head, worktree, stage]) => !(head === 1 && worktree === 1 && stage === 1));
+}
 
 class LocalFolderSourceProvider {
   source;
@@ -107618,22 +107701,24 @@ class LocalFolderSourceProvider {
     this.source = source;
     this.capabilities = capabilitiesFor(source);
   }
-  async initVersionHistory(options) {
+  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)
+    return withRepoLock(dir, async () => {
+      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)
+      });
+      return {
+        type: "local-git-folder",
+        path: dir,
+        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."));
@@ -107654,42 +107739,39 @@ class LocalGitSourceProvider {
     this.capabilities = capabilitiesFor(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(options.projectDir, () => this.snapshotUnlocked(options));
+  }
+  snapshotUnlocked(options) {
+    return snapshotWorkingTreeUnlocked(options);
+  }
+  listHistory(projectDir) {
+    return withRepoLock(projectDir, async () => {
+      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
+      }));
     });
-    return {
-      id: id2,
-      message: options.message,
-      timestamp: Date.now(),
-      author: author.name
-    };
-  }
-  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
-    }));
   }
-  async restore(options) {
+  restore(options) {
+    return withRepoLock(options.projectDir, () => this.restoreUnlocked(options));
+  }
+  async restoreUnlocked(options) {
     await import_isomorphic_git.default.checkout({
       fs: fs5,
       dir: options.projectDir,
@@ -107699,6 +107781,30 @@ class LocalGitSourceProvider {
     });
   }
 }
+async function snapshotWorkingTreeUnlocked(options) {
+  const dir = options.projectDir;
+  if (!await hasPendingChanges(dir)) {
+    throw new Error("No changes since the last snapshot — there is nothing new to save.");
+  }
+  await stageAll(dir);
+  const author = gitAuthor(options.authorName);
+  const id2 = await import_isomorphic_git.default.commit({
+    fs: fs5,
+    dir,
+    message: options.message,
+    author
+  });
+  const [head] = await import_isomorphic_git.default.log({ fs: fs5, dir, 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 +107816,44 @@ function providerFor(source) {
   }
 }
 function gitDirFor(projectDir) {
-  return path9.join(projectDir, ".git");
+  return path10.join(projectDir, ".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);
+  return withRepoLock(projectDir, async () => {
+    let backupId;
+    if (await hasPendingChanges(projectDir)) {
+      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, DEFAULT_AUTHOR = "print-md", DEFAULT_EMAIL = "noreply@print-md.local", DEFAULT_BRANCH = "main";
+var import_isomorphic_git, DEFAULT_AUTHOR = "print-md", DEFAULT_EMAIL = "noreply@print-md.local", DEFAULT_BRANCH = "main", repoQueues, RESTORE_BACKUP_MESSAGE = "Automatic backup before restoring an earlier version";
 var init_source_provider = __esm(() => {
   init_project_source();
   import_isomorphic_git = __toESM(require_isomorphic_git(), 1);
+  repoQueues = new Map;
 });
 
 // ../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 +107871,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 +107879,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 +107894,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 +107945,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 +107964,117 @@ 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 os3 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(os3.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/publish.ts
+var import_diff3;
+var init_publish = __esm(() => {
+  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 +108084,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_publish();
 });
 
 // ../lib/src/index.ts
@@ -107936,7 +108186,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 +108242,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 +108305,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 +108353,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 +108550,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 +108726,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 +108751,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.1";
 var main = defineCommand8({
   meta: {
     name: "print-md",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dimm-city/print-md",
-  "version": "0.4.1",
+  "version": "0.5.0-rc.1",
   "description": "Markdown-to-PDF converter for professional print layout using Paged.js and Ghostscript.",
   "author": "itlackey",
   "license": "MPL-2.0",