gutterpress 0.11.6-alpha.2 → 0.11.6-alpha.4

package/dist/cli-4tx0szk7.js

@@ -0,0 +1,1251 @@
+import {
+  capabilitiesFor,
+  detectProjectSource,
+  findEnclosingRepoDir
+} from "./cli-v5mp7a6q.js";
+
+// src/lib/git-fs.ts
+import * as nodeFs from "node:fs";
+var MUTABLE_GIT_METADATA = /(?:^|[\\/])\.git[\\/](?:index|HEAD|packed-refs|refs[\\/].+)$/;
+function needsAtomicWrite(file) {
+  return typeof file === "string" && MUTABLE_GIT_METADATA.test(file);
+}
+var tempCounter = 0;
+function tempPathFor(file) {
+  return `${file}.gp${process.pid.toString(36)}-${(tempCounter++).toString(36)}.tmp`;
+}
+function writeFile2(file, data, options, callback) {
+  const cb = typeof options === "function" ? options : callback;
+  const opts = typeof options === "function" ? undefined : options;
+  if (!needsAtomicWrite(file)) {
+    nodeFs.writeFile(file, data, opts, cb);
+    return;
+  }
+  const temp = tempPathFor(file);
+  const failed = (err) => nodeFs.unlink(temp, () => cb(err));
+  nodeFs.writeFile(temp, data, opts, (writeErr) => {
+    if (writeErr)
+      return failed(writeErr);
+    nodeFs.rename(temp, file, (renameErr) => {
+      if (renameErr)
+        return failed(renameErr);
+      cb(null);
+    });
+  });
+}
+async function writeFilePromise(file, data, options) {
+  if (!needsAtomicWrite(file)) {
+    return nodeFs.promises.writeFile(file, data, options);
+  }
+  const temp = tempPathFor(file);
+  try {
+    await nodeFs.promises.writeFile(temp, data, options);
+    await nodeFs.promises.rename(temp, file);
+  } catch (err) {
+    await nodeFs.promises.unlink(temp).catch(() => {});
+    throw err;
+  }
+}
+var promises2 = {
+  ...nodeFs.promises,
+  writeFile: writeFilePromise
+};
+var gitFs = {
+  ...nodeFs,
+  writeFile: writeFile2,
+  promises: promises2
+};
+
+// src/lib/source-provider.ts
+import path3 from "node:path";
+import git from "isomorphic-git";
+
+// src/lib/remote-auth/operation-log.ts
+import { appendFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+function sanitizeLogText(value, secrets = []) {
+  let text = value;
+  for (const secret of secrets) {
+    if (!secret)
+      continue;
+    for (const form of [secret, encodeURIComponent(secret)]) {
+      text = text.split(form).join("[redacted]");
+    }
+  }
+  return text.replace(/\/\/[^/\s]*@/g, "//").replace(/([?&](?:access_token|token|password|secret|key|code)=)[^&#\s]*/gi, "$1[redacted]").replace(/\b(Bearer|Basic)\s+[A-Za-z0-9+/_.=~-]+/gi, "$1 [redacted]").replace(/\b(?:gh[pousr]_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+)/g, "[redacted]").replace(/[\s\x00-\x1f\x7f]+/g, " ").trim().slice(0, 6000);
+}
+var noop = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+function createFileLogger(logFile, operation, minLevel = "debug", options = {}) {
+  try {
+    mkdirSync(path.dirname(logFile), { recursive: true });
+  } catch {
+    return noop;
+  }
+  function write(level, step, message, data) {
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[minLevel])
+      return;
+    const ts = new Date().toISOString();
+    const clean = (value) => sanitizeLogText(value, options.secrets);
+    const fields = formatData({ ...options.context, ...data }, clean);
+    const line = `[${ts}] ${level.toUpperCase().padEnd(5)} ${clean(operation)}: step=${clean(step)}${fields} | ${clean(message)}
+`;
+    try {
+      appendFileSync(logFile, line, "utf8");
+    } catch {}
+  }
+  return {
+    debug: (step, message, data) => write("debug", step, message, data),
+    info: (step, message, data) => write("info", step, message, data),
+    warn: (step, message, data) => write("warn", step, message, data),
+    error: (step, message, data) => write("error", step, message, data)
+  };
+}
+function formatData(data, clean) {
+  if (!data)
+    return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(data)) {
+    if (value === undefined)
+      continue;
+    if (Array.isArray(value)) {
+      parts.push(`${clean(key)}=${clean(value.join(","))}`);
+    } else {
+      parts.push(`${clean(key)}=${clean(String(value))}`);
+    }
+  }
+  return parts.length > 0 ? " " + parts.join(" ") : "";
+}
+
+// src/lib/plugin-vendor.ts
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { lstat, readFile, readdir, realpath } from "node:fs/promises";
+import path2 from "node:path";
+import { exports as resolveExports } from "resolve.exports";
+import { satisfies, validRange } from "semver";
+
+// src/lib/npm-registry.ts
+var DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org";
+var ENV_OVERRIDE = "GUTTERPRESS_NPM_REGISTRY";
+function npmRegistryUrl() {
+  const configured = process.env[ENV_OVERRIDE]?.trim();
+  if (!configured)
+    return DEFAULT_NPM_REGISTRY;
+  let scheme;
+  try {
+    scheme = new URL(configured).protocol;
+  } catch {
+    throw new Error(`Invalid ${ENV_OVERRIDE} URL "${configured}".`);
+  }
+  if (scheme !== "http:" && scheme !== "https:") {
+    throw new Error(`${ENV_OVERRIDE} must be an http(s) URL — got "${scheme}".`);
+  }
+  return configured.replace(/\/+$/, "");
+}
+
+// src/lib/plugin-vendor.ts
+var PLUGINS_DIR = "plugins";
+var VENDORED_NPM_DIR = "npm";
+var VENDOR_RECEIPT_FILE = ".gutterpress-install.json";
+var VENDOR_RECEIPT_VERSION = 2;
+var NPM_SEGMENT = /^[a-z0-9][a-z0-9._~-]*$/;
+var EXACT_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var WINDOWS_RESERVED = /^(con|prn|aux|nul|clock\$|conin\$|conout\$|com[1-9¹²³]|lpt[1-9¹²³])(?:\..*)?$/i;
+var MAX_VERIFIED_FILES = 50000;
+var MAX_VERIFIED_BYTES = 512 * 1024 * 1024;
+function isValidNpmPackageName(name) {
+  if (!name || name.length > 214 || name !== name.toLowerCase())
+    return false;
+  if (name.startsWith("@")) {
+    const parts = name.slice(1).split("/");
+    return parts.length === 2 && parts.every((part) => NPM_SEGMENT.test(part));
+  }
+  return !name.includes("/") && NPM_SEGMENT.test(name);
+}
+function parseNpmPluginSpec(input) {
+  const spec = input.trim();
+  if (!spec)
+    throw new Error("An npm package name is required.");
+  let name = spec;
+  let selector;
+  if (spec.startsWith("@")) {
+    const slash = spec.indexOf("/");
+    const versionAt = spec.lastIndexOf("@");
+    if (slash > 1 && versionAt > slash) {
+      name = spec.slice(0, versionAt);
+      selector = spec.slice(versionAt + 1);
+    }
+  } else {
+    const versionAt = spec.lastIndexOf("@");
+    if (versionAt > 0) {
+      name = spec.slice(0, versionAt);
+      selector = spec.slice(versionAt + 1);
+    }
+  }
+  if (!isValidNpmPackageName(name)) {
+    throw new Error(`"${name}" is not a valid npm package name. Use a name like ` + "markdown-it-highlightjs or @scope/markdown-it-plugin.");
+  }
+  if (selector !== undefined && !selector) {
+    throw new Error(`The package spec "${spec}" is missing a selector after @.`);
+  }
+  return selector === undefined ? { name } : { name, selector };
+}
+function isExactNpmVersion(version) {
+  return EXACT_VERSION.test(version);
+}
+function encodePathPart(value) {
+  return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function vendoredNpmPluginRoot(projectDir, name, version) {
+  return path2.join(projectDir, PLUGINS_DIR, VENDORED_NPM_DIR, encodePathPart(name), encodePathPart(version));
+}
+function vendoredNpmPluginPackageDir(installRoot, name) {
+  return path2.join(installRoot, "node_modules", ...name.split("/"));
+}
+function toPosixPath(value) {
+  return value.split(path2.sep).join("/");
+}
+function packageEntryFormat(manifest, relativeEntry) {
+  const extension = path2.posix.extname(relativeEntry);
+  return extension === ".cjs" || extension === ".json" || extension !== ".mjs" && manifest.type !== "module" ? "commonjs" : "module";
+}
+function assertWindowsSafeRelativePath(relative) {
+  if (!relative || relative.includes("\\") || relative.startsWith("/") || /^[a-zA-Z]:/.test(relative)) {
+    throw new Error(`Unsafe package path: ${relative || "(empty)"}`);
+  }
+  const normalized = relative.normalize("NFKC");
+  const parts = normalized.split("/");
+  if (parts.some((part) => !part || part === "." || part === "..")) {
+    throw new Error(`Unsafe package path: ${relative}`);
+  }
+  for (const part of parts) {
+    if (part.length > 255 || /[\u0000-\u001f<>:"|?*]/.test(part) || part.endsWith(".") || part.endsWith(" ") || WINDOWS_RESERVED.test(part)) {
+      throw new Error(`Package path is invalid on Windows: ${relative}`);
+    }
+  }
+}
+function windowsPathKey(relative) {
+  return relative.normalize("NFKC").toLowerCase();
+}
+function safeReceiptPath(relative, label) {
+  if (typeof relative !== "string")
+    throw new Error(`${label} must be a string.`);
+  assertWindowsSafeRelativePath(relative);
+  return relative;
+}
+function isContained(root, candidate) {
+  const relative = path2.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
+}
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringMap(value) {
+  const map = object(value);
+  if (!map)
+    return {};
+  const result = {};
+  for (const [name, selector] of Object.entries(map)) {
+    if (typeof selector === "string" && selector.trim())
+      result[name] = selector.trim();
+  }
+  return result;
+}
+function dependencyDeclarations(manifest) {
+  const required = stringMap(manifest.dependencies);
+  const optional = stringMap(manifest.optionalDependencies);
+  for (const name of Object.keys(optional))
+    delete required[name];
+  const peers = stringMap(manifest.peerDependencies);
+  const peerMeta = object(manifest.peerDependenciesMeta) ?? {};
+  const optionalPeers = {};
+  for (const [name, selector] of Object.entries(peers)) {
+    if (name in required || name in optional)
+      continue;
+    if (object(peerMeta[name])?.optional === true)
+      optionalPeers[name] = selector;
+    else
+      required[name] = selector;
+  }
+  return { required, optional, optionalPeers };
+}
+function unsupportedRegistrySelector(selector) {
+  return /^(?:file:|git\+|https?:|ssh:|github:|workspace:|link:|npm:)/i.test(selector);
+}
+async function readPackageJson(packageDir) {
+  const packageJsonPath = path2.join(packageDir, "package.json");
+  const info = await lstat(packageJsonPath);
+  if (!info.isFile() || info.isSymbolicLink()) {
+    throw new Error(`Package metadata is not a regular file: ${packageJsonPath}`);
+  }
+  const parsed = object(JSON.parse(await readFile(packageJsonPath, "utf8")));
+  if (!parsed)
+    throw new Error(`Package metadata is not an object: ${packageJsonPath}`);
+  return parsed;
+}
+async function verifyReceiptEntry(installRoot, packagePath, entry, label) {
+  if (entry === undefined)
+    return;
+  const relative = safeReceiptPath(entry, label);
+  if (!relative.startsWith(`${packagePath}/`)) {
+    throw new Error(`${label} is outside its package.`);
+  }
+  const packageDir = path2.resolve(installRoot, ...packagePath.split("/"));
+  const entryPath = path2.resolve(installRoot, ...relative.split("/"));
+  const [realPackageDir, realEntry] = await Promise.all([
+    realpath(packageDir),
+    realpath(entryPath)
+  ]);
+  if (!isContained(realPackageDir, realEntry))
+    throw new Error(`${label} escapes its package.`);
+  const info = await lstat(realEntry);
+  if (!info.isFile() || info.isSymbolicLink())
+    throw new Error(`${label} is not a regular file.`);
+  return realEntry;
+}
+function packageResolutionTargets(manifest, subpath, condition) {
+  if (manifest.exports !== undefined) {
+    try {
+      const targets2 = resolveExports(manifest, subpath ? `./${subpath}` : ".", { require: condition === "require" }) ?? [];
+      return targets2.map((target) => ({ target, exact: true }));
+    } catch {
+      return [];
+    }
+  }
+  if (subpath)
+    return [{ target: subpath, exact: false }];
+  const targets = [
+    ...condition === "import" && typeof manifest.module === "string" ? [manifest.module] : [],
+    ...typeof manifest.main === "string" ? [manifest.main] : [],
+    "index.mjs",
+    "index.js",
+    "index.cjs"
+  ];
+  return [...new Set(targets)].map((target) => ({ target, exact: false }));
+}
+function safePackageTarget(target) {
+  if (!target || target.includes("\\") || target.includes("*") || target.includes("?") || target.includes("#")) {
+    return null;
+  }
+  const relative = target.startsWith("./") ? target.slice(2) : target;
+  if (!relative || path2.isAbsolute(relative))
+    return null;
+  assertWindowsSafeRelativePath(relative);
+  if (relative.normalize("NFKC").split("/").some((part) => part.toLowerCase() === "node_modules")) {
+    return null;
+  }
+  return relative;
+}
+async function resolveEntryCandidate(packageDir, resolution) {
+  const relative = safePackageTarget(resolution.target);
+  if (!relative)
+    return null;
+  const base = path2.resolve(packageDir, ...relative.split("/"));
+  if (!isContained(packageDir, base))
+    return null;
+  const candidates = resolution.exact ? [base] : [
+    base,
+    `${base}.mjs`,
+    `${base}.js`,
+    `${base}.cjs`,
+    `${base}.json`,
+    path2.join(base, "index.mjs"),
+    path2.join(base, "index.js"),
+    path2.join(base, "index.cjs"),
+    path2.join(base, "index.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const info = await lstat(candidate);
+      if (!info.isFile() || info.isSymbolicLink())
+        continue;
+      const extension = path2.extname(candidate);
+      if (extension && ![".js", ".mjs", ".cjs", ".json"].includes(extension))
+        continue;
+      const [realRoot, realCandidate] = await Promise.all([realpath(packageDir), realpath(candidate)]);
+      if (!isContained(realRoot, realCandidate))
+        continue;
+      return toPosixPath(path2.relative(packageDir, realCandidate));
+    } catch {}
+  }
+  return null;
+}
+async function resolvePackageEntry(packageDir, packageJson, condition = "import") {
+  const manifest = packageJson ?? await readPackageJson(packageDir);
+  for (const target of packageResolutionTargets(manifest, "", condition)) {
+    const resolved = await resolveEntryCandidate(packageDir, target);
+    if (resolved)
+      return resolved;
+  }
+  throw new Error("Package has no contained JavaScript entry point for ESM import.");
+}
+async function listTreeEntries(root) {
+  const out = [];
+  async function visit(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const absolute = path2.join(dir, entry.name);
+      const relative = toPosixPath(path2.relative(root, absolute));
+      if (relative === VENDOR_RECEIPT_FILE)
+        continue;
+      if (entry.isSymbolicLink())
+        throw new Error(`Vendor tree contains a symbolic link: ${relative}`);
+      if (entry.isDirectory()) {
+        out.push({ relative, directory: true });
+        await visit(absolute);
+      } else if (entry.isFile())
+        out.push({ relative, directory: false });
+      else
+        throw new Error(`Vendor tree contains an unsupported filesystem entry: ${relative}`);
+    }
+  }
+  await visit(root);
+  return out;
+}
+async function computeVendorTreeDigest(root) {
+  const entries = await listTreeEntries(root);
+  const files = entries.filter((entry) => !entry.directory);
+  if (files.length > MAX_VERIFIED_FILES) {
+    throw new Error(`Vendor tree contains more than ${MAX_VERIFIED_FILES} files.`);
+  }
+  const seen = new Set;
+  const hash = createHash("sha256");
+  let bytes = 0;
+  for (const entry of entries) {
+    const { relative } = entry;
+    assertWindowsSafeRelativePath(relative);
+    const key = windowsPathKey(relative);
+    if (seen.has(key))
+      throw new Error(`Vendor tree has a Windows-colliding path: ${relative}`);
+    seen.add(key);
+    if (entry.directory)
+      continue;
+    const absolute = path2.join(root, ...relative.split("/"));
+    const info = await lstat(absolute);
+    if (!info.isFile() || info.isSymbolicLink() || info.nlink !== 1) {
+      throw new Error(`Vendor tree file is not an independent regular file: ${relative}`);
+    }
+    bytes += info.size;
+    if (bytes > MAX_VERIFIED_BYTES) {
+      throw new Error(`Vendor tree exceeds ${Math.round(MAX_VERIFIED_BYTES / 1024 / 1024)}MB.`);
+    }
+    hash.update(`${Buffer.byteLength(relative)}:${relative}:${info.size}\x00`);
+    for await (const chunk of createReadStream(absolute))
+      hash.update(chunk);
+  }
+  return { digest: hash.digest("hex"), files: files.length, bytes };
+}
+async function assertVendorPackageOwnership(root, packagePaths) {
+  const packages = packagePaths.map((relative) => ({
+    relative,
+    key: windowsPathKey(relative),
+    parts: relative.split("/").length
+  })).sort((a, b) => b.key.length - a.key.length);
+  for (const entry of await listTreeEntries(root)) {
+    const actualParts = entry.relative.split("/");
+    for (const part of actualParts) {
+      if (part.normalize("NFKC").toLowerCase() === "node_modules" && part !== "node_modules") {
+        throw new Error(`Vendor tree contains a non-canonical node_modules path: ${entry.relative}`);
+      }
+    }
+    const key = windowsPathKey(entry.relative);
+    const structural = packages.some((pkg) => pkg.key === key || pkg.key.startsWith(`${key}/`));
+    if (entry.directory && structural)
+      continue;
+    const owner = packages.find((pkg) => key.startsWith(`${pkg.key}/`));
+    if (!owner)
+      throw new Error(`Vendor tree path is not owned by a receipt package: ${entry.relative}`);
+    const packageRelative = actualParts.slice(owner.parts);
+    const nodeModulesAt = packageRelative.findIndex((part) => part.normalize("NFKC").toLowerCase() === "node_modules");
+    if (nodeModulesAt < 0)
+      continue;
+    const generatedEmptyDirectory = entry.directory && nodeModulesAt === 0 && (packageRelative.length === 1 || packageRelative.length === 2 && packageRelative[1].startsWith("@"));
+    if (!generatedEmptyDirectory) {
+      throw new Error(`Package contains bundled node_modules content: ${entry.relative}`);
+    }
+  }
+}
+async function recomputeReceiptEntry(packageDir, packagePath, manifest, condition) {
+  try {
+    const entry = await resolvePackageEntry(packageDir, manifest, condition);
+    return `${packagePath}/${entry}`;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("no contained JavaScript entry point")) {
+      return;
+    }
+    throw error;
+  }
+}
+async function resolveVendoredPluginInstallRoot(projectDir, expectedName, expectedVersion) {
+  const requestedProjectRoot = path2.resolve(projectDir);
+  const requestedInstallRoot = vendoredNpmPluginRoot(requestedProjectRoot, expectedName, expectedVersion);
+  let installInfo;
+  try {
+    installInfo = await lstat(requestedInstallRoot);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  if (!installInfo.isDirectory() || installInfo.isSymbolicLink()) {
+    throw new Error("Vendor install root is not a normal directory.");
+  }
+  const [realProjectRoot, installRoot] = await Promise.all([
+    realpath(requestedProjectRoot),
+    realpath(requestedInstallRoot)
+  ]);
+  if (!isContained(realProjectRoot, installRoot)) {
+    throw new Error("Vendor install root resolves outside the book folder.");
+  }
+  return installRoot;
+}
+function reconcileReceiptGraph(receipt, packages, manifests) {
+  if (!Array.isArray(receipt.skipped))
+    throw new Error("Vendor receipt skipped list is invalid.");
+  const declarations = new Map;
+  for (const [packagePath, manifest] of manifests) {
+    declarations.set(packagePath, dependencyDeclarations(manifest));
+  }
+  const skippedByEdge = new Map;
+  for (const skipped of receipt.skipped) {
+    if (!packages.has(skipped.from) || !isValidNpmPackageName(skipped.name) || typeof skipped.selector !== "string" || !["optional", "optional-peer"].includes(skipped.kind) || typeof skipped.reason !== "string") {
+      throw new Error("Vendor receipt contains an invalid skipped dependency.");
+    }
+    const declared = declarations.get(skipped.from);
+    const expectedSelector = skipped.kind === "optional" ? declared.optional[skipped.name] : declared.optionalPeers[skipped.name];
+    if (expectedSelector !== skipped.selector) {
+      throw new Error(`Skipped dependency is not declared as ${skipped.kind}: ${skipped.name}`);
+    }
+    const key = `${skipped.from}\x00${skipped.name}`;
+    if (skippedByEdge.has(key))
+      throw new Error(`Duplicate skipped dependency: ${skipped.name}`);
+    skippedByEdge.set(key, skipped);
+  }
+  for (const pkg of receipt.packages) {
+    if (!object(pkg.dependencies))
+      throw new Error(`Invalid dependency map for ${pkg.name}.`);
+    const declared = declarations.get(pkg.path);
+    for (const [dependency, target] of Object.entries(pkg.dependencies)) {
+      const targetPackage = packages.get(target);
+      if (!isValidNpmPackageName(dependency) || !targetPackage || targetPackage.name !== dependency) {
+        throw new Error(`Broken dependency edge ${pkg.name} -> ${dependency}.`);
+      }
+      const selector = declared.required[dependency] ?? declared.optional[dependency];
+      if (!selector)
+        throw new Error(`Undeclared dependency edge ${pkg.name} -> ${dependency}.`);
+      if (unsupportedRegistrySelector(selector)) {
+        throw new Error(`Unsupported selector on dependency edge ${pkg.name} -> ${dependency}.`);
+      }
+      const range = validRange(selector);
+      if (range && !satisfies(targetPackage.version, range)) {
+        throw new Error(`Dependency edge ${pkg.name} -> ${dependency}@${targetPackage.version} does not satisfy ${selector}.`);
+      }
+      if (skippedByEdge.has(`${pkg.path}\x00${dependency}`)) {
+        throw new Error(`Dependency is both installed and skipped: ${pkg.name} -> ${dependency}.`);
+      }
+    }
+    for (const dependency of Object.keys(declared.required)) {
+      if (!(dependency in pkg.dependencies)) {
+        throw new Error(`Missing required dependency edge ${pkg.name} -> ${dependency}.`);
+      }
+    }
+    for (const dependency of Object.keys(declared.optional)) {
+      if (!(dependency in pkg.dependencies) && !skippedByEdge.has(`${pkg.path}\x00${dependency}`)) {
+        throw new Error(`Optional dependency is neither installed nor skipped: ${pkg.name} -> ${dependency}.`);
+      }
+    }
+    for (const dependency of Object.keys(declared.optionalPeers)) {
+      if (!skippedByEdge.has(`${pkg.path}\x00${dependency}`)) {
+        throw new Error(`Optional peer dependency is not recorded as skipped: ${pkg.name} -> ${dependency}.`);
+      }
+    }
+  }
+}
+async function verifyVendoredPlugin(projectDir, expectedName, expectedVersion) {
+  try {
+    const installRoot = await resolveVendoredPluginInstallRoot(projectDir, expectedName, expectedVersion);
+    if (!installRoot)
+      return null;
+    const receiptPath = path2.join(installRoot, VENDOR_RECEIPT_FILE);
+    let raw;
+    try {
+      const info = await lstat(receiptPath);
+      if (!info.isFile() || info.isSymbolicLink() || info.nlink !== 1 || info.size > 1024 * 1024) {
+        throw new Error("Vendor receipt is not a small regular file.");
+      }
+      raw = await readFile(receiptPath, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return null;
+      throw error;
+    }
+    const receipt = JSON.parse(raw);
+    if (receipt.schemaVersion !== VENDOR_RECEIPT_VERSION) {
+      throw new Error(`Unsupported vendor receipt schema ${String(receipt.schemaVersion)}.`);
+    }
+    if (receipt.root?.name !== expectedName || receipt.root?.version !== expectedVersion) {
+      throw new Error("Vendor receipt identity does not match the manifest entry.");
+    }
+    if (!Array.isArray(receipt.packages) || receipt.packages.length === 0) {
+      throw new Error("Vendor receipt has no package graph.");
+    }
+    const tree = await computeVendorTreeDigest(installRoot);
+    if (receipt.tree?.algorithm !== "sha256" || receipt.tree.digest !== tree.digest || receipt.tree.files !== tree.files || receipt.tree.bytes !== tree.bytes) {
+      throw new Error("Vendor tree hash does not match its receipt.");
+    }
+    const packages = new Map;
+    const manifests = new Map;
+    const verifiedPackages = [];
+    const pathKeys = new Set;
+    for (const pkg of receipt.packages) {
+      const relative = safeReceiptPath(pkg.path, "Package receipt path");
+      const key = windowsPathKey(relative);
+      if (pathKeys.has(key))
+        throw new Error(`Duplicate package receipt path: ${relative}`);
+      pathKeys.add(key);
+      if (!isValidNpmPackageName(pkg.name) || !isExactNpmVersion(pkg.version)) {
+        throw new Error(`Invalid package identity in receipt: ${pkg.name}@${pkg.version}`);
+      }
+      const expectedSuffix = `node_modules/${pkg.name}`;
+      if (relative !== expectedSuffix && !relative.endsWith(`/${expectedSuffix}`)) {
+        throw new Error(`Package receipt path does not match ${pkg.name}: ${relative}`);
+      }
+      if (typeof pkg.integrity !== "string" || !/^(?:sha512|sha384|sha256|sha1)-(?:hex-)?[A-Za-z0-9+/=]+$/.test(pkg.integrity) || typeof pkg.legacySha1 !== "boolean" || pkg.legacySha1 !== pkg.integrity.startsWith("sha1-")) {
+        throw new Error(`Package receipt is missing provenance: ${pkg.name}@${pkg.version}`);
+      }
+      const tarball = new URL(pkg.tarball);
+      if (tarball.origin !== new URL(npmRegistryUrl()).origin || tarball.username || tarball.password) {
+        throw new Error(`Package receipt has an invalid tarball URL: ${pkg.name}@${pkg.version}`);
+      }
+      const packageDir = path2.resolve(installRoot, ...relative.split("/"));
+      if (!isContained(installRoot, packageDir))
+        throw new Error(`Package escapes vendor root: ${relative}`);
+      const realPackageDir2 = await realpath(packageDir);
+      if (!isContained(installRoot, realPackageDir2)) {
+        throw new Error(`Package resolves outside the vendor root: ${relative}`);
+      }
+      const manifest = await readPackageJson(packageDir);
+      if (manifest.name !== pkg.name || manifest.version !== pkg.version) {
+        throw new Error(`Installed package identity changed: ${pkg.name}@${pkg.version}`);
+      }
+      const [expectedEntry, expectedRequireEntry] = await Promise.all([
+        recomputeReceiptEntry(packageDir, relative, manifest, "import"),
+        recomputeReceiptEntry(packageDir, relative, manifest, "require")
+      ]);
+      if (pkg.entry !== expectedEntry || pkg.requireEntry !== expectedRequireEntry) {
+        throw new Error(`Recorded package entries do not match package.json: ${pkg.name}@${pkg.version}`);
+      }
+      packages.set(relative, pkg);
+      manifests.set(relative, manifest);
+      verifiedPackages.push({
+        path: relative,
+        name: pkg.name,
+        packageDir: realPackageDir2,
+        manifest,
+        entryPath: await verifyReceiptEntry(installRoot, relative, pkg.entry, "Package import entry"),
+        requireEntryPath: await verifyReceiptEntry(installRoot, relative, pkg.requireEntry, "Package require entry"),
+        dependencies: pkg.dependencies
+      });
+    }
+    await assertVendorPackageOwnership(installRoot, receipt.packages.map((pkg) => pkg.path));
+    reconcileReceiptGraph(receipt, packages, manifests);
+    const rootPackagePath = safeReceiptPath(receipt.root.packagePath, "Root package path");
+    const rootPackage = packages.get(rootPackagePath);
+    if (!rootPackage || rootPackage.name !== expectedName || rootPackage.version !== expectedVersion) {
+      throw new Error("Vendor receipt root package is missing.");
+    }
+    const reachablePackages = new Set([rootPackagePath]);
+    const pendingPackages = [rootPackagePath];
+    while (pendingPackages.length > 0) {
+      const current = packages.get(pendingPackages.pop());
+      for (const target of Object.values(current.dependencies)) {
+        if (reachablePackages.has(target))
+          continue;
+        reachablePackages.add(target);
+        pendingPackages.push(target);
+      }
+    }
+    if (reachablePackages.size !== receipt.packages.length) {
+      throw new Error("Vendor receipt contains a package that is not reachable from its root.");
+    }
+    const rootManifest = manifests.get(rootPackagePath);
+    if (receipt.root.format !== "module" && receipt.root.format !== "commonjs") {
+      throw new Error("Vendor receipt root format is invalid.");
+    }
+    const entryRelative = safeReceiptPath(receipt.root.entry, "Plugin entry path");
+    if (!entryRelative.startsWith(`${rootPackagePath}/`)) {
+      throw new Error("Plugin entry is outside its package.");
+    }
+    const expectedRootEntry = receipt.root.format === "commonjs" ? rootPackage.requireEntry ?? rootPackage.entry : rootPackage.entry;
+    if (entryRelative !== expectedRootEntry) {
+      throw new Error("Plugin entry does not match the package graph entry.");
+    }
+    if (packageEntryFormat(rootManifest, entryRelative) !== receipt.root.format) {
+      throw new Error("Plugin entry format does not match its package metadata.");
+    }
+    const entryPath = path2.resolve(installRoot, ...entryRelative.split("/"));
+    const rootPackageDir = path2.resolve(installRoot, ...rootPackagePath.split("/"));
+    const [realPackageDir, realEntry] = await Promise.all([
+      realpath(rootPackageDir),
+      realpath(entryPath)
+    ]);
+    if (!isContained(installRoot, realEntry) || !isContained(realPackageDir, realEntry)) {
+      throw new Error("Plugin entry resolves outside the verified vendor tree.");
+    }
+    const entryInfo = await lstat(realEntry);
+    if (!entryInfo.isFile() || entryInfo.isSymbolicLink()) {
+      throw new Error("Plugin entry is not a regular file.");
+    }
+    return {
+      installRoot,
+      entryPath: realEntry,
+      format: receipt.root.format,
+      packages: verifiedPackages,
+      receipt
+    };
+  } catch (error) {
+    throw new Error(`Vendored plugin "${expectedName}@${expectedVersion}" failed verification: ` + `${error instanceof Error ? error.message : String(error)} Reinstall it before building.`, { cause: error });
+  }
+}
+
+// src/lib/source-provider.ts
+var noopLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+function gitScopeFor(source) {
+  return source.repoRoot || source.path;
+}
+var HISTORY_PAGE_LIMIT = 100;
+var DEFAULT_AUTHOR = "gutterpress";
+var DEFAULT_EMAIL = "noreply@gutterpress.local";
+var DEFAULT_BRANCH = "main";
+var SNAPSHOT_STAGING_MARKER = "gutterpress-snapshot-staging";
+var repoQueues = new Map;
+function repoLockKey(projectDir) {
+  const resolved = path3.resolve(projectDir);
+  try {
+    return gitFs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function withRepoLock(projectDir, fn) {
+  const key = repoLockKey(projectDir);
+  const prev = repoQueues.get(key) ?? Promise.resolve();
+  const run = prev.then(fn, fn);
+  const tail = run.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  repoQueues.set(key, tail);
+  tail.then(() => {
+    if (repoQueues.get(key) === tail)
+      repoQueues.delete(key);
+  });
+  return run;
+}
+function __repoLockQueueSizeForTests() {
+  return repoQueues.size;
+}
+function gitAuthor(name, email) {
+  const n = (name ?? "").trim();
+  const e = (email ?? "").trim();
+  return { name: n || DEFAULT_AUTHOR, email: e || DEFAULT_EMAIL };
+}
+async function readGitAuthor(dir) {
+  const [name, email] = await Promise.all([
+    git.getConfig({ fs: gitFs, dir, path: "user.name" }).catch(() => {
+      return;
+    }),
+    git.getConfig({ fs: gitFs, dir, path: "user.email" }).catch(() => {
+      return;
+    })
+  ]);
+  return {
+    name: typeof name === "string" ? name : undefined,
+    email: typeof email === "string" ? email : undefined
+  };
+}
+async function resolveGitAuthor(dir, name, email) {
+  const existing = await readGitAuthor(dir);
+  return gitAuthor(name || existing.name, email || existing.email);
+}
+async function listWorkdirChanges(dir, cache = {}) {
+  const adds = [];
+  const removes = [];
+  await git.walk({
+    fs: gitFs,
+    dir,
+    cache,
+    trees: [git.WORKDIR(), git.STAGE()],
+    map: async (filepath, [workdir, stage]) => {
+      if (filepath === ".")
+        return;
+      if (!stage && workdir && (filepath.startsWith(".git-damaged") || await git.isIgnored({ fs: gitFs, dir, filepath }))) {
+        return null;
+      }
+      const [wType, sType] = await Promise.all([
+        workdir ? workdir.type() : Promise.resolve(undefined),
+        stage ? stage.type() : Promise.resolve(undefined)
+      ]);
+      if (wType === "tree" || sType === "tree") {
+        if (sType === "blob")
+          removes.push(filepath);
+        else if (wType === "blob")
+          adds.push(filepath);
+        return;
+      }
+      if (wType === "blob" && !sType) {
+        adds.push(filepath);
+      } else if (!wType && sType === "blob") {
+        removes.push(filepath);
+      } else if (wType === "blob" && sType === "blob") {
+        const workdirOid = await workdir.oid();
+        const stageOid = await stage.oid();
+        if (workdirOid !== stageOid) {
+          adds.push(filepath);
+        } else {
+          const fileBytes = await gitFs.promises.readFile(path3.join(dir, filepath));
+          const { oid: actualOid } = await git.hashBlob({ object: fileBytes });
+          if (actualOid !== stageOid)
+            adds.push(filepath);
+        }
+      }
+      return;
+    }
+  });
+  return { adds, removes };
+}
+async function stageChanges(dir, changes, cache) {
+  if (changes.adds.length > 0) {
+    await git.add({ fs: gitFs, dir, cache, filepath: changes.adds });
+  }
+  for (const filepath of changes.removes) {
+    await git.remove({ fs: gitFs, dir, cache, filepath });
+  }
+}
+async function hasPendingChanges(dir, cache = {}) {
+  const { adds, removes } = await listWorkdirChanges(dir, cache);
+  return adds.length > 0 || removes.length > 0;
+}
+async function hasUncommittedChanges(dir, cache = {}) {
+  if (await hasPendingChanges(dir, cache))
+    return true;
+  return !await stageMatchesHead(dir, cache);
+}
+async function stageMatchesHead(dir, cache) {
+  let headOid;
+  try {
+    headOid = await git.resolveRef({ fs: gitFs, dir, ref: "HEAD" });
+  } catch {
+    return false;
+  }
+  let differs = false;
+  await git.walk({
+    fs: gitFs,
+    dir,
+    cache,
+    trees: [git.TREE({ ref: headOid }), git.STAGE()],
+    map: async (filepath, [tree, stage]) => {
+      if (differs || filepath === ".")
+        return differs ? null : undefined;
+      const [tType, sType] = await Promise.all([
+        tree ? tree.type() : Promise.resolve(undefined),
+        stage ? stage.type() : Promise.resolve(undefined)
+      ]);
+      if (tType === "tree" || sType === "tree")
+        return;
+      if (!tType !== !sType) {
+        differs = true;
+        return null;
+      }
+      if (!tType || !sType)
+        return;
+      const [tOid, sOid] = await Promise.all([tree.oid(), stage.oid()]);
+      if (tOid !== sOid)
+        differs = true;
+      return null;
+    }
+  });
+  return !differs;
+}
+
+class LocalFolderSourceProvider {
+  source;
+  capabilities;
+  constructor(source) {
+    this.source = source;
+    this.capabilities = capabilitiesFor(source);
+  }
+  async initVersionHistory(options) {
+    const dir = options.projectDir;
+    if (await findEnclosingRepoDir(dir) !== undefined) {
+      throw new Error("This folder is already inside a versioned book, so gutterpress " + "won't create a separate history here.");
+    }
+    return withRepoLock(dir, async () => {
+      const cache = {};
+      await git.init({ fs: gitFs, dir, defaultBranch: DEFAULT_BRANCH });
+      await stageChanges(dir, await listWorkdirChanges(dir, cache), cache);
+      await git.commit({
+        fs: gitFs,
+        dir,
+        cache,
+        message: options.initialMessage?.trim() || "Created project",
+        author: await resolveGitAuthor(dir, options.authorName, options.authorEmail)
+      });
+      return {
+        type: "local-git-folder",
+        path: dir,
+        repoRoot: dir,
+        subPath: "",
+        hasRemote: false,
+        branch: DEFAULT_BRANCH
+      };
+    });
+  }
+  snapshot() {
+    return Promise.reject(new Error("This book has no version history yet. Enable version history first."));
+  }
+  listHistory() {
+    return Promise.resolve([]);
+  }
+  listHistoryPage() {
+    return Promise.resolve({ entries: [], hasMore: false });
+  }
+  restore() {
+    return Promise.reject(new Error("This book has no version history yet. Enable version history first."));
+  }
+}
+
+class LocalGitSourceProvider {
+  source;
+  capabilities;
+  dir;
+  constructor(source) {
+    this.source = source;
+    this.capabilities = capabilitiesFor(source);
+    this.dir = gitScopeFor(source);
+  }
+  async initVersionHistory(options) {
+    try {
+      await this.snapshot({
+        projectDir: options.projectDir,
+        message: options.initialMessage?.trim() || "Created project",
+        authorName: options.authorName,
+        authorEmail: options.authorEmail
+      });
+    } catch (e) {
+      if (!isNoChangesError(e))
+        throw e;
+    }
+    return this.source;
+  }
+  snapshot(options) {
+    return withRepoLock(this.dir, () => this.snapshotUnlocked(options));
+  }
+  snapshotUnlocked(options) {
+    return snapshotWorkingTreeUnlocked({ ...options, repoRoot: this.dir });
+  }
+  async listHistory(projectDir) {
+    return (await this.listHistoryPage(projectDir)).entries;
+  }
+  async listHistoryPage(_projectDir, options = {}) {
+    const dir = this.dir;
+    const limit = Math.min(500, Math.max(1, options.limit ?? HISTORY_PAGE_LIMIT));
+    const before = options.before;
+    let commits;
+    try {
+      commits = await git.log({
+        fs: gitFs,
+        dir,
+        cache: {},
+        depth: limit + 2,
+        ...before ? { ref: before } : {}
+      });
+    } catch (e) {
+      if (before && e?.code === "NotFoundError") {
+        return { entries: [], hasMore: false };
+      }
+      throw e;
+    }
+    const seen = new Set;
+    let filtered = commits.filter((c) => {
+      if (c.oid === before || seen.has(c.oid))
+        return false;
+      seen.add(c.oid);
+      return true;
+    });
+    const hasMore = filtered.length > limit;
+    if (hasMore)
+      filtered = filtered.slice(0, limit);
+    return {
+      entries: filtered.map((c) => ({
+        id: c.oid,
+        message: c.commit.message.trim(),
+        timestamp: c.commit.author.timestamp * 1000,
+        author: c.commit.author.name
+      })),
+      hasMore
+    };
+  }
+  restore(options) {
+    return withRepoLock(this.dir, () => this.restoreUnlocked(options));
+  }
+  async restoreUnlocked(options) {
+    await git.checkout({
+      fs: gitFs,
+      dir: this.dir,
+      cache: {},
+      ref: options.id,
+      force: true,
+      noUpdateHead: true
+    });
+  }
+}
+async function snapshotWorkingTreeUnlocked(options) {
+  const dir = options.repoRoot ?? options.projectDir;
+  const logger = options.logFile ? createFileLogger(options.logFile, "snapshot") : noopLogger;
+  const cache = options.cache ?? {};
+  const stagingMarker = snapshotStagingMarkerPath(dir);
+  const staleStaging = gitFs.existsSync(stagingMarker);
+  const changes = await listWorkdirChanges(dir, cache);
+  const workdirClean = changes.adds.length === 0 && changes.removes.length === 0;
+  if (workdirClean && !staleStaging) {
+    logger.debug("snapshot", "no changes — skipping");
+    throw new Error("No changes since the last snapshot — there is nothing new to save.");
+  }
+  if (workdirClean && staleStaging && await stageMatchesHead(dir, cache)) {
+    logger.debug("snapshot", "stale marker outlived a completed commit — clearing, not recommitting");
+    gitFs.rmSync(stagingMarker, { force: true });
+    const [head2] = await git.log({ fs: gitFs, dir, cache, depth: 1 });
+    return {
+      id: head2.oid,
+      message: head2.commit.message.trim(),
+      timestamp: head2.commit.author.timestamp * 1000,
+      author: head2.commit.author.name
+    };
+  }
+  logger.info("snapshot", "committing", {
+    adds: changes.adds.length,
+    removes: changes.removes.length,
+    ...staleStaging ? { recoveredStaleStaging: true } : {}
+  });
+  gitFs.writeFileSync(stagingMarker, "");
+  await stageChanges(dir, changes, cache);
+  const author = await resolveGitAuthor(dir, options.authorName, options.authorEmail);
+  const id = await git.commit({
+    fs: gitFs,
+    dir,
+    cache,
+    message: options.message,
+    author
+  });
+  gitFs.rmSync(stagingMarker, { force: true });
+  const [head] = await git.log({ fs: gitFs, dir, cache, depth: 1 });
+  return {
+    id,
+    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);
+}
+async function countUnversionedChanges(projectDir) {
+  const source = await detectProjectSource(projectDir);
+  if (source.type !== "local-git-folder")
+    return null;
+  const dir = gitScopeFor(source);
+  const bookPrefix = source.subPath ? `${source.subPath.replace(/\/+$/, "")}/` : "";
+  const appWritten = `${bookPrefix}${PLUGINS_DIR}/${VENDORED_NPM_DIR}/`;
+  return withRepoLock(dir, async () => {
+    const { adds, removes } = await listWorkdirChanges(dir);
+    const mine = new Set([...adds, ...removes].filter((f) => f.startsWith(bookPrefix) && !f.startsWith(appWritten) && path3.posix.basename(f) !== VENDOR_RECEIPT_FILE));
+    return { changedFiles: mine.size, stale: gitFs.existsSync(snapshotStagingMarkerPath(dir)) };
+  });
+}
+function providerFor(source) {
+  switch (source.type) {
+    case "local-folder":
+      return new LocalFolderSourceProvider(source);
+    case "local-git-folder":
+      return new LocalGitSourceProvider(source);
+    case "managed-github":
+      throw new Error("Managed GitHub books are not supported yet (#15/#16).");
+  }
+}
+function gitDirFor(projectDir) {
+  return path3.join(projectDir, ".git");
+}
+function snapshotStagingMarkerPath(projectDir) {
+  return path3.join(gitDirFor(projectDir), SNAPSHOT_STAGING_MARKER);
+}
+var RESTORE_BACKUP_MESSAGE = "Automatic backup before restoring an earlier version";
+var AUTO_SNAPSHOT_MESSAGE = "Automatic snapshot";
+async function restoreVersionWithBackup(options) {
+  const { projectDir, id, authorName, authorEmail } = options;
+  const source = await detectProjectSource(projectDir);
+  if (source.type !== "local-git-folder") {
+    throw new Error("This book has no version history yet. Enable version history first.");
+  }
+  const provider = new LocalGitSourceProvider(source);
+  const repoDir = gitScopeFor(source);
+  return withRepoLock(repoDir, async () => {
+    let backupId;
+    if (await hasPendingChanges(repoDir)) {
+      const backup = await provider.snapshotUnlocked({
+        projectDir,
+        message: RESTORE_BACKUP_MESSAGE,
+        authorName,
+        authorEmail
+      });
+      backupId = backup.id;
+    }
+    try {
+      await provider.restoreUnlocked({ projectDir, id });
+    } 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 book files were not changed.", { cause });
+    }
+    return { restoredId: id, backupId };
+  });
+}
+var SWITCH_BRANCH_SNAPSHOT_MESSAGE = "Saved before switching copy";
+async function listLocalBranches(dir) {
+  const source = await detectProjectSource(dir);
+  if (source.type !== "local-git-folder")
+    return null;
+  const repoDir = gitScopeFor(source);
+  const [local, current, remotes] = await Promise.all([
+    git.listBranches({ fs: gitFs, dir: repoDir }),
+    git.currentBranch({ fs: gitFs, dir: repoDir, fullname: false }).catch(() => {
+      return;
+    }),
+    git.listRemotes({ fs: gitFs, dir: repoDir }).catch(() => [])
+  ]);
+  const localNames = new Set(local);
+  const remoteOnly = new Set;
+  for (const { remote } of remotes) {
+    const names = await git.listBranches({ fs: gitFs, dir: repoDir, remote }).catch(() => []);
+    for (const name of names) {
+      if (name === "HEAD")
+        continue;
+      if (!localNames.has(name))
+        remoteOnly.add(name);
+    }
+  }
+  return {
+    current: current ?? null,
+    branches: [...localNames, ...remoteOnly].sort(),
+    remoteOnly: [...remoteOnly].sort()
+  };
+}
+async function resolveCopy(repoDir, branch) {
+  const local = await git.resolveRef({ fs: gitFs, dir: repoDir, ref: `refs/heads/${branch}` }).catch(() => {
+    return;
+  });
+  if (local)
+    return { oid: local };
+  const remotes = await git.listRemotes({ fs: gitFs, dir: repoDir }).catch(() => []);
+  for (const { remote } of remotes) {
+    const oid = await git.resolveRef({ fs: gitFs, dir: repoDir, ref: `refs/remotes/${remote}/${branch}` }).catch(() => {
+      return;
+    });
+    if (oid)
+      return { oid, remote };
+  }
+  throw new Error(`Couldn't find a copy named "${branch}" — it may have been renamed or deleted.`);
+}
+function isCheckoutConflictError(e) {
+  return e?.code === "CheckoutConflictError";
+}
+async function diffCommitPaths(dir, fromOid, toOid, cache) {
+  const changed = [];
+  await git.walk({
+    fs: gitFs,
+    dir,
+    cache,
+    trees: [git.TREE({ ref: fromOid }), git.TREE({ ref: toOid })],
+    map: async (filepath, [from, to]) => {
+      if (filepath === ".")
+        return;
+      const [fType, tType] = await Promise.all([
+        from ? from.type() : Promise.resolve(undefined),
+        to ? to.type() : Promise.resolve(undefined)
+      ]);
+      if (fType === "tree" || tType === "tree")
+        return;
+      if (!fType && !tType)
+        return;
+      if (!fType || !tType) {
+        changed.push(filepath);
+        return;
+      }
+      const [fOid, tOid] = await Promise.all([from.oid(), to.oid()]);
+      if (fOid !== tOid)
+        changed.push(filepath);
+    }
+  });
+  return changed;
+}
+async function switchBranch(options) {
+  const { projectDir, branch, authorName, authorEmail } = options;
+  const source = await detectProjectSource(projectDir);
+  if (source.type !== "local-git-folder") {
+    throw new Error("This book has no version history yet. Enable version history first.");
+  }
+  const repoDir = gitScopeFor(source);
+  return withRepoLock(repoDir, async () => {
+    const cache = {};
+    try {
+      await snapshotWorkingTreeUnlocked({
+        projectDir,
+        repoRoot: repoDir,
+        message: SWITCH_BRANCH_SNAPSHOT_MESSAGE,
+        authorName,
+        authorEmail,
+        cache
+      });
+    } catch (e) {
+      if (!isNoChangesError(e))
+        throw e;
+    }
+    const fromOid = await git.resolveRef({ fs: gitFs, dir: repoDir, ref: "HEAD" }).catch(() => {
+      return;
+    });
+    const { oid: toOid, remote } = await resolveCopy(repoDir, branch);
+    try {
+      await git.checkout({
+        fs: gitFs,
+        dir: repoDir,
+        cache,
+        ref: branch,
+        force: false,
+        ...remote ? { remote } : {}
+      });
+    } catch (e) {
+      if (isCheckoutConflictError(e)) {
+        throw new Error("Couldn't switch copies — some files changed on disk right as the switch " + "started. Try again.", { cause: e });
+      }
+      throw e;
+    }
+    const changedPaths = fromOid && fromOid !== toOid ? await diffCommitPaths(repoDir, fromOid, toOid, cache) : [];
+    return {
+      current: branch,
+      changedFiles: changedPaths.map((p) => path3.join(repoDir, p))
+    };
+  });
+}
+
+export { npmRegistryUrl, PLUGINS_DIR, VENDORED_NPM_DIR, VENDOR_RECEIPT_FILE, VENDOR_RECEIPT_VERSION, isValidNpmPackageName, parseNpmPluginSpec, isExactNpmVersion, vendoredNpmPluginRoot, vendoredNpmPluginPackageDir, packageEntryFormat, assertWindowsSafeRelativePath, windowsPathKey, packageResolutionTargets, resolvePackageEntry, computeVendorTreeDigest, resolveVendoredPluginInstallRoot, verifyVendoredPlugin, gitScopeFor, HISTORY_PAGE_LIMIT, withRepoLock, __repoLockQueueSizeForTests, resolveGitAuthor, listWorkdirChanges, stageChanges, hasPendingChanges, hasUncommittedChanges, snapshotWorkingTreeUnlocked, isNoChangesError, countUnversionedChanges, providerFor, gitDirFor, snapshotStagingMarkerPath, RESTORE_BACKUP_MESSAGE, AUTO_SNAPSHOT_MESSAGE, restoreVersionWithBackup, SWITCH_BRANCH_SNAPSHOT_MESSAGE, listLocalBranches, switchBranch };