gutterpress 0.11.6-alpha.3 → 0.11.6

package/dist/{cli-g6vshy3f.js → cli-02sh3r8x.js}

@@ -13,12 +13,12 @@ import {
   stampCreator,
   stripAnnotations,
   warn
-} from "./cli-rra50cp6.js";
+} from "./cli-emp8wz36.js";
 import {
   DEBOUNCE,
   UsageError,
   resolvePort
-} from "./cli-5c2xfsmz.js";
+} from "./cli-1bccnym3.js";
 import {
   MARGIN_BOX_IGNORED_PROPERTIES,
   RENDER_TIMEOUT_MS,
@@ -41,9 +41,27 @@ import {
   BuildError
 } from "./cli-46ycxe6r.js";
 import {
+  PLUGINS_DIR,
+  VENDORED_NPM_DIR,
+  VENDOR_RECEIPT_FILE,
+  VENDOR_RECEIPT_VERSION,
+  assertWindowsSafeRelativePath,
+  computeVendorTreeDigest,
   hasUncommittedChanges,
-  listWorkdirChanges
-} from "./cli-c5360prx.js";
+  isExactNpmVersion,
+  isValidNpmPackageName,
+  listWorkdirChanges,
+  npmRegistryUrl,
+  packageEntryFormat,
+  packageResolutionTargets,
+  parseNpmPluginSpec,
+  resolvePackageEntry,
+  resolveVendoredPluginInstallRoot,
+  vendoredNpmPluginPackageDir,
+  vendoredNpmPluginRoot,
+  verifyVendoredPlugin,
+  windowsPathKey
+} from "./cli-4tx0szk7.js";
 import {
   detectProjectSource,
   repoSubPath
@@ -52,599 +70,6 @@ import {
   __require
 } from "./cli-37x76zdn.js";
 
-// 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 path 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 path.join(projectDir, PLUGINS_DIR, VENDORED_NPM_DIR, encodePathPart(name), encodePathPart(version));
-}
-function vendoredNpmPluginPackageDir(installRoot, name) {
-  return path.join(installRoot, "node_modules", ...name.split("/"));
-}
-function toPosixPath(value) {
-  return value.split(path.sep).join("/");
-}
-function packageEntryFormat(manifest, relativeEntry) {
-  const extension = path.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 = path.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path.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 = path.join(packageDir, "package.json");
-  const info2 = await lstat(packageJsonPath);
-  if (!info2.isFile() || info2.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 = path.resolve(installRoot, ...packagePath.split("/"));
-  const entryPath = path.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 info2 = await lstat(realEntry);
-  if (!info2.isFile() || info2.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 || path.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 = path.resolve(packageDir, ...relative.split("/"));
-  if (!isContained(packageDir, base))
-    return null;
-  const candidates = resolution.exact ? [base] : [
-    base,
-    `${base}.mjs`,
-    `${base}.js`,
-    `${base}.cjs`,
-    `${base}.json`,
-    path.join(base, "index.mjs"),
-    path.join(base, "index.js"),
-    path.join(base, "index.cjs"),
-    path.join(base, "index.json")
-  ];
-  for (const candidate of candidates) {
-    try {
-      const info2 = await lstat(candidate);
-      if (!info2.isFile() || info2.isSymbolicLink())
-        continue;
-      const extension = path.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(path.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 = path.join(dir, entry.name);
-      const relative = toPosixPath(path.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 = path.join(root, ...relative.split("/"));
-    const info2 = await lstat(absolute);
-    if (!info2.isFile() || info2.isSymbolicLink() || info2.nlink !== 1) {
-      throw new Error(`Vendor tree file is not an independent regular file: ${relative}`);
-    }
-    bytes += info2.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}:${info2.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 (error2) {
-    if (error2 instanceof Error && error2.message.includes("no contained JavaScript entry point")) {
-      return;
-    }
-    throw error2;
-  }
-}
-async function resolveVendoredPluginInstallRoot(projectDir, expectedName, expectedVersion) {
-  const requestedProjectRoot = path.resolve(projectDir);
-  const requestedInstallRoot = vendoredNpmPluginRoot(requestedProjectRoot, expectedName, expectedVersion);
-  let installInfo;
-  try {
-    installInfo = await lstat(requestedInstallRoot);
-  } catch (error2) {
-    if (error2.code === "ENOENT")
-      return null;
-    throw error2;
-  }
-  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 = path.join(installRoot, VENDOR_RECEIPT_FILE);
-    let raw;
-    try {
-      const info2 = await lstat(receiptPath);
-      if (!info2.isFile() || info2.isSymbolicLink() || info2.nlink !== 1 || info2.size > 1024 * 1024) {
-        throw new Error("Vendor receipt is not a small regular file.");
-      }
-      raw = await readFile(receiptPath, "utf8");
-    } catch (error2) {
-      if (error2.code === "ENOENT")
-        return null;
-      throw error2;
-    }
-    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 = path.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 = path.resolve(installRoot, ...entryRelative.split("/"));
-    const rootPackageDir = path.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 (error2) {
-    throw new Error(`Vendored plugin "${expectedName}@${expectedVersion}" failed verification: ` + `${error2 instanceof Error ? error2.message : String(error2)} Reinstall it before building.`, { cause: error2 });
-  }
-}
-
 // src/lib/extension-specifier.ts
 var BUNDLED_EXTENSIONS = [
   "markdown-it-mark",
@@ -974,7 +399,7 @@ function applyDefaultPdfStrictChecks(config) {
 }
 
 // src/lib/manifest.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { existsSync, statSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { parse as parseYaml, YAMLParseError } from "yaml";
@@ -989,7 +414,7 @@ async function loadManifestWithPath(pathOrDir, opts) {
   const candidates = pathOrDir ? [resolve(pathOrDir), ...MANIFEST_FILENAMES.map((name) => resolve(pathOrDir, name))] : MANIFEST_FILENAMES.map((name) => resolve(name));
   for (const p of candidates) {
     if (existsSync(p) && statSync(p).isFile()) {
-      const raw = await readFile2(p, "utf8");
+      const raw = await readFile(p, "utf8");
       try {
         const manifest = parseYaml(raw) ?? {};
         return { manifest, manifestDir: dirname(p), manifestPath: p };
@@ -1283,7 +708,7 @@ function inspectionFailed(checkId, message, extra = {}) {
 }
 
 // src/lib/pdf-inspect.ts
-import { stat, readFile as readFile3 } from "node:fs/promises";
+import { stat, readFile as readFile2 } from "node:fs/promises";
 import { getDocumentProxy } from "unpdf";
 import * as pdfjs from "unpdf/pdfjs";
 function getOps(mod) {
@@ -1319,17 +744,17 @@ function evictLru() {
       destroyEntryAfterGrace(evicted);
   }
 }
-async function loadPdf(path2) {
+async function loadPdf(path) {
   let st;
   try {
-    st = await stat(path2);
+    st = await stat(path);
   } catch {
     return null;
   }
-  const hit = docCache.get(path2);
+  const hit = docCache.get(path);
   if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) {
-    docCache.delete(path2);
-    docCache.set(path2, hit);
+    docCache.delete(path);
+    docCache.set(path, hit);
     try {
       return await hit.doc;
     } catch {
@@ -1338,15 +763,15 @@ async function loadPdf(path2) {
   }
   if (hit)
     destroyEntry(hit);
-  const docPromise = readFile3(path2).then((buf) => getDocumentProxy(new Uint8Array(buf)));
-  docCache.delete(path2);
-  docCache.set(path2, { mtimeMs: st.mtimeMs, size: st.size, doc: docPromise });
+  const docPromise = readFile2(path).then((buf) => getDocumentProxy(new Uint8Array(buf)));
+  docCache.delete(path);
+  docCache.set(path, { mtimeMs: st.mtimeMs, size: st.size, doc: docPromise });
   evictLru();
   try {
     return await docPromise;
   } catch {
-    if (docCache.get(path2)?.doc === docPromise)
-      docCache.delete(path2);
+    if (docCache.get(path)?.doc === docPromise)
+      docCache.delete(path);
     return null;
   }
 }
@@ -1797,9 +1222,9 @@ var check3 = {
 registerCheck(check3);
 
 // src/lib/pdf-parse.ts
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 async function readPdfBytes(pdfPath) {
-  return readFile4(pdfPath, "latin1");
+  return readFile3(pdfPath, "latin1");
 }
 function parseInkCov(out) {
   const lines = out.split(/\r?\n/).filter((l) => l.includes("CMYK"));
@@ -2370,7 +1795,7 @@ var check15 = {
 registerCheck(check15);
 
 // src/checks/source/markdownlint.ts
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 import { lint } from "markdownlint/sync";
 import { parse as parseYaml2 } from "yaml";
 
@@ -2403,7 +1828,7 @@ function stripJsonComments(s) {
   return s.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
 }
 async function loadConfig(configPath) {
-  const raw = await readFile5(configPath, "utf8");
+  const raw = await readFile4(configPath, "utf8");
   let parsed;
   if (configPath.endsWith(".json")) {
     parsed = JSON.parse(raw);
@@ -2464,7 +1889,7 @@ registerCheck(check16);
 
 // src/checks/source/htmlhint.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 import htmlhint from "htmlhint";
 var { HTMLHint } = htmlhint;
 var CONFIG_NAMES2 = [".htmlhintrc"];
@@ -2484,8 +1909,8 @@ var check17 = {
     const resolvedConfig = findConfigFile(ctx.inputDir, CONFIG_NAMES2, configPath);
     if (!resolvedConfig && !configPath)
       return [];
-    const ruleset = resolvedConfig ? JSON.parse(await readFile6(resolvedConfig, "utf8")) : HTMLHint.defaultRuleset;
-    const html = await readFile6(ctx.htmlPath, "utf8");
+    const ruleset = resolvedConfig ? JSON.parse(await readFile5(resolvedConfig, "utf8")) : HTMLHint.defaultRuleset;
+    const html = await readFile5(ctx.htmlPath, "utf8");
     const messages = HTMLHint.verify(html, ruleset);
     return messages.map((m) => ({
       checkId: check17.id,
@@ -2500,7 +1925,7 @@ var check17 = {
 registerCheck(check17);
 
 // src/checks/source/stylelint.ts
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 
 // src/lib/printsafe.ts
 import postcss from "postcss";
@@ -2776,7 +2201,7 @@ var check18 = {
     for (const file of files) {
       let css;
       try {
-        css = await readFile7(file, "utf8");
+        css = await readFile6(file, "utf8");
       } catch (err) {
         results.push({
           checkId: check18.id,
@@ -2803,12 +2228,12 @@ var check18 = {
 registerCheck(check18);
 
 // src/checks/source/css-ownership.ts
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 
 // src/lib/style-resolver.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { readdir as readdir2 } from "node:fs/promises";
-import path2 from "node:path";
+import { readdir } from "node:fs/promises";
+import path from "node:path";
 var STYLES_SUBDIR = "styles";
 var FALLBACK_PRIORITY = [
   "styles/book.css",
@@ -2818,21 +2243,21 @@ var FALLBACK_PRIORITY = [
   "css/main.css"
 ];
 function relDisplay(projectDir, absPath) {
-  return path2.relative(projectDir, absPath).split(path2.sep).join("/");
+  return path.relative(projectDir, absPath).split(path.sep).join("/");
 }
 async function dirEntries(dir) {
   try {
-    return await readdir2(dir, { withFileTypes: true });
+    return await readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
 }
 function cssFilesFrom(dir, entries) {
-  return entries.filter((e) => e.isFile() && e.name.toLowerCase().endsWith(".css")).map((e) => path2.join(dir, e.name));
+  return entries.filter((e) => e.isFile() && e.name.toLowerCase().endsWith(".css")).map((e) => path.join(dir, e.name));
 }
 async function discoverCssFiles(projectDir) {
-  const stylesDir = path2.join(projectDir, STYLES_SUBDIR);
-  const cssDir = path2.join(projectDir, "css");
+  const stylesDir = path.join(projectDir, STYLES_SUBDIR);
+  const cssDir = path.join(projectDir, "css");
   const [rootEntries, stylesEntries, cssEntries] = await Promise.all([
     dirEntries(projectDir),
     dirEntries(stylesDir),
@@ -2855,7 +2280,7 @@ async function resolveActiveStyles(projectDir, manifestStyles) {
   if (manifest.length > 0)
     return manifest;
   for (const rel of FALLBACK_PRIORITY) {
-    if (existsSync4(path2.join(projectDir, rel)))
+    if (existsSync4(path.join(projectDir, rel)))
       return [rel];
   }
   const discovered = await discoverCssFiles(projectDir);
@@ -2871,7 +2296,7 @@ import postcss2 from "postcss";
 import { parse as parseYaml3 } from "yaml";
 var CONFIG_NAMES3 = [".gutterpress/css-contract.yaml", ".gutterpress/css-contract.yml"];
 async function loadContract(configPath) {
-  const raw = await readFile8(configPath, "utf8");
+  const raw = await readFile7(configPath, "utf8");
   const parsed = parseYaml3(raw);
   if (parsed && typeof parsed === "object")
     return parsed;
@@ -3022,7 +2447,7 @@ var check19 = {
         continue;
       let css;
       try {
-        css = await readFile8(absFile, "utf8");
+        css = await readFile7(absFile, "utf8");
       } catch {
         continue;
       }
@@ -3068,9 +2493,9 @@ import { existsSync as existsSync7 } from "node:fs";
 import { dirname as dirname3, resolve as resolve5 } from "node:path";
 
 // src/lib/asset-inline.ts
-import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile9 } from "node:fs/promises";
-import path3 from "node:path";
+import { createHash } from "node:crypto";
+import { readFile as readFile8 } from "node:fs/promises";
+import path2 from "node:path";
 import postcss3 from "postcss";
 var FONT_EXTS = new Set([".woff2", ".woff", ".ttf", ".otf"]);
 var HASHED_ASSET_DIR = "assets";
@@ -3111,19 +2536,19 @@ function decodeRef(ref) {
   }
 }
 function toPosix(p) {
-  return p.split(path3.sep).join("/");
+  return p.split(path2.sep).join("/");
 }
 function escapesProjectRoot(projectDir, absPath) {
-  const rel = path3.relative(projectDir, absPath);
-  return rel === ".." || rel.startsWith(`..${path3.sep}`) || path3.isAbsolute(rel);
+  const rel = path2.relative(projectDir, absPath);
+  return rel === ".." || rel.startsWith(`..${path2.sep}`) || path2.isAbsolute(rel);
 }
 function proseImageRefError(ref, projectDir) {
   const cleaned = stripUrlSuffix(decodeRef(ref));
-  if (/^file:/i.test(cleaned) || path3.isAbsolute(cleaned)) {
+  if (/^file:/i.test(cleaned) || path2.isAbsolute(cleaned)) {
     return `Image reference must be relative to the book folder: ${ref}
 ` + `  Copy the file into your book folder and reference it from there.`;
   }
-  if (escapesProjectRoot(projectDir, path3.resolve(projectDir, cleaned))) {
+  if (escapesProjectRoot(projectDir, path2.resolve(projectDir, cleaned))) {
     return `Image reference points outside the book folder: ${ref}
 ` + `  Copy the file into your book folder and reference it from there.`;
   }
@@ -3134,7 +2559,7 @@ function mimeFor(ext) {
 }
 async function readOrThrow(absPath, kind, referencedFrom) {
   try {
-    return await readFile9(absPath);
+    return await readFile8(absPath);
   } catch {
     throw new BuildError(`Missing ${kind}: ${absPath}
   referenced from ${referencedFrom}
@@ -3145,7 +2570,7 @@ function dataUri(bytes, ext) {
   return `data:${mimeFor(ext)};base64,${bytes.toString("base64")}`;
 }
 function contentHash(bytes) {
-  return createHash2("sha256").update(bytes).digest("hex").slice(0, 16);
+  return createHash("sha256").update(bytes).digest("hex").slice(0, 16);
 }
 async function rewriteUrls(value, rewrite) {
   const matches = [...value.matchAll(URL_TOKEN_RE)];
@@ -3193,12 +2618,12 @@ function importTarget(atRule) {
   return target;
 }
 async function inlineOne(cssPath, copies, warnings, seen) {
-  const abs = path3.resolve(cssPath);
+  const abs = path2.resolve(cssPath);
   if (seen.has(abs))
     return "";
   seen.add(abs);
   const source = await readOrThrow(abs, "stylesheet", "the book manifest");
-  const cssDir = path3.dirname(abs);
+  const cssDir = path2.dirname(abs);
   let root;
   try {
     root = postcss3.parse(source.toString("utf-8"), { from: abs });
@@ -3220,8 +2645,8 @@ async function inlineOne(cssPath, copies, warnings, seen) {
         return null;
       }
       const relPath = stripUrlSuffix(decodeRef(raw));
-      const absAsset = path3.resolve(cssDir, relPath);
-      const ext = path3.extname(absAsset).toLowerCase();
+      const absAsset = path2.resolve(cssDir, relPath);
+      const ext = path2.extname(absAsset).toLowerCase();
       if (FONT_EXTS.has(ext)) {
         const bytes2 = await readOrThrow(absAsset, "font file", abs);
         return dataUri(bytes2, ext);
@@ -3239,7 +2664,7 @@ async function inlineOne(cssPath, copies, warnings, seen) {
       imports.push({ node, target });
   });
   for (const { node, target } of imports) {
-    const importedAbs = path3.resolve(cssDir, stripUrlSuffix(decodeRef(target)));
+    const importedAbs = path2.resolve(cssDir, stripUrlSuffix(decodeRef(target)));
     const inlined = await inlineOne(importedAbs, copies, warnings, seen);
     node.replaceWith(wrapImportConditions(node, postcss3.parse(inlined, { from: importedAbs })));
   }
@@ -3251,10 +2676,10 @@ async function inlineStyles(projectDir, stylePaths) {
   const seen = new Set;
   const parts = [];
   for (const rel of stylePaths) {
-    const abs = path3.resolve(projectDir, rel);
+    const abs = path2.resolve(projectDir, rel);
     const css = await inlineOne(abs, copies, warnings, seen);
     if (css.trim().length > 0) {
-      parts.push(`/* ${toPosix(path3.relative(projectDir, abs))} */
+      parts.push(`/* ${toPosix(path2.relative(projectDir, abs))} */
 ${css.trim()}`);
     }
   }
@@ -3270,14 +2695,14 @@ async function collectStyleDependencies(projectDir, stylePaths) {
   const found = new Set;
   const visited = new Set;
   async function walk(cssPath) {
-    const abs = path3.resolve(cssPath);
+    const abs = path2.resolve(cssPath);
     if (visited.has(abs))
       return;
     visited.add(abs);
     found.add(abs);
     let source;
     try {
-      source = await readFile9(abs, "utf-8");
+      source = await readFile8(abs, "utf-8");
     } catch {
       return;
     }
@@ -3287,14 +2712,14 @@ async function collectStyleDependencies(projectDir, stylePaths) {
     } catch {
       return;
     }
-    const cssDir = path3.dirname(abs);
+    const cssDir = path2.dirname(abs);
     root.walkDecls((decl) => {
       if (!decl.value.includes("url("))
         return;
       for (const raw of extractCssUrls(decl.value)) {
         if (!raw || isNonFilesystemRef(raw))
           continue;
-        found.add(path3.resolve(cssDir, stripUrlSuffix(decodeRef(raw))));
+        found.add(path2.resolve(cssDir, stripUrlSuffix(decodeRef(raw))));
       }
     });
     const imports = [];
@@ -3304,11 +2729,11 @@ async function collectStyleDependencies(projectDir, stylePaths) {
         imports.push(target);
     });
     for (const target of imports) {
-      await walk(path3.resolve(cssDir, stripUrlSuffix(decodeRef(target))));
+      await walk(path2.resolve(cssDir, stripUrlSuffix(decodeRef(target))));
     }
   }
   for (const rel of stylePaths) {
-    await walk(path3.resolve(projectDir, rel));
+    await walk(path2.resolve(projectDir, rel));
   }
   return [...found];
 }
@@ -3325,8 +2750,8 @@ async function planImageCopies(projectDir, refs) {
       continue;
     }
     const cleaned = stripUrlSuffix(decodeRef(ref));
-    const abs = path3.resolve(projectDir, cleaned);
-    const rel = path3.relative(projectDir, abs);
+    const abs = path2.resolve(projectDir, cleaned);
+    const rel = path2.relative(projectDir, abs);
     const dest = toPosix(rel);
     copies.set(dest, { from: abs, to: dest });
     destinations.set(ref, dest);
@@ -3347,18 +2772,18 @@ async function inlineShapeUrls(html, baseDir) {
     if (!raw || isNonFilesystemRef(raw))
       continue;
     const cleaned = stripUrlSuffix(decodeRef(raw));
-    if (path3.isAbsolute(cleaned))
+    if (path2.isAbsolute(cleaned))
       continue;
-    const abs = path3.resolve(baseDir, cleaned);
+    const abs = path2.resolve(baseDir, cleaned);
     if (escapesProjectRoot(baseDir, abs))
       continue;
     let bytes;
     try {
-      bytes = await readFile9(abs);
+      bytes = await readFile8(abs);
     } catch {
       continue;
     }
-    const mime = mimeFor(path3.extname(abs).toLowerCase());
+    const mime = mimeFor(path2.extname(abs).toLowerCase());
     const dataUri2 = `data:${mime};base64,${bytes.toString("base64")}`;
     replacements.set(m[0], `--gp-shape:url(&quot;${dataUri2}&quot;)`);
   }
@@ -3372,7 +2797,7 @@ async function inlineShapeUrls(html, baseDir) {
 }
 
 // src/checks/source/local-ref-parser.ts
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 
 // src/lib/markdown/renderer.ts
 import MarkdownIt from "markdown-it";
@@ -5191,9 +4616,9 @@ function layerSlug(name) {
 }
 
 // src/lib/markdown/plugins.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync6, lstatSync, realpathSync, rmSync, statSync as statSync2, unlinkSync } from "node:fs";
-import { cp, link, mkdir, mkdtemp, readFile as readFile11, rm, unlink, writeFile } from "node:fs/promises";
+import { cp, link, mkdir, mkdtemp, readFile as readFile10, rm, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { resolve as resolve4, join, dirname as dirname2, basename, extname, relative, isAbsolute } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -5218,24 +4643,24 @@ function resolveDeclaredStyles(rawStyles, baseDir, subject) {
 }
 
 // src/lib/extension-manifest.ts
-import { readFile as readFile10 } from "node:fs/promises";
-import path4 from "node:path";
+import { readFile as readFile9 } from "node:fs/promises";
+import path3 from "node:path";
 var EXTENSION_MANIFEST_FILENAME = "package.json";
 var GUTTERPRESS_KEY = "gutterpress";
-function object2(value) {
+function object(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
 function str(value) {
   return typeof value === "string" ? value : undefined;
 }
 function authorName(value) {
-  return str(value) ?? str(object2(value)?.name);
+  return str(value) ?? str(object(value)?.name);
 }
 function metaFromPackageJson(raw) {
-  const pkg = object2(raw);
+  const pkg = object(raw);
   if (!pkg)
     return {};
-  const gp = object2(pkg[GUTTERPRESS_KEY]) ?? {};
+  const gp = object(pkg[GUTTERPRESS_KEY]) ?? {};
   const keywords = Array.isArray(pkg.keywords) ? pkg.keywords.filter((k) => typeof k === "string") : undefined;
   return {
     ...str(pkg.name) ? { name: str(pkg.name) } : {},
@@ -5254,7 +4679,7 @@ function metaFromPackageJson(raw) {
 }
 async function readExtensionMeta(dir) {
   try {
-    return metaFromPackageJson(JSON.parse(await readFile10(path4.join(dir, EXTENSION_MANIFEST_FILENAME), "utf8")));
+    return metaFromPackageJson(JSON.parse(await readFile9(path3.join(dir, EXTENSION_MANIFEST_FILENAME), "utf8")));
   } catch {
     return {};
   }
@@ -5277,7 +4702,7 @@ function extensionCarries(meta) {
   };
 }
 function pathEscapesFolder(rel) {
-  return path4.isAbsolute(rel) || rel.split(/[\\/]/).includes("..");
+  return path3.isAbsolute(rel) || rel.split(/[\\/]/).includes("..");
 }
 function assertExtensionContained(meta) {
   if (meta.engineStyles !== undefined) {
@@ -5548,9 +4973,9 @@ function isReceiptBoundRequireCall(node) {
     return true;
   if (callee.type !== "MemberExpression")
     return false;
-  const object3 = callee.object;
+  const object2 = callee.object;
   const property = memberName(callee);
-  return Boolean(object3 && (object3.type === "Identifier" && object3.name === "module" && property === "require" || object3.type === "Identifier" && object3.name === "require" && property === "resolve"));
+  return Boolean(object2 && (object2.type === "Identifier" && object2.name === "module" && property === "require" || object2.type === "Identifier" && object2.name === "require" && property === "resolve"));
 }
 function rewriteCommonJsRequires(source, absolute, pkg, tree) {
   const ast = parseJavaScript(source, {
@@ -5601,7 +5026,7 @@ async function rewriteReachableModuleImports(entryPath, tree) {
     const pkg = packageOwningFile(tree, absolute);
     if (!pkg)
       throw new Error(`Reachable plugin module is outside the verified package tree: ${absolute}`);
-    const source = await readFile11(absolute, "utf8");
+    const source = await readFile10(absolute, "utf8");
     const [imports] = parseModuleImports(source, absolute);
     const replacements = [];
     const targets = new Set;
@@ -5708,7 +5133,7 @@ async function createIsolatedVendorTree(verified, address) {
   }
 }
 async function isolateVendoredPlugin(verified) {
-  const address = createHash3("sha256").update(verified.receipt.tree.digest).update("\x00").update(JSON.stringify(verified.receipt)).digest("hex");
+  const address = createHash2("sha256").update(verified.receipt.tree.digest).update("\x00").update(JSON.stringify(verified.receipt)).digest("hex");
   let pending = isolatedVendorTrees.get(address);
   if (!pending) {
     pending = createIsolatedVendorTree(verified, address).catch((error2) => {
@@ -6180,7 +5605,7 @@ async function* renderedLocalRefs(ctx, checkId, results) {
   for (const file of files) {
     let refs;
     try {
-      refs = collectRenderedLocalRefs(await readFile12(file, "utf8"));
+      refs = collectRenderedLocalRefs(await readFile11(file, "utf8"));
     } catch {
       results.push(inspectionFailed(checkId, `Could not read source file: ${file}`, { file }));
       continue;
@@ -6242,15 +5667,15 @@ function localRefExists(ref, kind, sourceFile, projectRoot) {
 registerCheck(check20);
 
 // src/lib/build-staging.ts
-import path5 from "node:path";
+import path4 from "node:path";
 import os from "node:os";
 import fsp from "node:fs/promises";
 
 // src/lib/missing-asset-placeholder.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { deflateSync } from "node:zlib";
 function placeholderOutputPath(missingOutputPath) {
-  const hash = createHash4("sha256").update(missingOutputPath).digest("hex").slice(0, 16);
+  const hash = createHash3("sha256").update(missingOutputPath).digest("hex").slice(0, 16);
   return `assets/gutterpress-missing/${hash}.png`;
 }
 function decodeHtmlAttribute(value) {
@@ -6427,8 +5852,8 @@ function placeholderPng(width = 640, height = 480, cell = 32) {
 
 // src/lib/build-staging.ts
 async function shipViewerHtml(htmlFile, outDir) {
-  await fsp.mkdir(path5.join(outDir, "engine"), { recursive: true });
-  await fsp.copyFile(await getAssetPath("engine/gutterpress-viewer.js"), path5.join(outDir, "engine/gutterpress-viewer.js"));
+  await fsp.mkdir(path4.join(outDir, "engine"), { recursive: true });
+  await fsp.copyFile(await getAssetPath("engine/gutterpress-viewer.js"), path4.join(outDir, "engine/gutterpress-viewer.js"));
   const tag = `  <script src="engine/gutterpress-viewer.js"></script>
 `;
   const html = await fsp.readFile(htmlFile, "utf-8");
@@ -6460,18 +5885,18 @@ async function stageBookAssets(options) {
   return { missing: [...missingPlaceholders.keys()].sort() };
 }
 async function copyReferencedAssets(copies, outDir) {
-  const dirs = new Set(copies.map((c) => path5.dirname(path5.resolve(outDir, c.to))));
+  const dirs = new Set(copies.map((c) => path4.dirname(path4.resolve(outDir, c.to))));
   await Promise.all([...dirs].map((d) => fsp.mkdir(d, { recursive: true })));
   const missing = new Map;
   await Promise.all(copies.map(async (c) => {
-    const dest = path5.resolve(outDir, c.to);
+    const dest = path4.resolve(outDir, c.to);
     try {
       await fsp.copyFile(c.from, dest);
     } catch (err) {
       if (err?.code === "ENOENT") {
         const placeholder = placeholderOutputPath(c.to);
-        const placeholderDest = path5.resolve(outDir, placeholder);
-        await fsp.mkdir(path5.dirname(placeholderDest), { recursive: true });
+        const placeholderDest = path4.resolve(outDir, placeholder);
+        await fsp.mkdir(path4.dirname(placeholderDest), { recursive: true });
         await fsp.writeFile(placeholderDest, placeholderPng());
         missing.set(c.to, placeholder);
         return;
@@ -6501,7 +5926,7 @@ function dropRelativeLinkHrefs(html) {
   });
 }
 async function createStageRoot() {
-  return fsp.mkdtemp(path5.join(os.tmpdir(), "gutterpress-stage-"));
+  return fsp.mkdtemp(path4.join(os.tmpdir(), "gutterpress-stage-"));
 }
 
 // src/checks/source/dangling-links.ts
@@ -6531,7 +5956,7 @@ var check21 = {
 registerCheck(check21);
 
 // src/checks/source/accessibility-alt-text.ts
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 var check22 = {
   id: "source.accessibility.alt-text",
   name: "Image Alt Text",
@@ -6545,7 +5970,7 @@ var check22 = {
     const results = [];
     for (const file of files) {
       try {
-        const content = await readFile13(file, "utf8");
+        const content = await readFile12(file, "utf8");
         const lines = content.split(`
 `);
         let inFence = false;
@@ -6589,7 +6014,7 @@ function extractImageAlts(line) {
 registerCheck(check22);
 
 // src/checks/source/accessibility-heading-order.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile13 } from "node:fs/promises";
 var check23 = {
   id: "source.accessibility.heading-order",
   name: "Heading Order",
@@ -6603,7 +6028,7 @@ var check23 = {
     const results = [];
     for (const file of files) {
       try {
-        const content = await readFile14(file, "utf8");
+        const content = await readFile13(file, "utf8");
         const lines = content.split(`
 `);
         let inFence = false;
@@ -6639,7 +6064,7 @@ var check23 = {
 registerCheck(check23);
 
 // src/checks/source/layout-markers.ts
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 var check24 = {
   id: "source.markdown.layout-markers",
   name: "Layout Markers",
@@ -6657,7 +6082,7 @@ var check24 = {
     const md = createMarkdownRenderer(plugins);
     for (const file of files) {
       try {
-        const content = await readFile15(file, "utf8");
+        const content = await readFile14(file, "utf8");
         const env = {};
         md.render(content, env);
         for (const w of env.layoutWarnings ?? []) {
@@ -6679,8 +6104,8 @@ var check24 = {
 registerCheck(check24);
 
 // src/checks/source/merge-markers.ts
-import { readFile as readFile16 } from "node:fs/promises";
-import path6 from "node:path";
+import { readFile as readFile15 } from "node:fs/promises";
+import path5 from "node:path";
 
 // src/checks/asset/extensions.ts
 var RASTER_INSPECTABLE_EXTS = [
@@ -6721,7 +6146,7 @@ var check25 = {
     for (const file of textFiles) {
       let content;
       try {
-        content = await readFile16(file, "utf8");
+        content = await readFile15(file, "utf8");
       } catch {
         results.push(inspectionFailed(check25.id, `Could not read source file: ${file}`, { file }));
         continue;
@@ -6764,7 +6189,7 @@ var check25 = {
         ignore: [...ASSET_SCAN_IGNORE_GLOBS]
       });
       for (const sibling of siblings.sort()) {
-        const rel = path6.relative(ctx.inputDir, sibling).split(path6.sep).join("/");
+        const rel = path5.relative(ctx.inputDir, sibling).split(path5.sep).join("/");
         results.push(finding(check25.id, {
           severity: "warning",
           code: "kept-both-versions",
@@ -6784,27 +6209,27 @@ registerCheck(check25);
 import { stat as stat3 } from "node:fs/promises";
 
 // src/lib/image-inspect.ts
-import { stat as stat2, readFile as readFile17 } from "node:fs/promises";
+import { stat as stat2, readFile as readFile16 } from "node:fs/promises";
 var DEFAULT_DPI = 72;
 var cache = new Map;
-async function inspectImage(path7) {
+async function inspectImage(path6) {
   let st;
   try {
-    st = await stat2(path7);
+    st = await stat2(path6);
   } catch {
     return null;
   }
-  const hit = cache.get(path7);
+  const hit = cache.get(path6);
   if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size)
     return hit.info;
   let info2 = null;
   try {
-    const buf = await readFile17(path7);
+    const buf = await readFile16(path6);
     info2 = parseImage(buf);
   } catch {
     info2 = null;
   }
-  cache.set(path7, { mtimeMs: st.mtimeMs, size: st.size, info: info2 });
+  cache.set(path6, { mtimeMs: st.mtimeMs, size: st.size, info: info2 });
   return info2;
 }
 function parseImage(b) {
@@ -7359,7 +6784,7 @@ var check33 = {
 registerCheck(check33);
 
 // src/checks/heuristic/section-density.ts
-import { readFile as readFile18 } from "node:fs/promises";
+import { readFile as readFile17 } from "node:fs/promises";
 var check34 = {
   id: "heuristic.chunking.section-density",
   name: "Section Density",
@@ -7376,7 +6801,7 @@ var check34 = {
     const results = [];
     for (const file of files) {
       try {
-        const content = await readFile18(file, "utf8");
+        const content = await readFile17(file, "utf8");
         const lines = content.split(`
 `);
         let currentSectionStart = 0;
@@ -7545,7 +6970,7 @@ import { existsSync as existsSync9 } from "node:fs";
 import { dirname as dirname4, join as join3, resolve as resolve7 } from "node:path";
 
 // src/lib/output-paths.ts
-import path7 from "node:path";
+import path6 from "node:path";
 
 // src/lib/slug.ts
 function slugify(name, fallback = "") {
@@ -7563,7 +6988,7 @@ function bookSlug(title) {
   return slugify(title ?? "", "book");
 }
 function resolveOutputDir(manifestDir, title) {
-  return path7.resolve(manifestDir, DIST_DIRNAME, bookSlug(title));
+  return path6.resolve(manifestDir, DIST_DIRNAME, bookSlug(title));
 }
 function artifactName(title, format) {
   return `${bookSlug(title)}-${format}.pdf`;
@@ -7573,7 +6998,7 @@ function artifactName(title, format) {
 var BOOK_HTML_FILENAME = "book.html";
 
 // src/lib/markdown/index.ts
-import { readdir as readdir3, readFile as readFile19, writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
+import { readdir as readdir2, readFile as readFile18, writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
 
 // src/lib/remote-auth/sync-messages.ts
 function isOnlineSibling(filepath) {
@@ -7680,7 +7105,7 @@ ${bodyContent}
 async function resolveActiveMarkdownFiles(inputDir, configuredFiles) {
   if (configuredFiles && configuredFiles.length > 0)
     return configuredFiles;
-  return (await readdir3(inputDir)).filter((f) => f.endsWith(".md") && !isOnlineSibling(f)).sort();
+  return (await readdir2(inputDir)).filter((f) => f.endsWith(".md") && !isOnlineSibling(f)).sort();
 }
 async function renderChapters(inputDir, opts = {}) {
   const styles = await resolveActiveStyles(inputDir, opts.styles);
@@ -7719,7 +7144,7 @@ ${css.trim()}
   }
   return assembleBookHtml({
     files,
-    readText: (relPath) => readFile19(join2(inputDir, canonicalChapterId(relPath)), "utf-8"),
+    readText: (relPath) => readFile18(join2(inputDir, canonicalChapterId(relPath)), "utf-8"),
     projectCss: inlined.css,
     preloadImages: cssAssetCopies.map((c) => c.to),
     title: opts.title,
@@ -7750,7 +7175,7 @@ async function renderChaptersToFile(inputDir, outDir, opts = {}) {
 }
 
 // src/lib/markdownlint-fix.ts
-import { readFile as readFile20, writeFile as writeFile3 } from "node:fs/promises";
+import { readFile as readFile19, writeFile as writeFile3 } from "node:fs/promises";
 import { applyFixes } from "markdownlint";
 import { lint as lint2 } from "markdownlint/sync";
 async function uncommittedAmong(inputDir, files) {
@@ -7790,7 +7215,7 @@ async function applyMarkdownlintFixes(ctx) {
   for (const [file, violations] of Object.entries(results)) {
     if (!Array.isArray(violations) || violations.length === 0)
       continue;
-    const before = await readFile20(file, "utf8");
+    const before = await readFile19(file, "utf8");
     const after = applyFixes(before, violations);
     if (after !== before)
       pending.push({ file, content: after });
@@ -8286,7 +7711,7 @@ function buildPdfSummaryLines(results) {
 }
 
 // src/lib/build-runner.ts
-import path9 from "node:path";
+import path8 from "node:path";
 import fs2 from "node:fs";
 import fsp2 from "node:fs/promises";
 import os2 from "node:os";
@@ -8294,9 +7719,9 @@ import { randomBytes } from "node:crypto";
 
 // src/lib/build-fingerprint.ts
 import * as fs from "node:fs";
-import { mkdir as mkdir3, readFile as readFile21, writeFile as writeFile4 } from "node:fs/promises";
-import { createHash as createHash5 } from "node:crypto";
-import path8 from "node:path";
+import { mkdir as mkdir3, readFile as readFile20, writeFile as writeFile4 } from "node:fs/promises";
+import { createHash as createHash4 } from "node:crypto";
+import path7 from "node:path";
 import git from "isomorphic-git";
 var FINGERPRINT_FILENAME = "build-fingerprint.json";
 var VERSION_TIMEOUT_MS = 4000;
@@ -8345,7 +7770,7 @@ async function getGitRevision(sourceDir) {
   const candidateDirs = [sourceDir, process.cwd()].filter((v) => Boolean(v));
   const seen = new Set;
   for (const dir of candidateDirs) {
-    const abs = path8.resolve(dir);
+    const abs = path7.resolve(dir);
     if (seen.has(abs))
       continue;
     seen.add(abs);
@@ -8381,10 +7806,10 @@ async function getEngineBundleHash() {
       getAssetPath("engine/gutterpress-agent.js")
     ]);
     const [viewerBytes, agentBytes] = await Promise.all([
-      readFile21(viewerPath),
-      readFile21(agentPath)
+      readFile20(viewerPath),
+      readFile20(agentPath)
     ]);
-    const hash = createHash5("sha256");
+    const hash = createHash4("sha256");
     hash.update(viewerBytes);
     hash.update(agentBytes);
     return hash.digest("hex").slice(0, 12);
@@ -8430,8 +7855,8 @@ function sanitizeArgs(args) {
   return out;
 }
 async function writeBuildFingerprint(input) {
-  const outputDir = path8.resolve(input.outputDir);
-  const outPath = path8.join(outputDir, FINGERPRINT_FILENAME);
+  const outputDir = path7.resolve(input.outputDir);
+  const outPath = path7.join(outputDir, FINGERPRINT_FILENAME);
   const [tools, sourceRevision] = await Promise.all([
     getToolVersions(),
     getGitRevision(input.sourceDir)
@@ -8447,7 +7872,7 @@ async function writeBuildFingerprint(input) {
         iccPath: input.pdfx.iccPath,
         stripAnnotations: input.pdfx.stripAnnotations
       },
-      outputDir: input.recordedOutputDir ? path8.resolve(input.recordedOutputDir) : outputDir
+      outputDir: input.recordedOutputDir ? path7.resolve(input.recordedOutputDir) : outputDir
     },
     sourceRevision,
     tools
@@ -8527,18 +7952,18 @@ function splitOutPath(outArg, format) {
   if (typeof outArg !== "string" || outArg.length === 0) {
     return { outDir: undefined, pdfFileOverride: null };
   }
-  const resolved = path9.resolve(outArg);
+  const resolved = path8.resolve(outArg);
   if ((format === "pdf" || format === "pdfx") && resolved.toLowerCase().endsWith(".pdf")) {
-    return { outDir: path9.dirname(resolved), pdfFileOverride: resolved };
+    return { outDir: path8.dirname(resolved), pdfFileOverride: resolved };
   }
   return { outDir: resolved, pdfFileOverride: null };
 }
 function layoutWarningKey(file, line, message) {
-  return `${path9.resolve(file)}\x00${line ?? 0}\x00${message}`;
+  return `${path8.resolve(file)}\x00${line ?? 0}\x00${message}`;
 }
 async function resolveBuildContext(opts) {
   const { format } = opts;
-  const inputDir = path9.resolve(opts.inputDir);
+  const inputDir = path8.resolve(opts.inputDir);
   const { manifest, manifestDir, manifestPath } = await loadManifestWithPath(opts.manifestPath ?? inputDir, { explicit: opts.manifestPath !== undefined });
   if (manifestPath === null) {
     throw new UsageError(`No book manifest found in ${inputDir}. Looked for ${MANIFEST_FILENAMES.join(" or ")}. ` + "Run from your book folder or pass that folder with `gutterpress build <book-dir>`. " + "For a custom manifest filename, pass `--manifest <path>`.");
@@ -8552,10 +7977,10 @@ async function resolveBuildContext(opts) {
     title: opts.title,
     pdfx: pdfxConfigOverride
   }, manifest);
-  const target = opts.pdfFileOverride ? { kind: "file", file: path9.resolve(opts.pdfFileOverride) } : opts.outDir ? { kind: "directory", dir: opts.outDir } : { kind: "project", dir: resolveOutputDir(manifestDir, config.title) };
-  const outDir = target.kind === "file" ? path9.dirname(target.file) : target.dir;
+  const target = opts.pdfFileOverride ? { kind: "file", file: path8.resolve(opts.pdfFileOverride) } : opts.outDir ? { kind: "directory", dir: opts.outDir } : { kind: "project", dir: resolveOutputDir(manifestDir, config.title) };
+  const outDir = target.kind === "file" ? path8.dirname(target.file) : target.dir;
   const gates = computeGates(format, opts, config);
-  const workDir = target.kind === "project" ? path9.join(path9.dirname(target.dir), `.${path9.basename(target.dir)}-build-${randomBytes(6).toString("hex")}`) : path9.join(os2.tmpdir(), `gutterpress-build-${randomBytes(6).toString("hex")}`);
+  const workDir = target.kind === "project" ? path8.join(path8.dirname(target.dir), `.${path8.basename(target.dir)}-build-${randomBytes(6).toString("hex")}`) : path8.join(os2.tmpdir(), `gutterpress-build-${randomBytes(6).toString("hex")}`);
   return {
     opts,
     format,
@@ -8625,7 +8050,7 @@ async function renderBook(ctx) {
     pluginStyles,
     onChapterWarnings: (file, warnings) => {
       for (const w of warnings) {
-        const key = layoutWarningKey(path9.resolve(renderDir, file), w.line, w.message);
+        const key = layoutWarningKey(path8.resolve(renderDir, file), w.line, w.message);
         if (!ctx.prevalidatedLayoutWarningKeys.has(key)) {
           log.warn(`  ${file}, line ${w.line}: ${w.message}`);
         }
@@ -8664,9 +8089,9 @@ async function renderBook(ctx) {
   return htmlFile;
 }
 async function resolveIccProfile(icc, manifestDir, explicitIccPath) {
-  const iccCandidates = path9.isAbsolute(icc) ? [icc] : [path9.resolve(manifestDir, icc), path9.resolve(icc)];
+  const iccCandidates = path8.isAbsolute(icc) ? [icc] : [path8.resolve(manifestDir, icc), path8.resolve(icc)];
   let effectiveIccPath = iccCandidates.find((candidate) => fs2.existsSync(candidate)) ?? null;
-  if (!effectiveIccPath && !explicitIccPath && path9.basename(icc) === "CGATS21_CRPC1.icc") {
+  if (!effectiveIccPath && !explicitIccPath && path8.basename(icc) === "CGATS21_CRPC1.icc") {
     effectiveIccPath = await getAssetPath("profiles/CGATS21_CRPC1.icc");
   }
   if (!effectiveIccPath) {
@@ -8682,13 +8107,13 @@ async function finalizeBuild(ctx, fingerprint, wroteMessage, paths, artifactName
   });
   await publishBuild(ctx, artifactName2);
   const delivered = ctx.target.kind === "project" || ctx.target.kind === "directory" && ctx.format === "html";
-  const fingerprintPath = delivered ? path9.join(ctx.outDir, path9.basename(workFingerprint)) : null;
+  const fingerprintPath = delivered ? path8.join(ctx.outDir, path8.basename(workFingerprint)) : null;
   log.success(wroteMessage);
   if (fingerprintPath)
     log.info(`Fingerprint: ${fingerprintPath}`);
   return {
     outDir: ctx.outDir,
-    htmlPath: delivered ? path9.join(ctx.outDir, path9.relative(ctx.workDir, paths.htmlPath)) : null,
+    htmlPath: delivered ? path8.join(ctx.outDir, path8.relative(ctx.workDir, paths.htmlPath)) : null,
     pdfPath: paths.pdfPath,
     fingerprintPath,
     diagnostics
@@ -8699,7 +8124,7 @@ async function publishToDirectory(workDir, targetDir, format, artifactName2) {
   if (format !== "html") {
     if (!artifactName2)
       throw new BuildError("No artifact to write for this format", 1);
-    await fsp2.copyFile(path9.join(workDir, artifactName2), path9.join(targetDir, artifactName2));
+    await fsp2.copyFile(path8.join(workDir, artifactName2), path8.join(targetDir, artifactName2));
     return;
   }
   await fsp2.cp(workDir, targetDir, { recursive: true, force: true });
@@ -8709,8 +8134,8 @@ async function publishBuild(ctx, artifactName2) {
   if (target.kind === "file") {
     if (!artifactName2)
       throw new BuildError("No artifact to write for this format", 1);
-    await fsp2.mkdir(path9.dirname(target.file), { recursive: true });
-    await fsp2.copyFile(path9.join(workDir, artifactName2), target.file);
+    await fsp2.mkdir(path8.dirname(target.file), { recursive: true });
+    await fsp2.copyFile(path8.join(workDir, artifactName2), target.file);
     return;
   }
   if (target.kind === "directory") {
@@ -8718,12 +8143,12 @@ async function publishBuild(ctx, artifactName2) {
     return;
   }
   for (const name of await listPdfs(target.dir)) {
-    if (!fs2.existsSync(path9.join(workDir, name))) {
-      await fsp2.rename(path9.join(target.dir, name), path9.join(workDir, name));
+    if (!fs2.existsSync(path8.join(workDir, name))) {
+      await fsp2.rename(path8.join(target.dir, name), path8.join(workDir, name));
     }
   }
   await fsp2.rm(target.dir, { recursive: true, force: true });
-  await fsp2.mkdir(path9.dirname(target.dir), { recursive: true });
+  await fsp2.mkdir(path8.dirname(target.dir), { recursive: true });
   await fsp2.rename(workDir, target.dir);
 }
 async function listPdfs(dir) {
@@ -8739,7 +8164,7 @@ class HtmlOutput {
     const { workDir, outDir, inputDir, config, opts } = ctx;
     log.info("Shipping self-contained HTML + viewer bundle (native engine)");
     await shipViewerHtml(htmlFile, workDir);
-    await fsp2.writeFile(path9.join(workDir, "index.html"), `<!DOCTYPE html><html><head><meta charset="utf-8"><meta http-equiv="refresh" content="0;url=book.html"><title>Gutterpress</title></head><body></body></html>
+    await fsp2.writeFile(path8.join(workDir, "index.html"), `<!DOCTYPE html><html><head><meta charset="utf-8"><meta http-equiv="refresh" content="0;url=book.html"><title>Gutterpress</title></head><body></body></html>
 `, "utf-8");
     return finalizeBuild(ctx, {
       command: "build",
@@ -8752,7 +8177,7 @@ class HtmlOutput {
         iccPath: null,
         stripAnnotations: null
       }
-    }, `Wrote: ${path9.join(outDir, BOOK_HTML)}`, { htmlPath: htmlFile, pdfPath: null });
+    }, `Wrote: ${path8.join(outDir, BOOK_HTML)}`, { htmlPath: htmlFile, pdfPath: null });
   }
 }
 
@@ -8761,12 +8186,12 @@ class PdfOutput {
     const { workDir, outDir, inputDir, config, opts, format, manifestDir, gates } = ctx;
     const pdfxMode = format === "pdfx" ? opts.pdfxFlavor ?? config.pdfx.flavor : undefined;
     const pdfName = artifactName(config.title, pdfxMode ? "pdfx" : "pdf");
-    const pdfFile = path9.join(workDir, pdfName);
-    const reportedPdf = ctx.target.kind === "file" ? ctx.target.file : path9.join(outDir, pdfName);
+    const pdfFile = path8.join(workDir, pdfName);
+    const reportedPdf = ctx.target.kind === "file" ? ctx.target.file : path8.join(outDir, pdfName);
     const stage = await createStageRoot();
     try {
-      const rawPdf = pdfxMode ? path9.join(stage, "raw.pdf") : path9.resolve(pdfFile);
-      await fsp2.mkdir(path9.dirname(path9.resolve(pdfFile)), { recursive: true });
+      const rawPdf = pdfxMode ? path8.join(stage, "raw.pdf") : path8.resolve(pdfFile);
+      await fsp2.mkdir(path8.dirname(path8.resolve(pdfFile)), { recursive: true });
       log.info("Rendering HTML to PDF via the Gutterpress engine (native Chromium pagination)");
       const { buildNativePdf } = await import("./engine-amxqsfka.js");
       const engineDiagnostics = await buildNativePdf(htmlFile, rawPdf, {
@@ -8799,7 +8224,7 @@ class PdfOutput {
           await stripAnnotations(rawPdf, stage);
         }
         log.info(`Converting to CMYK PDF/X (${pdfxMode})`);
-        await convertToPdfxCmyk(rawPdf, path9.resolve(pdfFile), {
+        await convertToPdfxCmyk(rawPdf, path8.resolve(pdfFile), {
           iccPath: effectiveIccPath,
           pdfx: pdfxMode,
           title: config.title,
@@ -8888,10 +8313,10 @@ function openPath(filePath) {
 }
 
 // src/preview/lifecycle.ts
-import path11 from "path";
+import path10 from "path";
 import { tmpdir as tmpdir2 } from "os";
 import { randomBytes as randomBytes2 } from "crypto";
-import { readdir as readdir4, readFile as readFile22, writeFile as writeFile5 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile21, writeFile as writeFile5 } from "node:fs/promises";
 
 // src/utils/file-utils.ts
 import { promises as fs3 } from "fs";
@@ -8913,7 +8338,7 @@ async function mkdir4(dirPath) {
 // src/preview/file-watcher.ts
 import { watch } from "chokidar";
 import fsp3 from "node:fs/promises";
-import path10 from "path";
+import path9 from "path";
 var EMPTY_BOOK_HTML = `<!doctype html>
 <html lang="en">
 <head>
@@ -8966,7 +8391,7 @@ function injectPreviewScripts(html, pageIsolateChapters) {
 async function generateAndWriteHtml(inputPath, tempDir, config, cssAssets) {
   if (!inputPath) {
     cssAssets.clear();
-    await fsp3.writeFile(path10.join(tempDir, BOOK_HTML_FILENAME), EMPTY_BOOK_HTML, "utf-8");
+    await fsp3.writeFile(path9.join(tempDir, BOOK_HTML_FILENAME), EMPTY_BOOK_HTML, "utf-8");
     return;
   }
   const nextAssets = new Map;
@@ -8981,7 +8406,7 @@ async function generateAndWriteHtml(inputPath, tempDir, config, cssAssets) {
   cssAssets.clear();
   for (const [to, from] of nextAssets)
     cssAssets.set(to, from);
-  await fsp3.writeFile(path10.join(tempDir, BOOK_HTML_FILENAME), injectPreviewScripts(html, false), "utf-8");
+  await fsp3.writeFile(path9.join(tempDir, BOOK_HTML_FILENAME), injectPreviewScripts(html, false), "utf-8");
 }
 async function renderChapterPreviewHtml(inputPath, file, config) {
   const html = await renderPreviewBook(inputPath, config, {
@@ -8993,12 +8418,12 @@ async function renderChapterPreviewHtml(inputPath, file, config) {
 function describeChanges(changes, inputResolved) {
   const files = [];
   for (const [changedPath, event] of changes) {
-    const relative2 = path10.relative(inputResolved, path10.resolve(changedPath));
-    if (relative2 === "" || relative2 === ".." || relative2.startsWith(`..${path10.sep}`) || path10.isAbsolute(relative2))
+    const relative2 = path9.relative(inputResolved, path9.resolve(changedPath));
+    if (relative2 === "" || relative2 === ".." || relative2.startsWith(`..${path9.sep}`) || path9.isAbsolute(relative2))
       continue;
     files.push({
       relativePath: canonicalChapterId(relative2),
-      ext: path10.extname(changedPath).toLowerCase(),
+      ext: path9.extname(changedPath).toLowerCase(),
       event
     });
   }
@@ -9050,23 +8475,23 @@ function isIgnoredWatchPath(candidatePath, projectRoot) {
   return isDotPathUnderRoot(candidatePath, projectRoot) || isGeneratedProjectPath(relative2);
 }
 function isExternalWatchCandidate(candidatePath, targets) {
-  const candidate = path10.resolve(candidatePath);
+  const candidate = path9.resolve(candidatePath);
   for (const rawTarget of targets) {
-    const target = path10.resolve(rawTarget);
-    const rel = path10.relative(candidate, target);
-    if (rel === "" || rel !== ".." && !rel.startsWith(`..${path10.sep}`) && !path10.isAbsolute(rel))
+    const target = path9.resolve(rawTarget);
+    const rel = path9.relative(candidate, target);
+    if (rel === "" || rel !== ".." && !rel.startsWith(`..${path9.sep}`) && !path9.isAbsolute(rel))
       return true;
   }
   return false;
 }
 async function nearestExistingDirectory(start) {
-  let current = path10.resolve(start);
+  let current = path9.resolve(start);
   while (true) {
     try {
       if ((await fsp3.stat(current)).isDirectory())
         return current;
     } catch {}
-    const parent = path10.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current)
       return current;
     current = parent;
@@ -9075,7 +8500,7 @@ async function nearestExistingDirectory(start) {
 async function externalWatchRoots(targets) {
   const roots = new Set;
   for (const target of targets) {
-    roots.add(await nearestExistingDirectory(path10.dirname(path10.resolve(target))));
+    roots.add(await nearestExistingDirectory(path9.dirname(path9.resolve(target))));
   }
   return [...roots];
 }
@@ -9089,19 +8514,19 @@ async function extensionFolderFiles(dir) {
   const meta = await readExtensionMeta(dir);
   const entry = extensionEntry(meta);
   return [
-    path10.join(dir, EXTENSION_MANIFEST_FILENAME),
-    ...entry ? [path10.resolve(dir, entry)] : [],
+    path9.join(dir, EXTENSION_MANIFEST_FILENAME),
+    ...entry ? [path9.resolve(dir, entry)] : [],
     ...await collectStyleDependencies(dir, extensionStyleList(meta))
   ];
 }
 async function externalWatchTargets(projectDir, config) {
-  const root = path10.resolve(projectDir);
+  const root = path9.resolve(projectDir);
   let canonicalRoot = root;
   try {
     canonicalRoot = await fsp3.realpath(root);
   } catch {}
   const styles = await resolveActiveStyles(root, config.styles);
-  const extensionPaths = (config.extensions ?? []).map((p) => p.path).filter((p) => !!p).map((p) => path10.resolve(root, p));
+  const extensionPaths = (config.extensions ?? []).map((p) => p.path).filter((p) => !!p).map((p) => path9.resolve(root, p));
   const candidates = [
     ...await collectStyleDependencies(root, styles),
     ...extensionPaths,
@@ -9109,17 +8534,17 @@ async function externalWatchTargets(projectDir, config) {
   ];
   const external = new Set;
   for (const abs of candidates) {
-    const authoredPath = path10.resolve(abs);
-    const authoredRel = path10.relative(root, authoredPath);
-    if (authoredRel !== "" && (authoredRel === ".." || authoredRel.startsWith(`..${path10.sep}`) || path10.isAbsolute(authoredRel))) {
+    const authoredPath = path9.resolve(abs);
+    const authoredRel = path9.relative(root, authoredPath);
+    if (authoredRel !== "" && (authoredRel === ".." || authoredRel.startsWith(`..${path9.sep}`) || path9.isAbsolute(authoredRel))) {
       external.add(authoredPath);
     }
     let canonicalPath = authoredPath;
     try {
       canonicalPath = await fsp3.realpath(canonicalPath);
     } catch {}
-    const rel = path10.relative(canonicalRoot, canonicalPath);
-    if (rel === "" || rel !== ".." && !rel.startsWith(`..${path10.sep}`) && !path10.isAbsolute(rel))
+    const rel = path9.relative(canonicalRoot, canonicalPath);
+    if (rel === "" || rel !== ".." && !rel.startsWith(`..${path9.sep}`) && !path9.isAbsolute(rel))
       continue;
     external.add(canonicalPath);
   }
@@ -9146,7 +8571,7 @@ async function addAndAwaitWatch(watcher, roots) {
   }
 }
 function createFileWatcher(state) {
-  const inputResolved = path10.resolve(state.currentInputPath);
+  const inputResolved = path9.resolve(state.currentInputPath);
   const watcher = watch(inputResolved, {
     persistent: true,
     ignoreInitial: true,
@@ -9186,7 +8611,7 @@ function createFileWatcher(state) {
   async function recordChange(event, filePath) {
     if (closed)
       return;
-    const target = path10.resolve(filePath);
+    const target = path9.resolve(filePath);
     const settled = settledWrites.get(target);
     if (settled && event !== "unlink" && Date.now() <= settled.expiresAt) {
       const diskContent = await fsp3.readFile(target, "utf8").catch(() => null);
@@ -9207,7 +8632,7 @@ function createFileWatcher(state) {
     recordChange(event, filePath);
   });
   externalWatcher.on("all", (event, filePath) => {
-    const target = path10.resolve(filePath);
+    const target = path9.resolve(filePath);
     if (!desiredExternals.has(target))
       return;
     if (event === "add" && suppressInitialExternalAdds.delete(target))
@@ -9215,8 +8640,8 @@ function createFileWatcher(state) {
     recordChange(event, target);
   });
   function isWatchedSource(target) {
-    const rel = path10.relative(inputResolved, target);
-    const inProject = rel === "" || rel !== ".." && !rel.startsWith(`..${path10.sep}`) && !path10.isAbsolute(rel);
+    const rel = path9.relative(inputResolved, target);
+    const inProject = rel === "" || rel !== ".." && !rel.startsWith(`..${path9.sep}`) && !path9.isAbsolute(rel);
     if (inProject)
       return !isIgnoredWatchPath(target, inputResolved);
     return desiredExternals.has(target);
@@ -9241,7 +8666,7 @@ function createFileWatcher(state) {
   state.notifySettledWrite = (filePath, writtenContent) => {
     if (closed)
       return;
-    const target = path10.resolve(filePath);
+    const target = path9.resolve(filePath);
     if (isWatchedSource(target)) {
       acceptSettledWrite(target, writtenContent);
       return;
@@ -9262,7 +8687,7 @@ function createFileWatcher(state) {
       return;
     let nextTargets;
     try {
-      nextTargets = new Set((await externalWatchTargets(inputResolved, state.config)).map((target) => path10.resolve(target)));
+      nextTargets = new Set((await externalWatchTargets(inputResolved, state.config)).map((target) => path9.resolve(target)));
     } catch (err) {
       debug(`Could not resolve external watch targets: ${err}`);
       return;
@@ -9394,7 +8819,7 @@ async function stopFileWatcher(state) {
 }
 
 // src/preview/lifecycle.ts
-var TEMP_DIR_BASE = path11.join(tmpdir2(), "gutterpress-preview");
+var TEMP_DIR_BASE = path10.join(tmpdir2(), "gutterpress-preview");
 var PID_FILE_NAME = ".gutterpress.pid";
 function isProcessAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0)
@@ -9409,15 +8834,15 @@ function isProcessAlive(pid) {
 async function cleanupOrphanTempDirs() {
   let entries;
   try {
-    entries = await readdir4(TEMP_DIR_BASE);
+    entries = await readdir3(TEMP_DIR_BASE);
   } catch {
     return;
   }
   for (const entry of entries) {
-    const dir = path11.join(TEMP_DIR_BASE, entry);
-    const pidFile = path11.join(dir, PID_FILE_NAME);
+    const dir = path10.join(TEMP_DIR_BASE, entry);
+    const pidFile = path10.join(dir, PID_FILE_NAME);
     try {
-      const raw = await readFile22(pidFile, "utf8");
+      const raw = await readFile21(pidFile, "utf8");
       const pid = parseInt(raw.trim(), 10);
       if (!isProcessAlive(pid)) {
         debug(`Removing orphan temp dir ${dir} (pid ${pid} not alive)`);
@@ -9429,10 +8854,10 @@ async function cleanupOrphanTempDirs() {
 async function initializePreviewDirectories() {
   await cleanupOrphanTempDirs();
   const tempDirSuffix = randomBytes2(8).toString("hex");
-  const tempDir = path11.join(TEMP_DIR_BASE, tempDirSuffix);
+  const tempDir = path10.join(TEMP_DIR_BASE, tempDirSuffix);
   await mkdir4(tempDir);
   debug(`Created temporary directory: ${tempDir}`);
-  await writeFile5(path11.join(tempDir, PID_FILE_NAME), `${process.pid}
+  await writeFile5(path10.join(tempDir, PID_FILE_NAME), `${process.pid}
 `, "utf8");
   return tempDir;
 }
@@ -9522,13 +8947,13 @@ function createServerState(inputPath, tempDir, config, options) {
 // src/preview/http-server.ts
 import http from "node:http";
 import net from "node:net";
-import { createHash as createHash6, randomUUID } from "node:crypto";
-import { readFile as readFile23, stat as stat4 } from "node:fs/promises";
-import path13 from "path";
+import { createHash as createHash5, randomUUID } from "node:crypto";
+import { readFile as readFile22, stat as stat4 } from "node:fs/promises";
+import path12 from "path";
 import { WebSocket, WebSocketServer } from "ws";
 
 // src/lib/static-serve.ts
-import path12 from "node:path";
+import path11 from "node:path";
 var STATIC_MIME = {
   ".html": "text/html; charset=utf-8",
   ".htm": "text/html; charset=utf-8",
@@ -9550,9 +8975,9 @@ var STATIC_MIME = {
   ".otf": "font/otf"
 };
 function resolveWithinRoot(relPath, root) {
-  const resolvedRoot = path12.resolve(root);
-  const candidate = path12.resolve(resolvedRoot, "." + (relPath.startsWith("/") ? relPath : "/" + relPath));
-  if (candidate !== resolvedRoot && !candidate.startsWith(resolvedRoot + path12.sep)) {
+  const resolvedRoot = path11.resolve(root);
+  const candidate = path11.resolve(resolvedRoot, "." + (relPath.startsWith("/") ? relPath : "/" + relPath));
+  if (candidate !== resolvedRoot && !candidate.startsWith(resolvedRoot + path11.sep)) {
     return null;
   }
   return candidate;
@@ -9805,7 +9230,7 @@ async function serveStatic(absPath, res, cacheControl = "no-store", extraHeaders
   try {
     const s = await stat4(filePath);
     if (s.isDirectory())
-      filePath = path13.join(filePath, "index.html");
+      filePath = path12.join(filePath, "index.html");
   } catch {
     res.writeHead(404);
     res.end("Not Found");
@@ -9813,7 +9238,7 @@ async function serveStatic(absPath, res, cacheControl = "no-store", extraHeaders
   }
   let data;
   try {
-    data = await readFile23(filePath);
+    data = await readFile22(filePath);
   } catch {
     res.writeHead(404);
     res.end("Not Found");
@@ -9826,7 +9251,7 @@ async function serveStatic(absPath, res, cacheControl = "no-store", extraHeaders
     res.end(withHmr);
     return;
   }
-  const ct = STATIC_MIME[path13.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+  const ct = STATIC_MIME[path12.extname(filePath).toLowerCase()] ?? "application/octet-stream";
   res.writeHead(200, { "Content-Type": ct, "Cache-Control": cacheControl, ...extraHeaders });
   res.end(data);
 }
@@ -9836,7 +9261,7 @@ var EMBEDDED_CACHE_CONTROL = "public, no-cache";
 var EMBEDDED_ETAG = `"gutterpress-${PACKAGE_VERSION}"`;
 var PROJECT_ASSET_CACHE_CONTROL = "private, no-cache";
 async function serveRevalidatedStatic(req, absPath, res, validators) {
-  const extension = path13.extname(absPath).toLowerCase();
+  const extension = path12.extname(absPath).toLowerCase();
   if (extension === ".html" || extension === ".htm") {
     await serveStatic(absPath, res);
     return;
@@ -9863,12 +9288,12 @@ async function serveRevalidatedStatic(req, absPath, res, validators) {
   let data;
   if (!validator || validator.stamp !== stamp) {
     try {
-      data = await readFile23(absPath);
+      data = await readFile22(absPath);
     } catch {
       await serveStatic(absPath, res);
       return;
     }
-    const digest = createHash6("sha256").update(data).digest("base64url");
+    const digest = createHash5("sha256").update(data).digest("base64url");
     validator = { stamp, etag: `"gutterpress-file-${digest}"` };
     validators.set(absPath, validator);
   }
@@ -10002,7 +9427,7 @@ async function createPreviewServer(state, port) {
       const file = rawFile ? canonicalChapterId(rawFile) : "";
       const revision = Number(url.searchParams.get("revision"));
       const configuredFiles = state.config.source?.files;
-      if (!file || !state.currentInputPath || !incrementalPreviewEnabled() || !Number.isSafeInteger(revision) || revision !== reloadRevision || path13.extname(file).toLowerCase() !== ".md" || hasDotSegment(file) || !resolveWithinRoot(file, state.currentInputPath) || Array.isArray(configuredFiles) && configuredFiles.length > 0 && !configuredFiles.some((configured) => canonicalChapterId(configured) === file)) {
+      if (!file || !state.currentInputPath || !incrementalPreviewEnabled() || !Number.isSafeInteger(revision) || revision !== reloadRevision || path12.extname(file).toLowerCase() !== ".md" || hasDotSegment(file) || !resolveWithinRoot(file, state.currentInputPath) || Array.isArray(configuredFiles) && configuredFiles.length > 0 && !configuredFiles.some((configured) => canonicalChapterId(configured) === file)) {
         res.writeHead(400);
         res.end("Bad Request");
         return;
@@ -10202,25 +9627,25 @@ async function startPreviewServer(options) {
 }
 
 // src/lib/project-scaffold.ts
-import { access, copyFile, cp as cp2, mkdir as mkdir6, readdir as readdir5, readFile as readFile25, stat as stat5, writeFile as writeFile6 } from "node:fs/promises";
+import { access, copyFile, cp as cp2, mkdir as mkdir6, readdir as readdir4, readFile as readFile24, stat as stat5, writeFile as writeFile6 } from "node:fs/promises";
 import { constants as FS, existsSync as existsSync11 } from "node:fs";
-import path15 from "node:path";
+import path14 from "node:path";
 
 // src/lib/manifest-doc.ts
 import { existsSync as existsSync10 } from "node:fs";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir5, open, readFile as readFile24, rename, rm as rm2 } from "node:fs/promises";
-import path14 from "node:path";
+import { mkdir as mkdir5, open, readFile as readFile23, rename, rm as rm2 } from "node:fs/promises";
+import path13 from "node:path";
 import { parseDocument, isSeq, YAMLSeq } from "yaml";
 function resolveManifestPath(projectDir) {
-  const existing = MANIFEST_FILENAMES.find((name) => existsSync10(path14.join(projectDir, name)));
-  return path14.join(projectDir, existing ?? MANIFEST_FILENAMES[0]);
+  const existing = MANIFEST_FILENAMES.find((name) => existsSync10(path13.join(projectDir, name)));
+  return path13.join(projectDir, existing ?? MANIFEST_FILENAMES[0]);
 }
 async function loadManifestDoc(projectDir) {
   const file = resolveManifestPath(projectDir);
   let text = "";
   try {
-    text = await readFile24(file, "utf8");
+    text = await readFile23(file, "utf8");
   } catch (error2) {
     if (error2.code !== "ENOENT")
       throw error2;
@@ -10228,9 +9653,9 @@ async function loadManifestDoc(projectDir) {
   return { doc: parseDocument(text), file };
 }
 async function writeManifestDoc(file, doc) {
-  const dir = path14.dirname(file);
+  const dir = path13.dirname(file);
   await mkdir5(dir, { recursive: true });
-  const temporary = path14.join(dir, `.${path14.basename(file)}.tmp-${process.pid}-${randomUUID2()}`);
+  const temporary = path13.join(dir, `.${path13.basename(file)}.tmp-${process.pid}-${randomUUID2()}`);
   try {
     const handle = await open(temporary, "wx", 438);
     try {
@@ -10332,7 +9757,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 || !path15.isAbsolute(parentDir)) {
+  if (!parentDir || !path14.isAbsolute(parentDir)) {
     throw new CreateProjectErrorImpl("parent-not-writable", "The save location must be an absolute path.");
   }
   try {
@@ -10340,7 +9765,7 @@ async function scaffoldProject(options) {
   } catch {
     throw new CreateProjectErrorImpl("parent-not-writable", `The chosen save location can't be written to: ${parentDir}`);
   }
-  const projectDir = path15.join(parentDir, folderName);
+  const projectDir = path14.join(parentDir, folderName);
   let targetExists = true;
   try {
     await access(projectDir, FS.F_OK);
@@ -10357,21 +9782,21 @@ async function scaffoldProject(options) {
   try {
     await mkdir6(projectDir, { recursive: true });
     if (customTemplateDir) {
-      const entries = await readdir5(customTemplateDir, { withFileTypes: true });
+      const entries = await readdir4(customTemplateDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name === ".gutterpress-template.json")
           continue;
-        await cp2(path15.join(customTemplateDir, entry.name), path15.join(projectDir, entry.name), { recursive: true });
+        await cp2(path14.join(customTemplateDir, entry.name), path14.join(projectDir, entry.name), { recursive: true });
       }
-      await mkdir6(path15.join(projectDir, "assets"), { recursive: true });
+      await mkdir6(path14.join(projectDir, "assets"), { recursive: true });
     } else {
       const tplManifest = await getAssetPath(`templates/${template}/manifest.yaml`);
       const tplChapter = await getAssetPath(`templates/${template}/chapter-01.md`);
-      await mkdir6(path15.join(projectDir, "assets"), { recursive: true });
-      await copyFile(tplManifest, path15.join(projectDir, MANIFEST_FILENAMES[0]));
-      await copyFile(tplChapter, path15.join(projectDir, "chapter-01.md"));
-      await mkdir6(path15.join(projectDir, "styles"), { recursive: true });
-      await writeFile6(path15.join(projectDir, "styles", "book.css"), starterOverridesCss(), "utf8");
+      await mkdir6(path14.join(projectDir, "assets"), { recursive: true });
+      await copyFile(tplManifest, path14.join(projectDir, MANIFEST_FILENAMES[0]));
+      await copyFile(tplChapter, path14.join(projectDir, "chapter-01.md"));
+      await mkdir6(path14.join(projectDir, "styles"), { recursive: true });
+      await writeFile6(path14.join(projectDir, "styles", "book.css"), starterOverridesCss(), "utf8");
     }
   } catch (e) {
     throw new CreateProjectErrorImpl("scaffold-io", `Could not create the book files: ${e instanceof Error ? e.message : String(e)}`);
@@ -10381,13 +9806,13 @@ async function scaffoldProject(options) {
   } catch (e) {
     throw new CreateProjectErrorImpl("scaffold-io", `Could not write .gitignore: ${e instanceof Error ? e.message : String(e)}`);
   }
-  const manifestPath = MANIFEST_FILENAMES.map((name2) => path15.join(projectDir, name2)).find(existsSync11) ?? path15.join(projectDir, MANIFEST_FILENAMES[0]);
+  const manifestPath = MANIFEST_FILENAMES.map((name2) => path14.join(projectDir, name2)).find(existsSync11) ?? path14.join(projectDir, MANIFEST_FILENAMES[0]);
   const author = (options.author ?? "").trim() || DEFAULT_AUTHOR;
   const substitutions = {
     "{{TITLE}}": escapeYamlScalar(name),
     "{{AUTHOR}}": escapeYamlScalar(author)
   };
-  let openFile = path15.join(projectDir, "chapter-01.md");
+  let openFile = path14.join(projectDir, "chapter-01.md");
   try {
     await fillTemplateFile(manifestPath, substitutions);
     if (preset) {
@@ -10408,7 +9833,7 @@ async function scaffoldProject(options) {
     }
     const firstSource = await firstSourceFile(manifestPath);
     if (firstSource)
-      openFile = path15.join(projectDir, firstSource);
+      openFile = path14.join(projectDir, firstSource);
     await fillTemplateFile(openFile, { "{{TITLE}}": name }).catch(() => {});
   } catch (e) {
     throw new CreateProjectErrorImpl("scaffold-io", `Could not finalize the book files: ${e instanceof Error ? e.message : String(e)}`);
@@ -10418,7 +9843,7 @@ async function scaffoldProject(options) {
   let versionHistoryError;
   if (requested === "local-git") {
     try {
-      const { providerFor } = await import("./source-provider-exy1wakv.js");
+      const { providerFor } = await import("./source-provider-gy3cn7kw.js");
       const provider = providerFor({ type: "local-folder", path: projectDir });
       await provider.initVersionHistory({
         projectDir,
@@ -10430,7 +9855,7 @@ async function scaffoldProject(options) {
       versionHistory = "none";
       const { findEnclosingRepoDir } = await import("./project-source-ekcyp63q.js");
       const enclosingRepoDir = await findEnclosingRepoDir(projectDir);
-      versionHistoryError = enclosingRepoDir ? `This book was added to ${path15.basename(enclosingRepoDir)}'s shared version history; save a snapshot to record it.` : e instanceof Error ? e.message : String(e);
+      versionHistoryError = enclosingRepoDir ? `This book was added to ${path14.basename(enclosingRepoDir)}'s shared version history; save a snapshot to record it.` : e instanceof Error ? e.message : String(e);
     }
   }
   const result = {
@@ -10445,10 +9870,10 @@ async function scaffoldProject(options) {
   return result;
 }
 async function ensureGitignoreHasDist(projectDir) {
-  const gitignorePath = path15.join(projectDir, ".gitignore");
+  const gitignorePath = path14.join(projectDir, ".gitignore");
   let existing = null;
   try {
-    existing = await readFile25(gitignorePath, "utf8");
+    existing = await readFile24(gitignorePath, "utf8");
   } catch {}
   if (existing === null) {
     await writeFile6(gitignorePath, `dist/
@@ -10468,7 +9893,7 @@ async function ensureGitignoreHasDist(projectDir) {
 async function firstSourceFile(manifestPath) {
   let text;
   try {
-    text = await readFile25(manifestPath, "utf8");
+    text = await readFile24(manifestPath, "utf8");
   } catch {
     return;
   }
@@ -10480,7 +9905,7 @@ async function firstSourceFile(manifestPath) {
   return m ? m[1].trim() : undefined;
 }
 async function fillTemplateFile(filePath, substitutions) {
-  let text = await readFile25(filePath, "utf8");
+  let text = await readFile24(filePath, "utf8");
   for (const [token, value] of Object.entries(substitutions)) {
     text = text.split(token).join(value);
   }
@@ -10488,9 +9913,9 @@ async function fillTemplateFile(filePath, substitutions) {
 }
 
 // src/lib/extension-scaffold.ts
-import { access as access2, mkdir as mkdir7, readFile as readFile26, writeFile as writeFile7 } from "node:fs/promises";
+import { access as access2, mkdir as mkdir7, readFile as readFile25, writeFile as writeFile7 } from "node:fs/promises";
 import { constants as FS2 } from "node:fs";
-import path16 from "node:path";
+import path15 from "node:path";
 var EXTENSION_KINDS = ["plugin", "theme"];
 var RESERVED_PREFIX = "gp-";
 var TEMPLATE_FILES = {
@@ -10568,7 +9993,7 @@ async function scaffoldExtension(options) {
   }
   const prefix = resolveExtensionPrefix(slug, options.prefix);
   const parentDir = options.parentDir;
-  if (!parentDir || !path16.isAbsolute(parentDir)) {
+  if (!parentDir || !path15.isAbsolute(parentDir)) {
     throw new ExtensionScaffoldError("parent-not-writable", "The save location must be an absolute path.");
   }
   try {
@@ -10576,7 +10001,7 @@ async function scaffoldExtension(options) {
   } catch {
     throw new ExtensionScaffoldError("parent-not-writable", `The chosen save location can't be written to: ${parentDir}`);
   }
-  const extensionDir = path16.join(parentDir, slug);
+  const extensionDir = path15.join(parentDir, slug);
   let targetExists = true;
   try {
     await access2(extensionDir, FS2.F_OK);
@@ -10603,9 +10028,9 @@ async function scaffoldExtension(options) {
     await mkdir7(extensionDir, { recursive: true });
     for (const [assetName, relDest] of entries) {
       const src = await getAssetPath(`extension-templates/${kind}/${assetName}`);
-      const dest = path16.join(extensionDir, relDest);
-      await mkdir7(path16.dirname(dest), { recursive: true });
-      const text = await readFile26(src, "utf8");
+      const dest = path15.join(extensionDir, relDest);
+      await mkdir7(path15.dirname(dest), { recursive: true });
+      const text = await readFile25(src, "utf8");
       const table = relDest.endsWith(".json") ? jsonSafe : plain;
       await writeFile7(dest, substitute(text, table), "utf8");
       written.push(relDest);
@@ -10615,11 +10040,11 @@ async function scaffoldExtension(options) {
   }
   return {
     extensionDir,
-    manifestPath: path16.join(extensionDir, "package.json"),
+    manifestPath: path15.join(extensionDir, "package.json"),
     kind,
     slug,
     prefix,
-    openFile: path16.join(extensionDir, OPEN_FILE[kind]),
+    openFile: path15.join(extensionDir, OPEN_FILE[kind]),
     files: written
   };
 }
@@ -10649,29 +10074,29 @@ var SKIP_ENTRIES = new Set([
 ]);
 
 // src/lib/extension-manager.ts
-import { cp as cp3, mkdir as mkdir9, readFile as readFile28, rm as rm4, stat as stat6 } from "node:fs/promises";
+import { cp as cp3, mkdir as mkdir9, readFile as readFile27, rm as rm4, stat as stat6 } from "node:fs/promises";
 import { existsSync as existsSync12 } from "node:fs";
-import path18 from "node:path";
+import path17 from "node:path";
 import { isSeq as isSeq3, isMap as isMap2, isScalar as isScalar2, YAMLMap, Scalar } from "yaml";
 
 // src/lib/npm-plugin-installer.ts
-import { createHash as createHash7, randomUUID as randomUUID3, timingSafeEqual } from "node:crypto";
-import { createReadStream as createReadStream2 } from "node:fs";
+import { createHash as createHash6, randomUUID as randomUUID3, timingSafeEqual } from "node:crypto";
+import { createReadStream } from "node:fs";
 import {
-  lstat as lstat2,
+  lstat,
   mkdir as mkdir8,
   mkdtemp as mkdtemp2,
   open as open2,
-  readFile as readFile27,
-  realpath as realpath2,
+  readFile as readFile26,
+  realpath,
   rename as rename2,
   rm as rm3
 } from "node:fs/promises";
-import path17 from "node:path";
+import path16 from "node:path";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGunzip } from "node:zlib";
-import { maxSatisfying, satisfies as satisfies2, validRange as validRange2 } from "semver";
+import { maxSatisfying, satisfies, validRange } from "semver";
 
 // src/lib/fetch-timeout.ts
 class FetchPassthroughError extends Error {
@@ -10728,11 +10153,11 @@ class PackageUnavailableError extends Error {
 function isOptionalAvailabilityError(error2) {
   return error2 instanceof PackageUnavailableError || error2 instanceof FriendlyHttpError || error2 instanceof FetchUnavailableError;
 }
-function object3(value) {
+function object2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function stringMap2(value) {
-  const map = object3(value);
+function stringMap(value) {
+  const map = object2(value);
   if (!map)
     return {};
   const result = {};
@@ -10745,9 +10170,9 @@ function stringMap2(value) {
 function mb(bytes) {
   return `${Math.ceil(bytes / 1024 / 1024)}MB`;
 }
-function isContained2(root, candidate) {
-  const relative2 = path17.relative(root, candidate);
-  return relative2 === "" || !relative2.startsWith("..") && !path17.isAbsolute(relative2);
+function isContained(root, candidate) {
+  const relative2 = path16.relative(root, candidate);
+  return relative2 === "" || !relative2.startsWith("..") && !path16.isAbsolute(relative2);
 }
 function mergeLimits(overrides) {
   const limits = { ...DEFAULT_LIMITS, ...overrides };
@@ -10825,7 +10250,7 @@ async function fetchPackument(ctx, name) {
     }
     let metadata = null;
     try {
-      metadata = object3(JSON.parse(new TextDecoder().decode(bytes)));
+      metadata = object2(JSON.parse(new TextDecoder().decode(bytes)));
     } catch {}
     if (!metadata || metadata.name !== name) {
       throw new FriendlyHttpError(`npm returned invalid metadata for "${name}".`);
@@ -10881,29 +10306,29 @@ async function selectPackage(ctx, name, selector) {
     throw new PackageUnavailableError(`Dependency selector "${selector}" for ${name} is not a registry semver range or dist-tag.`);
   }
   const metadata = await fetchPackument(ctx, name);
-  const versions = object3(metadata.versions);
-  const tags = object3(metadata["dist-tags"]);
+  const versions = object2(metadata.versions);
+  const tags = object2(metadata["dist-tags"]);
   if (!versions || !tags)
     throw new PackageUnavailableError(`npm metadata for "${name}" has no versions.`);
   let version;
   if (!selector) {
     if (typeof tags.latest === "string")
       version = tags.latest;
-  } else if (object3(versions[selector])) {
+  } else if (object2(versions[selector])) {
     version = selector;
   } else if (typeof tags[selector] === "string") {
     version = tags[selector];
-  } else if (validRange2(selector)) {
+  } else if (validRange(selector)) {
     version = maxSatisfying(Object.keys(versions), selector) ?? undefined;
   }
   if (!version || !isExactNpmVersion(version)) {
     throw new PackageUnavailableError(`No exact npm version of "${name}" satisfies "${selector ?? "latest"}".`);
   }
-  const selected = object3(versions[version]);
+  const selected = object2(versions[version]);
   if (!selected || selected.name !== name || selected.version !== version) {
     throw new SecurityInstallError(`npm metadata identity failed for "${name}@${version}".`);
   }
-  const dist = object3(selected.dist);
+  const dist = object2(selected.dist);
   if (!dist || typeof dist.tarball !== "string") {
     throw new PackageUnavailableError(`npm metadata for "${name}@${version}" has no tarball.`);
   }
@@ -10920,7 +10345,7 @@ async function selectPackage(ctx, name, selector) {
 }
 async function downloadTarball(ctx, pkg, archivePath) {
   const file = await open2(archivePath, "wx");
-  const hash = createHash7(pkg.integrity.algorithm);
+  const hash = createHash6(pkg.integrity.algorithm);
   try {
     await withFetchTimeout({
       timeoutMs: TARBALL_TIMEOUT_MS,
@@ -11042,7 +10467,7 @@ async function extractTarball(ctx, archivePath, packageDir, packageName) {
     }
   });
   try {
-    await pipeline(createReadStream2(archivePath), createGunzip(), limiter, unpack);
+    await pipeline(createReadStream(archivePath), createGunzip(), limiter, unpack);
   } catch (error2) {
     if (rejected)
       throw rejected;
@@ -11054,13 +10479,13 @@ async function extractTarball(ctx, archivePath, packageDir, packageName) {
     throw rejected;
 }
 async function readInstalledManifest(packageDir, selected) {
-  const packageJsonPath = path17.join(packageDir, "package.json");
+  const packageJsonPath = path16.join(packageDir, "package.json");
   let manifest = null;
   try {
-    const info2 = await lstat2(packageJsonPath);
+    const info2 = await lstat(packageJsonPath);
     if (!info2.isFile() || info2.isSymbolicLink())
       throw new Error("not a regular file");
-    manifest = object3(JSON.parse(await readFile27(packageJsonPath, "utf8")));
+    manifest = object2(JSON.parse(await readFile26(packageJsonPath, "utf8")));
   } catch (error2) {
     throw new SecurityInstallError(`Downloaded ${selected.name}@${selected.version} has no valid package.json (${error2 instanceof Error ? error2.message : String(error2)}).`);
   }
@@ -11123,17 +10548,17 @@ async function installPackage(ctx, name, selector, parentPackagePath, ancestors,
     }
     throw error2;
   }
-  const ancestor = ancestors.find((candidate) => candidate.name === name && (candidate.version === selected.version || (selector ? satisfies2(candidate.version, selector) : false)));
+  const ancestor = ancestors.find((candidate) => candidate.name === name && (candidate.version === selected.version || (selector ? satisfies(candidate.version, selector) : false)));
   if (ancestor)
     return { path: ancestor.path };
   if (ctx.records.length >= ctx.limits.totalPackages) {
     throw new SecurityInstallError(`Dependency graph exceeds ${ctx.limits.totalPackages} packages.`);
   }
   const relativePath = relativePackagePath(parentPackagePath, name);
-  const packageDir = path17.join(ctx.stageRoot, ...relativePath.split("/"));
-  const archivePath = path17.join(ctx.downloadsDir, `${ctx.archiveCounter++}.tgz`);
+  const packageDir = path16.join(ctx.stageRoot, ...relativePath.split("/"));
+  const archivePath = path16.join(ctx.downloadsDir, `${ctx.archiveCounter++}.tgz`);
   try {
-    await mkdir8(path17.dirname(packageDir), { recursive: true });
+    await mkdir8(path16.dirname(packageDir), { recursive: true });
     await downloadTarball(ctx, selected, archivePath);
     await extractTarball(ctx, archivePath, packageDir, selected.name);
     const manifest = await readInstalledManifest(packageDir, selected);
@@ -11167,19 +10592,19 @@ async function installPackage(ctx, name, selector, parentPackagePath, ancestors,
     if (selected.integrity.legacySha1) {
       ctx.warnings.add(`${name}@${selected.version} is an old npm release with only SHA-1 registry integrity. It was accepted for compatibility and recorded as legacy SHA-1 in the vendor receipt.`);
     }
-    const dependencies = stringMap2(manifest.dependencies);
-    const optionalDependencies = stringMap2(manifest.optionalDependencies);
+    const dependencies = stringMap(manifest.dependencies);
+    const optionalDependencies = stringMap(manifest.optionalDependencies);
     for (const optionalName of Object.keys(optionalDependencies))
       delete dependencies[optionalName];
-    const peerDependencies = stringMap2(manifest.peerDependencies);
-    const peerMeta = object3(manifest.peerDependenciesMeta) ?? {};
+    const peerDependencies = stringMap(manifest.peerDependencies);
+    const peerMeta = object2(manifest.peerDependenciesMeta) ?? {};
     for (const existing of [...Object.keys(dependencies), ...Object.keys(optionalDependencies)]) {
       delete peerDependencies[existing];
     }
     const nextAncestors = [...ancestors, record];
     const requiredEntries = [
       ...Object.entries(dependencies).map(([dependency, range]) => ({ dependency, range, kind: "required" })),
-      ...Object.entries(peerDependencies).filter(([dependency]) => object3(peerMeta[dependency])?.optional !== true).map(([dependency, range]) => ({ dependency, range, kind: "peer" }))
+      ...Object.entries(peerDependencies).filter(([dependency]) => object2(peerMeta[dependency])?.optional !== true).map(([dependency, range]) => ({ dependency, range, kind: "peer" }))
     ].sort((a, b) => a.dependency.localeCompare(b.dependency));
     for (const { dependency, range } of requiredEntries) {
       const child = await installPackage(ctx, dependency, range, relativePath, nextAncestors, depth + 1, false);
@@ -11197,7 +10622,7 @@ async function installPackage(ctx, name, selector, parentPackagePath, ancestors,
       }
     }
     for (const [dependency, range] of Object.entries(peerDependencies)) {
-      if (object3(peerMeta[dependency])?.optional === true) {
+      if (object2(peerMeta[dependency])?.optional === true) {
         ctx.skipped.push({
           from: relativePath,
           name: dependency,
@@ -11221,7 +10646,7 @@ async function installPackage(ctx, name, selector, parentPackagePath, ancestors,
 }
 async function ensureDirectory(pathname) {
   try {
-    const info2 = await lstat2(pathname);
+    const info2 = await lstat(pathname);
     if (info2.isSymbolicLink() || !info2.isDirectory()) {
       throw new Error(`Plugin install path is not a normal directory: ${pathname}`);
     }
@@ -11232,18 +10657,18 @@ async function ensureDirectory(pathname) {
   }
 }
 async function prepareVendorParent(projectDir, name) {
-  const plugins = path17.join(projectDir, PLUGINS_DIR);
-  const npm = path17.join(plugins, VENDORED_NPM_DIR);
-  const packageParent = path17.dirname(vendoredNpmPluginRoot(projectDir, name, "0.0.0"));
+  const plugins = path16.join(projectDir, PLUGINS_DIR);
+  const npm = path16.join(plugins, VENDORED_NPM_DIR);
+  const packageParent = path16.dirname(vendoredNpmPluginRoot(projectDir, name, "0.0.0"));
   await mkdir8(projectDir, { recursive: true });
   await ensureDirectory(plugins);
   await ensureDirectory(npm);
   await ensureDirectory(packageParent);
   const [realNpm, realPackageParent] = await Promise.all([
-    realpath2(npm),
-    realpath2(packageParent)
+    realpath(npm),
+    realpath(packageParent)
   ]);
-  if (!isContained2(projectDir, realNpm) || !isContained2(projectDir, realPackageParent)) {
+  if (!isContained(projectDir, realNpm) || !isContained(projectDir, realPackageParent)) {
     throw new Error("Plugin install path resolves outside the book folder.");
   }
   return realNpm;
@@ -11262,14 +10687,14 @@ function publicReceipt(record) {
   };
 }
 async function installNpmPlugin(projectDirInput, packageSpec, options = {}) {
-  const requestedProjectDir = path17.resolve(projectDirInput);
+  const requestedProjectDir = path16.resolve(projectDirInput);
   await mkdir8(requestedProjectDir, { recursive: true });
-  const projectDir = await realpath2(requestedProjectDir);
+  const projectDir = await realpath(requestedProjectDir);
   const requested = parseNpmPluginSpec(packageSpec);
   const npmRoot = await prepareVendorParent(projectDir, requested.name);
-  const container = await mkdtemp2(path17.join(npmRoot, ".install-"));
-  const stageRoot = path17.join(container, "root");
-  const downloadsDir = path17.join(container, "downloads");
+  const container = await mkdtemp2(path16.join(npmRoot, ".install-"));
+  const stageRoot = path16.join(container, "root");
+  const downloadsDir = path16.join(container, "downloads");
   await Promise.all([mkdir8(stageRoot), mkdir8(downloadsDir)]);
   const ctx = {
     fetch: options.fetch ?? globalThis.fetch,
@@ -11315,7 +10740,7 @@ async function installNpmPlugin(projectDirInput, packageSpec, options = {}) {
       skipped: ctx.skipped,
       tree: { algorithm: "sha256", ...tree }
     };
-    const receiptFile = await open2(path17.join(stageRoot, VENDOR_RECEIPT_FILE), "wx");
+    const receiptFile = await open2(path16.join(stageRoot, VENDOR_RECEIPT_FILE), "wx");
     try {
       await receiptFile.writeFile(`${JSON.stringify(receipt, null, 2)}
 `, "utf8");
@@ -11324,12 +10749,12 @@ async function installNpmPlugin(projectDirInput, packageSpec, options = {}) {
       await receiptFile.close();
     }
     finalRoot = vendoredNpmPluginRoot(projectDir, rootRecord.name, rootRecord.version);
-    const realFinalParent = await realpath2(path17.dirname(finalRoot));
-    if (!isContained2(projectDir, realFinalParent)) {
+    const realFinalParent = await realpath(path16.dirname(finalRoot));
+    if (!isContained(projectDir, realFinalParent)) {
       throw new Error("Plugin install destination resolves outside the book folder.");
     }
     try {
-      await lstat2(finalRoot);
+      await lstat(finalRoot);
       backupRoot = `${finalRoot}.backup-${randomUUID3()}`;
       await rename2(finalRoot, backupRoot);
     } catch (error2) {
@@ -11402,7 +10827,7 @@ var RECOMMENDED_EXTENSIONS = [
 var BUILT_IN_STYLE_SET_IDS = ["clean-book", "zine", "technical-doc"];
 var mutationQueues = new Map;
 function withMutationLock(projectDir, mutation) {
-  const resolved = path18.resolve(projectDir);
+  const resolved = path17.resolve(projectDir);
   const key = process.platform === "win32" ? resolved.toLowerCase() : resolved;
   const previous = mutationQueues.get(key) ?? Promise.resolve();
   const run = previous.then(mutation, mutation);
@@ -11464,7 +10889,7 @@ function indexOfUse(seq, use) {
   });
 }
 function manifestPathFor(projectDir, abs) {
-  const rel = path18.relative(path18.resolve(projectDir), abs).split(path18.sep).join("/");
+  const rel = path17.relative(path17.resolve(projectDir), abs).split(path17.sep).join("/");
   if (rel === "") {
     throw new Error("An extension cannot be the book folder itself.");
   }
@@ -11523,21 +10948,21 @@ async function describeEntry(projectDir, raw) {
     });
   }
   if (parsed.kind === "path") {
-    const abs = path18.resolve(projectDir, parsed.path);
+    const abs = path17.resolve(projectDir, parsed.path);
     const base2 = { ...common, kind: "path", name: parsed.path };
     let info2;
     try {
       info2 = await stat6(abs);
     } catch {
       warnings.push(`Not found: ${abs}`);
-      return withWarnings({ ...base2, label: path18.basename(abs), carries: NO_CARRIES });
+      return withWarnings({ ...base2, label: path17.basename(abs), carries: NO_CARRIES });
     }
     if (info2.isDirectory()) {
-      return withWarnings(await describeFolder(abs, base2, prettify(path18.basename(abs))));
+      return withWarnings(await describeFolder(abs, base2, prettify(path17.basename(abs))));
     }
     return withWarnings({
       ...base2,
-      label: path18.basename(abs),
+      label: path17.basename(abs),
       carries: { ...NO_CARRIES, markdown: true }
     });
   }
@@ -11562,7 +10987,7 @@ async function describeEntry(projectDir, raw) {
     return withWarnings({ ...base, label: parsed.name, carries: { ...NO_CARRIES, markdown: true } });
   }
   const pkgDir = vendoredNpmPluginPackageDir(installRoot, parsed.name);
-  if (!existsSync12(path18.join(pkgDir, EXTENSION_MANIFEST_FILENAME))) {
+  if (!existsSync12(path17.join(pkgDir, EXTENSION_MANIFEST_FILENAME))) {
     return withWarnings({ ...base, label: parsed.name, carries: { ...NO_CARRIES, markdown: true } });
   }
   const described = await describeFolder(pkgDir, base, parsed.name, (name) => name);
@@ -11698,11 +11123,11 @@ async function addExtension(projectDir, specifier, options = {}) {
 async function addExtensionUnlocked(projectDir, specifier, options) {
   const input = specifier.trim();
   const exportName = options.exportName?.trim() || undefined;
-  if (path18.isAbsolute(input))
+  if (path17.isAbsolute(input))
     return addPathExtension(projectDir, input, exportName);
   const parsed = parseExtensionSpecifier(input);
   if (parsed.kind === "path") {
-    return addPathExtension(projectDir, path18.resolve(projectDir, parsed.path), exportName);
+    return addPathExtension(projectDir, path17.resolve(projectDir, parsed.path), exportName);
   }
   if (parsed.kind === "bundled") {
     if (exportName)
@@ -11743,7 +11168,7 @@ async function addExtensionUnlocked(projectDir, specifier, options) {
 async function uniqueExtensionId(projectDir, base) {
   const slug = slugify(base) || "extension";
   let candidate = slug;
-  for (let n = 2;existsSync12(path18.join(projectDir, EXTENSIONS_DIR, candidate)); n++) {
+  for (let n = 2;existsSync12(path17.join(projectDir, EXTENSIONS_DIR, candidate)); n++) {
     candidate = `${slug}-${n}`;
   }
   return candidate;
@@ -11753,10 +11178,10 @@ async function addBuiltInStyleSet(projectDir, id) {
     throw new Error(`Unknown built-in look "${id}" (one of: ${BUILT_IN_STYLE_SET_IDS.join(", ")}).`);
   }
   return withMutationLock(projectDir, async () => {
-    const dest = path18.join(projectDir, EXTENSIONS_DIR, id);
+    const dest = path17.join(projectDir, EXTENSIONS_DIR, id);
     if (!existsSync12(dest)) {
-      const src = path18.join(await getAssetsDir(), "themes", id);
-      await mkdir9(path18.dirname(dest), { recursive: true });
+      const src = path17.join(await getAssetsDir(), "themes", id);
+      await mkdir9(path17.dirname(dest), { recursive: true });
       await cp3(src, dest, { recursive: true });
     }
     return addExtensionUnlocked(projectDir, `./${EXTENSIONS_DIR}/${id}`, {});
@@ -11765,9 +11190,9 @@ async function addBuiltInStyleSet(projectDir, id) {
 
 // src/lib/extension-import.ts
 import { existsSync as existsSync13 } from "node:fs";
-import { cp as cp4, mkdir as mkdir10, mkdtemp as mkdtemp3, readFile as readFile29, rm as rm5, writeFile as writeFile8 } from "node:fs/promises";
+import { cp as cp4, mkdir as mkdir10, mkdtemp as mkdtemp3, readFile as readFile28, rm as rm5, writeFile as writeFile8 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import path19 from "node:path";
+import path18 from "node:path";
 import { unzipSync } from "fflate";
 var MAX_THEME_ARCHIVE_BYTES = 25 * 1024 * 1024;
 var MAX_THEME_UNZIPPED_BYTES = 25 * 1024 * 1024;
@@ -11834,11 +11259,11 @@ function mb2(n) {
   return `${Math.round(n / (1024 * 1024))}MB`;
 }
 async function finalizeExtensionImport(projectDir, sourceDir, relPaths, fallbackName) {
-  const cssPath = path19.join(sourceDir, "theme.css");
+  const cssPath = path18.join(sourceDir, "theme.css");
   if (!existsSync13(cssPath)) {
     throw new Error("A theme must contain a theme.css file.");
   }
-  const css = await readFile29(cssPath, "utf8");
+  const css = await readFile28(cssPath, "utf8");
   const { reject, warnings: printFindings } = classifyThemeCssFindings(checkCss(css, "theme.css"));
   if (reject) {
     throw new Error(`theme.css could not be parsed — ${reject.message}`);
@@ -11847,7 +11272,7 @@ async function finalizeExtensionImport(projectDir, sourceDir, relPaths, fallback
   for (const w of printFindings) {
     warnings.push({ code: "print-safety", message: w.message });
   }
-  const metaExists = existsSync13(path19.join(sourceDir, EXTENSION_MANIFEST_FILENAME));
+  const metaExists = existsSync13(path18.join(sourceDir, EXTENSION_MANIFEST_FILENAME));
   const meta = metaExists ? await readExtensionMeta(sourceDir) : {};
   if (!metaExists) {
     warnings.push({
@@ -11866,7 +11291,7 @@ async function finalizeExtensionImport(projectDir, sourceDir, relPaths, fallback
   for (let i = 0;i < extraSheets.length; i++) {
     const rel = extraSheets[i];
     const sheetPath = extraSheetPaths[i];
-    const sheetCss = await readFile29(sheetPath, "utf8");
+    const sheetCss = await readFile28(sheetPath, "utf8");
     const { reject: sheetReject, warnings: sheetFindings } = classifyThemeCssFindings(checkCss(sheetCss, rel));
     if (sheetReject) {
       throw new Error(`${rel} could not be parsed — ${sheetReject.message}`);
@@ -11885,8 +11310,8 @@ async function finalizeExtensionImport(projectDir, sourceDir, relPaths, fallback
     });
   }
   const id = await uniqueExtensionId(projectDir, meta.name?.trim() || fallbackName);
-  const dest = path19.join(projectDir, EXTENSIONS_DIR, id);
-  await mkdir10(path19.dirname(dest), { recursive: true });
+  const dest = path18.join(projectDir, EXTENSIONS_DIR, id);
+  await mkdir10(path18.dirname(dest), { recursive: true });
   await cp4(sourceDir, dest, { recursive: true });
   await completeLandedManifest(dest, id, meta, metaExists);
   const entry = await addExtension(projectDir, `./${EXTENSIONS_DIR}/${id}`);
@@ -11895,11 +11320,11 @@ async function finalizeExtensionImport(projectDir, sourceDir, relPaths, fallback
 async function completeLandedManifest(dest, id, meta, metaExists) {
   if (metaExists && extensionStyleList(meta).length > 0)
     return;
-  const file = path19.join(dest, EXTENSION_MANIFEST_FILENAME);
+  const file = path18.join(dest, EXTENSION_MANIFEST_FILENAME);
   let pkg = {};
   if (metaExists) {
     try {
-      const parsed = JSON.parse(await readFile29(file, "utf8"));
+      const parsed = JSON.parse(await readFile28(file, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         pkg = parsed;
       }
@@ -11953,7 +11378,7 @@ async function importExtensionFromZip(projectDir, archive) {
     throw new Error("No theme.css found in the package. A theme needs a theme.css at the package root or inside a single folder.");
   }
   const prefix = root === "" ? "" : `${root}/`;
-  const tmp = await mkdtemp3(path19.join(tmpdir3(), "gutterpress-theme-"));
+  const tmp = await mkdtemp3(path18.join(tmpdir3(), "gutterpress-theme-"));
   try {
     const relPaths = [];
     for (const [name, data] of Object.entries(files)) {
@@ -11965,12 +11390,12 @@ async function importExtensionFromZip(projectDir, archive) {
       const rel = prefix ? norm.slice(prefix.length) : norm;
       if (!rel || rel.split("/").some((seg) => seg === ".."))
         continue;
-      const dest = path19.join(tmp, rel);
-      if (dest !== tmp && !dest.startsWith(tmp + path19.sep)) {
+      const dest = path18.join(tmp, rel);
+      if (dest !== tmp && !dest.startsWith(tmp + path18.sep)) {
         throw new Error(`The package contains an unsafe path and was rejected: ${name}`);
       }
       relPaths.push(rel);
-      await mkdir10(path19.dirname(dest), { recursive: true });
+      await mkdir10(path18.dirname(dest), { recursive: true });
       await writeFile8(dest, data);
     }
     return await finalizeExtensionImport(projectDir, tmp, relPaths, root || "imported-look");
@@ -11984,10 +11409,10 @@ async function importExtensionFromCssText(projectDir, css, name) {
     throw new Error(`The CSS could not be parsed — ${reject.message}`);
   }
   const displayName = name.trim() || "Imported theme";
-  const tmp = await mkdtemp3(path19.join(tmpdir3(), "gutterpress-theme-"));
+  const tmp = await mkdtemp3(path18.join(tmpdir3(), "gutterpress-theme-"));
   try {
-    await writeFile8(path19.join(tmp, "theme.css"), css, "utf8");
-    await writeFile8(path19.join(tmp, EXTENSION_MANIFEST_FILENAME), JSON.stringify({ name: slugify(displayName, "look"), gutterpress: { styles: ["theme.css"] } }, null, 2), "utf8");
+    await writeFile8(path18.join(tmp, "theme.css"), css, "utf8");
+    await writeFile8(path18.join(tmp, EXTENSION_MANIFEST_FILENAME), JSON.stringify({ name: slugify(displayName, "look"), gutterpress: { styles: ["theme.css"] } }, null, 2), "utf8");
     const result = await finalizeExtensionImport(projectDir, tmp, ["theme.css", EXTENSION_MANIFEST_FILENAME], displayName);
     result.warnings.unshift({
       code: "no-theme-json",
@@ -11999,14 +11424,14 @@ async function importExtensionFromCssText(projectDir, css, name) {
   }
 }
 async function importExtensionFromFile(projectDir, filePath) {
-  const ext = path19.extname(filePath).toLowerCase();
+  const ext = path18.extname(filePath).toLowerCase();
   if (ext === ".zip") {
-    const buf = await readFile29(filePath);
+    const buf = await readFile28(filePath);
     return importExtensionFromZip(projectDir, new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
   }
   if (ext === ".css") {
-    const css = await readFile29(filePath, "utf8");
-    return importExtensionFromCssText(projectDir, css, prettify(path19.basename(filePath, ".css")));
+    const css = await readFile28(filePath, "utf8");
+    return importExtensionFromCssText(projectDir, css, prettify(path18.basename(filePath, ".css")));
   }
   throw new Error("Choose a .zip extension package or a .css stylesheet.");
 }
@@ -12054,7 +11479,7 @@ async function importExtensionFromUrl(projectDir, url) {
   let baseName;
   if (looksLikeCssUrl(trimmed)) {
     css = await fetchText(trimmed);
-    baseName = path19.basename(new URL(trimmed, "https://x/").pathname, ".css") || "look";
+    baseName = path18.basename(new URL(trimmed, "https://x/").pathname, ".css") || "look";
   } else {
     const base = trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
     css = await fetchText(`${base}theme.css`);
@@ -12063,14 +11488,14 @@ async function importExtensionFromUrl(projectDir, url) {
       if (parsed && typeof parsed === "object")
         meta = parsed;
     } catch {}
-    baseName = typeof meta.name === "string" && meta.name || path19.basename(new URL(base, "https://x/").pathname.replace(/\/$/, "")) || "look";
+    baseName = typeof meta.name === "string" && meta.name || path18.basename(new URL(base, "https://x/").pathname.replace(/\/$/, "")) || "look";
   }
   if (!css.trim())
     throw new Error(`Fetched CSS from ${trimmed} was empty.`);
   assertLooksLikeCss(css, trimmed);
-  const tmp = await mkdtemp3(path19.join(tmpdir3(), "gutterpress-ext-"));
+  const tmp = await mkdtemp3(path18.join(tmpdir3(), "gutterpress-ext-"));
   try {
-    await writeFile8(path19.join(tmp, "theme.css"), css, "utf8");
+    await writeFile8(path18.join(tmp, "theme.css"), css, "utf8");
     const gp = meta.gutterpress && typeof meta.gutterpress === "object" && !Array.isArray(meta.gutterpress) ? meta.gutterpress : {};
     const finalMeta = {
       name: typeof meta.name === "string" && meta.name || slugify(baseName, "look"),
@@ -12082,7 +11507,7 @@ async function importExtensionFromUrl(projectDir, url) {
         preview: typeof gp.preview === "string" ? gp.preview : null
       }
     };
-    await writeFile8(path19.join(tmp, EXTENSION_MANIFEST_FILENAME), JSON.stringify(finalMeta, null, 2), "utf8");
+    await writeFile8(path18.join(tmp, EXTENSION_MANIFEST_FILENAME), JSON.stringify(finalMeta, null, 2), "utf8");
     return await finalizeExtensionImport(projectDir, tmp, ["theme.css", EXTENSION_MANIFEST_FILENAME], baseName);
   } finally {
     await rm5(tmp, { recursive: true, force: true });
@@ -12100,7 +11525,7 @@ var KIND_FOR_KEYWORD = {
 function invalid(reason) {
   throw new Error(`Malformed npm search response: ${reason}.`);
 }
-function object4(value) {
+function object3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
 function str2(value) {
@@ -12113,7 +11538,7 @@ function parseSearchPage(text, keyword) {
   } catch {
     invalid("not valid JSON");
   }
-  const root = object4(parsed);
+  const root = object3(parsed);
   if (!root)
     invalid("root is not an object");
   if (!Array.isArray(root.objects))
@@ -12123,10 +11548,10 @@ function parseSearchPage(text, keyword) {
   const packages = [];
   const scores = [];
   root.objects.forEach((raw, i) => {
-    const entry = object4(raw);
+    const entry = object3(raw);
     if (!entry)
       invalid(`objects[${i}] is not an object`);
-    const pkg = object4(entry.package);
+    const pkg = object3(entry.package);
     if (!pkg)
       invalid(`objects[${i}].package is not an object`);
     const name = str2(pkg.name);
@@ -12140,7 +11565,7 @@ function parseSearchPage(text, keyword) {
       return;
     if (name === "markdown-it" || name.startsWith("@types/"))
       return;
-    const links = object4(pkg.links) ?? {};
+    const links = object3(pkg.links) ?? {};
     packages.push({
       name,
       version,
@@ -12709,24 +12134,24 @@ ${tail}` : ""}`);
 
 // src/lib/publish/providers/guided.ts
 import { copyFile as copyFile2, mkdir as mkdir11, writeFile as writeFile9 } from "node:fs/promises";
-import path20 from "node:path";
+import path19 from "node:path";
 async function stageGuidedPackage(req, providerId, listingLines) {
-  const packageDir = path20.join(path20.dirname(req.artifact.path), "publish", providerId);
+  const packageDir = path19.join(path19.dirname(req.artifact.path), "publish", providerId);
   await mkdir11(packageDir, { recursive: true });
-  await copyFile2(req.artifact.path, path20.join(packageDir, path20.basename(req.artifact.path)));
+  await copyFile2(req.artifact.path, path19.join(packageDir, path19.basename(req.artifact.path)));
   const { title, authors } = req.project;
   const sheet = [
     `# ${title || "Untitled"}`,
     "",
     `- **Authors:** ${authors.length ? authors.join(", ") : "(not set)"}`,
-    `- **File:** ${path20.basename(req.artifact.path)}`,
+    `- **File:** ${path19.basename(req.artifact.path)}`,
     ...listingLines,
     "",
     "Copy these details into the platform's listing form when uploading.",
     ""
   ].join(`
 `);
-  await writeFile9(path20.join(packageDir, "LISTING.md"), sheet, "utf8");
+  await writeFile9(path19.join(packageDir, "LISTING.md"), sheet, "utf8");
   return packageDir;
 }
 
@@ -12789,9 +12214,9 @@ var drivethrurpgProvider = {
 };
 
 // src/lib/publish/providers/gdrive.ts
-import { mkdtemp as mkdtemp4, readFile as readFile30, readdir as readdir6, rm as rm6, stat as stat7, writeFile as writeFile10 } from "node:fs/promises";
+import { mkdtemp as mkdtemp4, readFile as readFile29, readdir as readdir5, rm as rm6, stat as stat7, writeFile as writeFile10 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import path21 from "node:path";
+import path20 from "node:path";
 import { Zip, ZipDeflate } from "fflate";
 
 // src/lib/publish/google-drive.ts
@@ -13174,26 +12599,26 @@ function zipEntriesNonBlocking(entries, opts) {
   });
 }
 async function collectZipEntries(root, dir, out, onWarn) {
-  const entries = await readdir6(dir, { withFileTypes: true });
+  const entries = await readdir5(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = path21.join(dir, entry.name);
+    const full = path20.join(dir, entry.name);
     if (entry.isDirectory()) {
       await collectZipEntries(root, full, out, onWarn);
     } else if (entry.isFile()) {
-      const rel = path21.relative(root, full).split(path21.sep).join("/");
-      out[rel] = await readFile30(full);
+      const rel = path20.relative(root, full).split(path20.sep).join("/");
+      out[rel] = await readFile29(full);
     } else if (entry.isSymbolicLink()) {
       const resolved = await stat7(full).catch(() => null);
       if (resolved?.isFile()) {
-        const rel = path21.relative(root, full).split(path21.sep).join("/");
-        out[rel] = await readFile30(full);
+        const rel = path20.relative(root, full).split(path20.sep).join("/");
+        out[rel] = await readFile29(full);
       } else if (resolved?.isDirectory()) {
         await collectZipEntries(root, full, out, onWarn);
       } else {
-        onWarn?.(`Skipped "${path21.relative(root, full)}" in the website export — it's a broken symlink.`);
+        onWarn?.(`Skipped "${path20.relative(root, full)}" in the website export — it's a broken symlink.`);
       }
     } else {
-      onWarn?.(`Skipped "${path21.relative(root, full)}" in the website export — not a file, folder, or symlink.`);
+      onWarn?.(`Skipped "${path20.relative(root, full)}" in the website export — not a file, folder, or symlink.`);
     }
   }
 }
@@ -13201,9 +12626,9 @@ async function zipHtmlExport(exportDir, title, onWarn, writeArchiveImpl = writeF
   const entries = {};
   await collectZipEntries(exportDir, exportDir, entries, onWarn);
   const fileName = `${bookSlug(title)}-website.zip`;
-  const tmpRoot = await mkdtemp4(path21.join(tmpdir4(), "gutterpress-gdrive-"));
+  const tmpRoot = await mkdtemp4(path20.join(tmpdir4(), "gutterpress-gdrive-"));
   try {
-    const filePath = path21.join(tmpRoot, fileName);
+    const filePath = path20.join(tmpRoot, fileName);
     const zipped = await zipEntriesNonBlocking(entries, { level: 6 });
     await writeArchiveImpl(filePath, zipped);
     return {
@@ -13251,7 +12676,7 @@ var gdriveProvider = {
     const isHtml = req.artifact.format === "html";
     const source = isHtml ? await zipHtmlExport(req.artifact.path, req.project.title, (msg) => req.deps.onProgress?.(msg)) : {
       filePath: req.artifact.path,
-      fileName: path21.basename(req.artifact.path),
+      fileName: path20.basename(req.artifact.path),
       mimeType: "application/pdf",
       cleanup: async () => {}
     };
@@ -13302,7 +12727,7 @@ var gdriveProvider = {
 
 // src/lib/publish/butler.ts
 import { chmod, mkdir as mkdir12, stat as stat8, writeFile as writeFile11 } from "node:fs/promises";
-import path22 from "node:path";
+import path21 from "node:path";
 import { unzipSync as unzipSync2 } from "fflate";
 var BUTLER_DOWNLOAD_TIMEOUT_MS = 300000;
 function butlerBrothChannel(platform = process.platform, arch = process.arch) {
@@ -13339,8 +12764,8 @@ async function ensureButler(deps) {
   }
   if (await commandExists("butler", runCommand, deps.env))
     return "butler";
-  const cacheDir = path22.join(deps.configDir ?? defaultConfigDir(), "tools", "butler");
-  const cached = path22.join(cacheDir, butlerBinaryName());
+  const cacheDir = path21.join(deps.configDir ?? defaultConfigDir(), "tools", "butler");
+  const cached = path21.join(cacheDir, butlerBinaryName());
   if (await fileExists2(cached))
     return cached;
   const channel = butlerBrothChannel();
@@ -13367,9 +12792,9 @@ async function ensureButler(deps) {
   for (const [name, data] of Object.entries(files)) {
     if (name.endsWith("/"))
       continue;
-    const target = path22.join(cacheDir, path22.basename(name));
+    const target = path21.join(cacheDir, path21.basename(name));
     await writeFile11(target, data);
-    if (path22.basename(name) === butlerBinaryName()) {
+    if (path21.basename(name) === butlerBinaryName()) {
       await chmod(target, 493).catch(() => {});
       foundBinary = true;
     }
@@ -13798,8 +13223,8 @@ function publishProviderFor(id) {
 }
 
 // src/lib/publish/run-publish.ts
-import { readdir as readdir7, stat as stat9 } from "node:fs/promises";
-import path23 from "node:path";
+import { readdir as readdir6, stat as stat9 } from "node:fs/promises";
+import path22 from "node:path";
 function resolvePublishFormat(info8, providerConfig) {
   if (info8.formats && info8.formats.length > 0) {
     const configured = typeof providerConfig.format === "string" ? providerConfig.format.trim() : "";
@@ -13820,9 +13245,9 @@ async function resolvePublishRequest(options, deps) {
   const effectiveDeps = effectiveAccount ? { ...deps, credentialAccount: effectiveAccount } : deps;
   const outDir = resolveOutputDir(manifestDir, config.title);
   const effectiveFormat = resolvePublishFormat(provider.info, providerConfig);
-  const defaultArtifact = effectiveFormat === "pdf" ? path23.join(outDir, artifactName(config.title, "pdf")) : outDir;
+  const defaultArtifact = effectiveFormat === "pdf" ? path22.join(outDir, artifactName(config.title, "pdf")) : outDir;
   const artifact = {
-    path: options.artifactPath ? path23.resolve(options.projectDir, options.artifactPath) : defaultArtifact,
+    path: options.artifactPath ? path22.resolve(options.projectDir, options.artifactPath) : defaultArtifact,
     format: effectiveFormat
   };
   return {
@@ -13886,7 +13311,7 @@ async function artifactIssues(artifact) {
 var BUILD_FINGERPRINT_FILENAME = "build-fingerprint.json";
 async function htmlDirIssues(dir) {
   const issues = [];
-  const isThere = async (rel) => stat9(path23.join(dir, rel)).then(() => true, () => false);
+  const isThere = async (rel) => stat9(path22.join(dir, rel)).then(() => true, () => false);
   if (!await isThere(BOOK_HTML)) {
     issues.push({
       severity: "error",
@@ -13894,7 +13319,7 @@ async function htmlDirIssues(dir) {
       message: `${dir} has no ${BOOK_HTML} — it isn't an HTML export. ${HTML_HINT}`
     });
   }
-  const entries = await readdir7(dir).catch(() => []);
+  const entries = await readdir6(dir).catch(() => []);
   const extras = entries.filter((name) => name.toLowerCase().endsWith(".pdf") || name === BUILD_FINGERPRINT_FILENAME);
   if (extras.length > 0) {
     issues.push({
@@ -14117,17 +13542,17 @@ import git6 from "isomorphic-git";
 import git5 from "isomorphic-git";
 import diff3Merge from "diff3";
 // src/lib/publish/selections.ts
-import { chmod as chmod2, mkdir as mkdir13, readFile as readFile31, writeFile as writeFile12 } from "node:fs/promises";
-import path24 from "node:path";
+import { chmod as chmod2, mkdir as mkdir13, readFile as readFile30, writeFile as writeFile12 } from "node:fs/promises";
+import path23 from "node:path";
 class PublishSelectionsStore {
   filePath;
   queue = Promise.resolve();
   constructor(filePath) {
-    this.filePath = filePath ?? path24.join(defaultConfigDir(), "publish-selections.json");
+    this.filePath = filePath ?? path23.join(defaultConfigDir(), "publish-selections.json");
   }
   async read() {
     try {
-      const raw = await readFile31(this.filePath, "utf8");
+      const raw = await readFile30(this.filePath, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") {
         return {
@@ -14140,7 +13565,7 @@ class PublishSelectionsStore {
     return { version: 1, global: {}, projects: {} };
   }
   async write(data) {
-    await mkdir13(path24.dirname(this.filePath), { recursive: true });
+    await mkdir13(path23.dirname(this.filePath), { recursive: true });
     await writeFile12(this.filePath, JSON.stringify(data, null, 2), {
       encoding: "utf8",
       mode: 384
@@ -14208,7 +13633,7 @@ function normalizeProjectKey(projectDir) {
 import { isMap as isMap4 } from "yaml";
 // src/lib/lint-runner.ts
 import { resolve as resolve8 } from "node:path";
-import { readFile as readFile32 } from "node:fs/promises";
+import { readFile as readFile31 } from "node:fs/promises";
 async function runLint(opts = {}) {
   const { glob } = await import("glob");
   const { manifest, manifestDir } = await loadManifestWithPath(opts.manifest, {
@@ -14239,7 +13664,7 @@ async function runLint(opts = {}) {
   for (const file of files) {
     let css;
     try {
-      css = await readFile32(file, "utf8");
+      css = await readFile31(file, "utf8");
     } catch (err) {
       log.error(`  ${file}`);
       log.error(`    cannot read stylesheet: ${err instanceof Error ? err.message : String(err)}`);