gutterpress 0.11.10-alpha.2 → 0.11.10-alpha.6

package/dist/{cli-4xksazfr.js → cli-z8ye91f0.js}

@@ -13,22 +13,20 @@ import {
   stampCreator,
   stripAnnotations,
   warn
-} from "./cli-p679pvce.js";
+} from "./cli-vbzkkcbv.js";
 import {
   DEBOUNCE,
   UsageError,
   resolvePort
-} from "./cli-k2hwrp7s.js";
+} from "./cli-97bdz5k0.js";
 import {
   MARGIN_BOX_IGNORED_PROPERTIES,
-  RENDER_TIMEOUT_MS,
-  REQUIRED_MILESTONE,
-  closeBrowser,
   getAssetPath,
-  getAssetsDir,
-  getBrowser,
-  prewarmBrowser
-} from "./cli-d8rdk1y7.js";
+  getAssetsDir
+} from "./cli-30j93gzt.js";
+import {
+  BuildError
+} from "./cli-46ycxe6r.js";
 import {
   INSTALL_HINTS,
   execCapture,
@@ -36,32 +34,24 @@ import {
   requireChromiumExecutable,
   resolveChromiumExecutable,
   spawnCapture
-} from "./cli-c41yr7he.js";
-import {
-  BuildError
-} from "./cli-46ycxe6r.js";
+} from "./cli-7fkhgtfn.js";
 import {
   PLUGINS_DIR,
   VENDORED_NPM_DIR,
-  VENDOR_RECEIPT_FILE,
-  VENDOR_RECEIPT_VERSION,
   assertWindowsSafeRelativePath,
-  computeVendorTreeDigest,
   hasUncommittedChanges,
   isExactNpmVersion,
   isValidNpmPackageName,
   listWorkdirChanges,
-  npmRegistryUrl,
-  packageEntryFormat,
   packageResolutionTargets,
   parseNpmPluginSpec,
   resolvePackageEntry,
   resolveVendoredPluginInstallRoot,
+  safePackageTarget,
   vendoredNpmPluginPackageDir,
   vendoredNpmPluginRoot,
-  verifyVendoredPlugin,
   windowsPathKey
-} from "./cli-pfczdbyd.js";
+} from "./cli-5qr3z0qa.js";
 import {
   detectProjectSource,
   repoSubPath
@@ -2797,7 +2787,7 @@ async function inlineShapeUrls(html, baseDir) {
 }
 
 // src/checks/source/local-ref-parser.ts
-import { readFile as readFile11 } from "node:fs/promises";
+import { readFile as readFile10 } from "node:fs/promises";
 
 // src/lib/markdown/renderer.ts
 import MarkdownIt from "markdown-it";
@@ -4616,16 +4606,11 @@ function layerSlug(name) {
 }
 
 // src/lib/markdown/plugins.ts
-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 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";
-import Module, { builtinModules, createRequire } from "node:module";
-import { parse as parseJavaScript } from "acorn";
-import { parse as parseModuleImports } from "es-module-lexer/js";
-import { imports as resolvePackageImports } from "resolve.exports";
+import { existsSync as existsSync6, readFileSync, statSync as statSync2, unlinkSync } from "node:fs";
+import { link, unlink } from "node:fs/promises";
+import { isBuiltin } from "node:module";
+import { resolve as resolve4, join, dirname as dirname2, basename, extname, isAbsolute, relative, sep } from "node:path";
+import { pathToFileURL } from "node:url";
 
 // src/lib/style-declarations.ts
 import { existsSync as existsSync5 } from "node:fs";
@@ -4737,513 +4722,97 @@ function resolveExtension(dir, meta, subject) {
   };
 }
 // src/lib/markdown/plugins.ts
-var moduleInternals = Module;
-var vendorCjsTrees = new Map;
-var latestVendorCjsTree = new Map;
-var isolatedVendorTrees = new Map;
-var nodeBuiltins = new Set(builtinModules.flatMap((name) => [name, `node:${name}`]));
-var needsNativeCjsResolver = !process.versions.bun;
-var cjsResolverInstalled = false;
-var isolatedVendorBase;
-var isolatedVendorBasePath = null;
-var vendorSnapshotHook;
-function pathContains(root, candidate) {
-  const value = relative(root, candidate);
-  return value === "" || !value.startsWith("..") && !isAbsolute(value);
-}
-function barePackageRequest(request) {
-  if (!request || request.startsWith(".") || request.startsWith("/") || request.startsWith("#") || isAbsolute(request) || /^[a-zA-Z][a-zA-Z+.-]*:/.test(request)) {
-    return null;
-  }
-  const parts = request.split("/");
-  if (request.startsWith("@")) {
-    if (parts.length < 2)
-      return null;
-    return { name: `${parts[0]}/${parts[1]}`, subpath: parts.slice(2).join("/") };
-  }
-  return { name: parts[0], subpath: parts.slice(1).join("/") };
-}
-function resolveVerifiedTarget(pkg, resolution) {
-  const target = resolution.target.startsWith("./") ? resolution.target.slice(2) : resolution.target;
-  if (!target || target.includes("\\") || target.includes("*") || target.includes("?") || target.includes("#")) {
-    return null;
-  }
-  try {
-    assertWindowsSafeRelativePath(target);
-  } catch {
-    return null;
-  }
-  if (target.normalize("NFKC").split("/").some((part) => part.toLowerCase() === "node_modules")) {
-    return null;
-  }
-  const base = resolve4(pkg.packageDir, ...target.split("/"));
-  if (!pathContains(pkg.packageDir, base))
-    return null;
-  const candidates = resolution.exact ? [base] : [
-    base,
-    `${base}.js`,
-    `${base}.cjs`,
-    `${base}.mjs`,
-    `${base}.json`,
-    join(base, "index.js"),
-    join(base, "index.cjs"),
-    join(base, "index.mjs"),
-    join(base, "index.json")
-  ];
-  for (const candidate of candidates) {
-    try {
-      const info2 = lstatSync(candidate);
-      const extension = extname(candidate);
-      if (info2.isFile() && !info2.isSymbolicLink() && (!extension || [".js", ".cjs", ".mjs", ".json"].includes(extension))) {
-        return candidate;
-      }
-    } catch {}
-  }
-  return null;
-}
-function resolveVerifiedRequest(pkg, subpath, condition) {
-  for (const resolution of packageResolutionTargets(pkg.manifest, subpath, condition)) {
-    const resolved = resolveVerifiedTarget(pkg, resolution);
-    if (resolved)
-      return resolved;
-  }
-  return null;
-}
-function resolveApprovedPackageRequest(owner, request, condition, tree, depth = 0) {
-  if (depth > 8)
-    return null;
-  if (nodeBuiltins.has(request)) {
-    return request.startsWith("node:") ? request : `node:${request}`;
-  }
-  if (request.startsWith("#")) {
-    let targets;
+var vendoredRootsOpened = new Set;
+var bunVendoredResolverInstalled = false;
+function isInsideDir(candidate, root) {
+  return candidate === root || candidate.startsWith(root.endsWith(sep) ? root : root + sep);
+}
+function resolveBareSpecifierSync(specifier, fromDir, stopRoot, condition) {
+  const parts = specifier.split("/");
+  const name = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  const subpath = specifier.slice(name.length).replace(/^\//, "");
+  for (let dir = fromDir;isInsideDir(dir, stopRoot); dir = dirname2(dir)) {
+    const packageDir = join(dir, "node_modules", ...name.split("/"));
+    const packageJson = join(packageDir, "package.json");
+    if (!existsSync6(packageJson)) {
+      if (dir === stopRoot)
+        break;
+      continue;
+    }
+    let manifest;
     try {
-      targets = resolvePackageImports(owner.manifest, request, {
-        require: condition === "require"
-      }) ?? [];
+      manifest = JSON.parse(readFileSync(packageJson, "utf8"));
     } catch {
       return null;
     }
-    for (const target2 of targets) {
-      if (target2.startsWith("./")) {
-        const resolved = resolveVerifiedTarget(owner, { target: target2, exact: true });
-        if (resolved)
-          return resolved;
-      } else {
-        const resolved = resolveApprovedPackageRequest(owner, target2, condition, tree, depth + 1);
-        if (resolved)
-          return resolved;
+    for (const target of packageResolutionTargets(manifest, subpath, condition)) {
+      const rel = safePackageTarget(target.target);
+      if (!rel)
+        continue;
+      const base = resolve4(packageDir, ...rel.split("/"));
+      if (!isInsideDir(base, packageDir))
+        continue;
+      const candidates = target.exact ? [base] : [base, `${base}.mjs`, `${base}.js`, `${base}.cjs`, `${base}.json`, join(base, "index.mjs"), join(base, "index.js"), join(base, "index.cjs")];
+      for (const candidate of candidates) {
+        try {
+          if (statSync2(candidate).isFile())
+            return candidate;
+        } catch {}
       }
     }
     return null;
   }
-  const parsed = barePackageRequest(request);
-  if (!parsed)
-    return null;
-  const targetPath = parsed.name === owner.name ? owner.path : owner.dependencies[parsed.name];
-  const target = targetPath ? tree.byPath.get(targetPath) : undefined;
-  if (!target)
-    return null;
-  if (parsed.subpath)
-    return resolveVerifiedRequest(target, parsed.subpath, condition);
-  return condition === "require" ? target.requireEntryPath ?? null : target.entryPath ?? null;
-}
-function unresolvedVendorRequest(request, parent) {
-  const error2 = new Error(`Cannot resolve undeclared or unexported package request "${request}" from ${parent}.`);
-  error2.code = "MODULE_NOT_FOUND";
-  return error2;
+  return null;
 }
-function ensureVendorCjsResolver() {
-  if (!needsNativeCjsResolver || cjsResolverInstalled)
+function installBunVendoredResolver() {
+  if (bunVendoredResolverInstalled)
     return;
-  cjsResolverInstalled = true;
-  const original = moduleInternals._resolveFilename;
-  moduleInternals._resolveFilename = function resolveVendorRequest(request, parent, isMain, options) {
-    if (parent?.filename && (request.startsWith("#") || barePackageRequest(request))) {
-      for (const tree of vendorCjsTrees.values()) {
-        const owner = tree.packages.find((pkg) => pathContains(pkg.packageDir, parent.filename));
-        if (!owner)
-          continue;
-        const resolved = resolveApprovedPackageRequest(owner, request, "require", tree);
-        if (resolved)
-          return resolved;
-        if (!nodeBuiltins.has(request)) {
-          throw unresolvedVendorRequest(request, parent.filename);
-        }
-      }
-    }
-    return Reflect.apply(original, this, [request, parent, isMain, options]);
-  };
-}
-async function getIsolatedVendorBase() {
-  isolatedVendorBase ??= mkdtemp(join(tmpdir(), "gutterpress-plugin-loads-"));
-  const base = await isolatedVendorBase;
-  isolatedVendorBasePath = base;
-  ensureExitCleanupRegistered();
-  return base;
-}
-function isolatedPackageCopyFilter(packageDir, candidate) {
-  const candidateRelative = relative(packageDir, candidate);
-  if (!candidateRelative)
-    return true;
-  const parts = candidateRelative.split(/[\\/]/);
-  const nodeModulesAt = parts.findIndex((part) => part.normalize("NFKC").toLowerCase() === "node_modules");
-  if (nodeModulesAt < 0)
-    return true;
-  if (nodeModulesAt === 0 && parts[0] === "node_modules")
-    return false;
-  throw new Error(`Package contains bundled node_modules content: ${candidateRelative}`);
-}
-function rewrittenSpecifier(owner, specifier, condition, tree) {
-  if (!specifier.startsWith("#") && !barePackageRequest(specifier) && !nodeBuiltins.has(specifier)) {
-    return null;
-  }
-  const resolved = resolveApprovedPackageRequest(owner, specifier, condition, tree);
-  if (!resolved) {
-    throw new Error(`Package request "${specifier}" from ${owner.name} is not a receipt-approved dependency.`);
-  }
-  if (resolved.startsWith("node:"))
-    return { replacement: resolved };
-  return {
-    replacement: condition === "require" ? resolved : pathToFileURL(resolved).href,
-    targetPath: resolved
-  };
-}
-function localModuleTarget(absolute, specifier, condition) {
-  if (!specifier.startsWith(".") && !specifier.startsWith("file:") && !isAbsolute(specifier)) {
-    return null;
-  }
-  try {
-    if (condition === "require" && !specifier.startsWith("file:")) {
-      return createRequire(absolute).resolve(specifier);
-    }
-    const url = specifier.startsWith("file:") ? new URL(specifier) : isAbsolute(specifier) ? pathToFileURL(specifier) : new URL(specifier, pathToFileURL(absolute));
-    const target = fileURLToPath(url);
-    return lstatSync(target).isFile() ? target : null;
-  } catch {
-    return null;
-  }
-}
-function packageOwningFile(tree, file) {
-  return tree.packages.find((pkg) => pathContains(pkg.packageDir, file));
-}
-function addReachableTarget(targets, target, specifier, absolute, tree) {
-  if (!target)
+  bunVendoredResolverInstalled = true;
+  const bun = globalThis.Bun;
+  if (typeof bun?.plugin !== "function")
     return;
-  if (!packageOwningFile(tree, target)) {
-    throw new Error(`Module "${specifier}" from ${absolute} resolves outside the verified package tree.`);
-  }
-  targets.add(target);
-}
-function visitSyntax(node, visitor) {
-  visitor(node);
-  for (const [key, value] of Object.entries(node)) {
-    if (["type", "start", "end", "loc", "range"].includes(key) || !value)
-      continue;
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (item && typeof item === "object" && typeof item.type === "string") {
-          visitSyntax(item, visitor);
+  bun.plugin({
+    name: "gutterpress-vendored-plugins",
+    setup(build) {
+      build.onResolve({ filter: /^[^./]/ }, (args) => {
+        if (!args.importer || isAbsolute(args.path) || /^[a-z]+:/i.test(args.path) || isBuiltin(args.path)) {
+          return;
         }
-      }
-    } else if (typeof value === "object" && typeof value.type === "string") {
-      visitSyntax(value, visitor);
-    }
-  }
-}
-function memberName(node) {
-  if (node.type !== "MemberExpression")
-    return null;
-  const property = node.property;
-  if (!property)
-    return null;
-  if (property.type === "Identifier")
-    return property.name;
-  if (property.type === "Literal" && typeof property.value === "string")
-    return property.value;
-  return null;
-}
-function isReceiptBoundRequireCall(node) {
-  if (node.type !== "CallExpression")
-    return false;
-  const callee = node.callee;
-  if (!callee)
-    return false;
-  if (callee.type === "Identifier" && callee.name === "require")
-    return true;
-  if (callee.type !== "MemberExpression")
-    return false;
-  const object2 = callee.object;
-  const property = memberName(callee);
-  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, {
-    ecmaVersion: "latest",
-    sourceType: "script",
-    allowHashBang: true,
-    allowReturnOutsideFunction: true
-  });
-  const replacements = [];
-  const targets = new Set;
-  visitSyntax(ast, (node) => {
-    if (!isReceiptBoundRequireCall(node))
-      return;
-    const args = node.arguments;
-    const argument = args?.[0];
-    if (!argument || argument.type !== "Literal" || typeof argument.value !== "string") {
-      throw new Error(`Dynamic require in ${pkg.name}/${relative(pkg.packageDir, absolute)} must use a string literal.`);
-    }
-    const rewritten = rewrittenSpecifier(pkg, argument.value, "require", tree);
-    if (rewritten) {
-      replacements.push({
-        start: argument.start,
-        end: argument.end,
-        value: JSON.stringify(rewritten.replacement)
-      });
-      addReachableTarget(targets, rewritten.targetPath, argument.value, absolute, tree);
-    } else {
-      const target = localModuleTarget(absolute, argument.value, "require");
-      if (!target) {
-        throw new Error(`CommonJS module "${argument.value}" from ${pkg.name}/${relative(pkg.packageDir, absolute)} could not be resolved.`);
-      }
-      addReachableTarget(targets, target, argument.value, absolute, tree);
-    }
-  });
-  return { replacements, targets };
-}
-async function rewriteReachableModuleImports(entryPath, tree) {
-  const pending = [entryPath];
-  const visited = new Set;
-  while (pending.length > 0) {
-    const absolute = pending.pop();
-    if (visited.has(absolute))
-      continue;
-    visited.add(absolute);
-    const extension = extname(absolute);
-    if (![".js", ".mjs", ".cjs"].includes(extension))
-      continue;
-    const pkg = packageOwningFile(tree, absolute);
-    if (!pkg)
-      throw new Error(`Reachable plugin module is outside the verified package tree: ${absolute}`);
-    const source = await readFile10(absolute, "utf8");
-    const [imports] = parseModuleImports(source, absolute);
-    const replacements = [];
-    const targets = new Set;
-    for (const imported of imports) {
-      if (imported.d === -2)
-        continue;
-      if (imported.n === undefined) {
-        throw new Error(`Dynamic import in ${pkg.name}/${relative(pkg.packageDir, absolute)} must use a string literal.`);
-      }
-      const rewritten2 = rewrittenSpecifier(pkg, imported.n, "import", tree);
-      if (rewritten2) {
-        addReachableTarget(targets, rewritten2.targetPath, imported.n, absolute, tree);
-        if (imported.d === -1) {
-          const quote = source[imported.s - 1];
-          if (quote !== '"' && quote !== "'" || source[imported.e] !== quote) {
-            throw new Error(`Could not safely rewrite an import in ${absolute}.`);
+        let root;
+        for (const opened of vendoredRootsOpened) {
+          if (isInsideDir(args.importer, opened)) {
+            root = opened;
+            break;
           }
-          replacements.push({
-            start: imported.s - 1,
-            end: imported.e + 1,
-            value: JSON.stringify(rewritten2.replacement)
-          });
-        } else {
-          replacements.push({
-            start: imported.s,
-            end: imported.e,
-            value: JSON.stringify(rewritten2.replacement)
-          });
         }
-      } else {
-        const target = localModuleTarget(absolute, imported.n, "import");
-        if (target) {
-          addReachableTarget(targets, target, imported.n, absolute, tree);
-        } else if (imported.n.startsWith(".") || imported.n.startsWith("file:") || isAbsolute(imported.n)) {
-          throw new Error(`ESM module "${imported.n}" from ${pkg.name}/${relative(pkg.packageDir, absolute)} could not be resolved.`);
-        }
-      }
-    }
-    if (extension === ".cjs" || extension === ".js" && pkg.manifest.type !== "module") {
-      const commonJs = rewriteCommonJsRequires(source, absolute, pkg, tree);
-      replacements.push(...commonJs.replacements);
-      for (const target of commonJs.targets)
-        targets.add(target);
-    }
-    replacements.sort((a, b) => b.start - a.start);
-    let rewritten = source;
-    for (const replacement of replacements) {
-      rewritten = rewritten.slice(0, replacement.start) + replacement.value + rewritten.slice(replacement.end);
-    }
-    if (replacements.length > 0)
-      await writeFile(absolute, rewritten, "utf8");
-    pending.push(...targets);
-  }
-}
-function remapPackageEntry(source, destination, entry) {
-  if (!entry)
-    return;
-  const entryRelative = relative(source.packageDir, entry);
-  if (!pathContains(source.packageDir, entry) || !entryRelative) {
-    throw new Error(`Verified entry for ${source.name} is outside its package.`);
-  }
-  return resolve4(destination, entryRelative);
-}
-async function createIsolatedVendorTree(verified, address) {
-  const base = await getIsolatedVendorBase();
-  const loadRoot = join(base, address);
-  await mkdir(loadRoot);
-  try {
-    const packageMap = new Map;
-    const sorted = [...verified.packages].sort((a, b) => a.path.localeCompare(b.path));
-    for (let index = 0;index < sorted.length; index++) {
-      const source = sorted[index];
-      const destination = join(loadRoot, "packages", String(index), "package");
-      await mkdir(dirname2(destination), { recursive: true });
-      await cp(source.packageDir, destination, {
-        recursive: true,
-        filter: (candidate) => isolatedPackageCopyFilter(source.packageDir, candidate)
-      });
-      packageMap.set(source.path, {
-        ...source,
-        packageDir: destination,
-        entryPath: remapPackageEntry(source, destination, source.entryPath),
-        requireEntryPath: remapPackageEntry(source, destination, source.requireEntryPath)
+        if (!root)
+          return;
+        const resolved = resolveBareSpecifierSync(args.path, dirname2(args.importer), root, args.kind === "require-call" || args.kind === "require-resolve" ? "require" : "import");
+        return resolved ? { path: resolved } : undefined;
       });
     }
-    const packages = [...packageMap.values()];
-    const tree = {
-      sourceRoot: verified.installRoot,
-      packages,
-      byPath: new Map(packages.map((pkg) => [pkg.path, pkg]))
-    };
-    const rootPackage = packageMap.get(verified.receipt.root.packagePath);
-    if (!rootPackage)
-      throw new Error("Verified root package is missing from the isolated tree.");
-    const sourceRoot = verified.packages.find((pkg) => pkg.path === verified.receipt.root.packagePath);
-    const entryPath = remapPackageEntry(sourceRoot, rootPackage.packageDir, verified.entryPath);
-    if (!entryPath)
-      throw new Error("Verified plugin entry is missing from the isolated tree.");
-    await rewriteReachableModuleImports(entryPath, tree);
-    return { loadRoot, entryPath, packages };
-  } catch (error2) {
-    await rm(loadRoot, { recursive: true, force: true }).catch(() => {});
-    throw error2;
-  }
-}
-async function isolateVendoredPlugin(verified) {
-  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) => {
-      isolatedVendorTrees.delete(address);
-      throw error2;
-    });
-    isolatedVendorTrees.set(address, pending);
-  }
-  const isolated = await pending;
-  return {
-    ...verified,
-    loadRoot: isolated.loadRoot,
-    entryPath: isolated.entryPath,
-    packages: isolated.packages
-  };
-}
-async function snapshotAndIsolateVendoredPlugin(baseDir, packageName, version) {
-  const sourceRoot = await resolveVendoredPluginInstallRoot(baseDir, packageName, version);
-  if (!sourceRoot)
-    return null;
-  const base = await getIsolatedVendorBase();
-  const container = await mkdtemp(join(base, "snapshot-"));
-  const snapshotProject = join(container, "project");
-  const snapshotRoot = vendoredNpmPluginRoot(snapshotProject, packageName, version);
-  try {
-    await mkdir(dirname2(snapshotRoot), { recursive: true });
-    await cp(sourceRoot, snapshotRoot, {
-      recursive: true,
-      dereference: false,
-      verbatimSymlinks: true
-    });
-    await vendorSnapshotHook?.(sourceRoot, snapshotRoot);
-    const verifiedSnapshot = await verifyVendoredPlugin(snapshotProject, packageName, version);
-    if (!verifiedSnapshot)
-      return null;
-    const isolated = await isolateVendoredPlugin(verifiedSnapshot);
-    return { ...isolated, installRoot: sourceRoot };
-  } finally {
-    await rm(container, { recursive: true, force: true }).catch(() => {});
-  }
-}
-function registerVendorCjsTree(verified) {
-  ensureVendorCjsResolver();
-  const key = `${verified.installRoot}\x00${verified.loadRoot}`;
-  const previousKey = latestVendorCjsTree.get(verified.installRoot);
-  if (vendorCjsTrees.has(key)) {
-    latestVendorCjsTree.set(verified.installRoot, key);
-    return () => {};
-  }
-  const packages = [...verified.packages].sort((a, b) => b.packageDir.length - a.packageDir.length);
-  vendorCjsTrees.set(key, {
-    sourceRoot: verified.installRoot,
-    ...previousKey ? { previousKey } : {},
-    packages,
-    byPath: new Map(packages.map((pkg) => [pkg.path, pkg]))
   });
-  latestVendorCjsTree.set(verified.installRoot, key);
-  return () => {
-    vendorCjsTrees.delete(key);
-    if (latestVendorCjsTree.get(verified.installRoot) === key) {
-      if (previousKey)
-        latestVendorCjsTree.set(verified.installRoot, previousKey);
-      else
-        latestVendorCjsTree.delete(verified.installRoot);
-    }
-  };
-}
-function clearVendoredPluginResolver(baseDir, packageName, version) {
-  let projectDir = baseDir;
-  try {
-    projectDir = realpathSync(baseDir);
-  } catch {}
-  const sourceRoot = vendoredNpmPluginRoot(projectDir, packageName, version);
-  const key = latestVendorCjsTree.get(sourceRoot);
-  if (!key)
-    return;
-  const tree = vendorCjsTrees.get(key);
-  vendorCjsTrees.delete(key);
-  if (tree?.previousKey)
-    latestVendorCjsTree.set(sourceRoot, tree.previousKey);
-  else
-    latestVendorCjsTree.delete(sourceRoot);
 }
 async function loadNpmPackage(packageName, baseDir, version) {
   if (version && isValidNpmPackageName(packageName) && isExactNpmVersion(version)) {
-    const verified = await snapshotAndIsolateVendoredPlugin(baseDir, packageName, version);
-    if (verified) {
-      const restoreRegistration = registerVendorCjsTree(verified);
+    const installRoot = await resolveVendoredPluginInstallRoot(baseDir, packageName, version);
+    if (installRoot) {
+      const packageDir = vendoredNpmPluginPackageDir(installRoot, packageName);
+      let entry;
       try {
-        const moduleDir = dirname2(verified.entryPath);
-        const packageDir = verified.packages.find((pkg) => pkg.path === verified.receipt.root.packagePath)?.packageDir ?? null;
-        const entryPath = verified.entryPath;
-        if (verified.format === "commonjs") {
-          return {
-            module: createRequire(verified.entryPath)(verified.entryPath),
-            moduleDir,
-            packageDir,
-            entryPath
-          };
-        }
-        return {
-          module: await import(pathToFileURL(verified.entryPath).href),
-          moduleDir,
-          packageDir,
-          entryPath
-        };
-      } catch (error2) {
-        restoreRegistration();
-        throw error2;
+        entry = await resolvePackageEntry(packageDir);
+      } catch (cause) {
+        throw new Error(`the downloaded copy of ${packageName}@${version} under plugins/npm/ is incomplete ` + `(${cause instanceof Error ? cause.message : String(cause)}). ` + `Reinstall it with \`gutterpress ext add ${packageName}@${version}\`.`, { cause });
       }
+      const entryPath = join(packageDir, ...entry.split("/"));
+      vendoredRootsOpened.add(installRoot);
+      installBunVendoredResolver();
+      return {
+        module: await import(pathToFileURL(entryPath).href),
+        moduleDir: dirname2(entryPath),
+        packageDir,
+        entryPath
+      };
     }
   }
   try {
@@ -5325,11 +4894,6 @@ function ensureExitCleanupRegistered() {
         unlinkSync(shadowPath);
       } catch {}
     }
-    if (isolatedVendorBasePath) {
-      try {
-        rmSync(isolatedVendorBasePath, { recursive: true, force: true });
-      } catch {}
-    }
   });
 }
 function shadowPathFor(pluginPath, mtimeMs) {
@@ -5605,7 +5169,7 @@ async function* renderedLocalRefs(ctx, checkId, results) {
   for (const file of files) {
     let refs;
     try {
-      refs = collectRenderedLocalRefs(await readFile11(file, "utf8"));
+      refs = collectRenderedLocalRefs(await readFile10(file, "utf8"));
     } catch {
       results.push(inspectionFailed(checkId, `Could not read source file: ${file}`, { file }));
       continue;
@@ -5672,10 +5236,10 @@ import os from "node:os";
 import fsp from "node:fs/promises";
 
 // src/lib/missing-asset-placeholder.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { deflateSync } from "node:zlib";
 function placeholderOutputPath(missingOutputPath) {
-  const hash = createHash3("sha256").update(missingOutputPath).digest("hex").slice(0, 16);
+  const hash = createHash2("sha256").update(missingOutputPath).digest("hex").slice(0, 16);
   return `assets/gutterpress-missing/${hash}.png`;
 }
 function decodeHtmlAttribute(value) {
@@ -5956,7 +5520,7 @@ var check21 = {
 registerCheck(check21);
 
 // src/checks/source/accessibility-alt-text.ts
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 var check22 = {
   id: "source.accessibility.alt-text",
   name: "Image Alt Text",
@@ -5970,7 +5534,7 @@ var check22 = {
     const results = [];
     for (const file of files) {
       try {
-        const content = await readFile12(file, "utf8");
+        const content = await readFile11(file, "utf8");
         const lines = content.split(`
 `);
         let inFence = false;
@@ -6014,7 +5578,7 @@ function extractImageAlts(line) {
 registerCheck(check22);
 
 // src/checks/source/accessibility-heading-order.ts
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 var check23 = {
   id: "source.accessibility.heading-order",
   name: "Heading Order",
@@ -6028,7 +5592,7 @@ var check23 = {
     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;
@@ -6064,7 +5628,7 @@ var check23 = {
 registerCheck(check23);
 
 // src/checks/source/layout-markers.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile13 } from "node:fs/promises";
 var check24 = {
   id: "source.markdown.layout-markers",
   name: "Layout Markers",
@@ -6082,7 +5646,7 @@ var check24 = {
     const md = createMarkdownRenderer(plugins);
     for (const file of files) {
       try {
-        const content = await readFile14(file, "utf8");
+        const content = await readFile13(file, "utf8");
         const env = {};
         md.render(content, env);
         for (const w of env.layoutWarnings ?? []) {
@@ -6104,7 +5668,7 @@ var check24 = {
 registerCheck(check24);
 
 // src/checks/source/merge-markers.ts
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 import path5 from "node:path";
 
 // src/checks/asset/extensions.ts
@@ -6146,7 +5710,7 @@ var check25 = {
     for (const file of textFiles) {
       let content;
       try {
-        content = await readFile15(file, "utf8");
+        content = await readFile14(file, "utf8");
       } catch {
         results.push(inspectionFailed(check25.id, `Could not read source file: ${file}`, { file }));
         continue;
@@ -6209,7 +5773,7 @@ registerCheck(check25);
 import { stat as stat3 } from "node:fs/promises";
 
 // src/lib/image-inspect.ts
-import { stat as stat2, readFile as readFile16 } from "node:fs/promises";
+import { stat as stat2, readFile as readFile15 } from "node:fs/promises";
 var DEFAULT_DPI = 72;
 var cache = new Map;
 async function inspectImage(path6) {
@@ -6224,7 +5788,7 @@ async function inspectImage(path6) {
     return hit.info;
   let info2 = null;
   try {
-    const buf = await readFile16(path6);
+    const buf = await readFile15(path6);
     info2 = parseImage(buf);
   } catch {
     info2 = null;
@@ -6784,7 +6348,7 @@ var check33 = {
 registerCheck(check33);
 
 // src/checks/heuristic/section-density.ts
-import { readFile as readFile17 } from "node:fs/promises";
+import { readFile as readFile16 } from "node:fs/promises";
 var check34 = {
   id: "heuristic.chunking.section-density",
   name: "Section Density",
@@ -6801,7 +6365,7 @@ var check34 = {
     const results = [];
     for (const file of files) {
       try {
-        const content = await readFile17(file, "utf8");
+        const content = await readFile16(file, "utf8");
         const lines = content.split(`
 `);
         let currentSectionStart = 0;
@@ -6998,7 +6562,7 @@ function artifactName(title, format) {
 var BOOK_HTML_FILENAME = "book.html";
 
 // src/lib/markdown/index.ts
-import { readdir as readdir2, readFile as readFile18, writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
+import { readdir as readdir2, readFile as readFile17, writeFile, mkdir } from "node:fs/promises";
 
 // src/lib/remote-auth/sync-messages.ts
 function isOnlineSibling(filepath) {
@@ -7050,16 +6614,8 @@ async function assembleBookHtml(opts) {
     }
     for (const ref of env.imageRefs ?? [])
       imageRefs.add(ref);
-    if (opts.wrapChapters) {
-      const safe = chapterId.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
-      bodyContent += `<div class="gutterpress-chapter" data-chapter-src="${safe}">
-${rendered}
-</div>
-`;
-    } else {
-      bodyContent += rendered + `
+    bodyContent += rendered + `
 `;
-    }
   }
   if (opts.onImageRefs) {
     for (const ref of collectHtmlImageRefs(bodyContent))
@@ -7144,20 +6700,19 @@ ${css.trim()}
   }
   return assembleBookHtml({
     files,
-    readText: (relPath) => readFile18(join2(inputDir, canonicalChapterId(relPath)), "utf-8"),
+    readText: (relPath) => readFile17(join2(inputDir, canonicalChapterId(relPath)), "utf-8"),
     projectCss: inlined.css,
     preloadImages: cssAssetCopies.map((c) => c.to),
     title: opts.title,
     plugins: opts.plugins,
     pluginCss,
-    wrapChapters: opts.wrapChapters,
     annotateSourceChapters: opts.annotateSourceChapters,
     onChapterWarnings: opts.onChapterWarnings,
     onImageRefs: opts.onImageRefs
   });
 }
 async function renderChaptersToFile(inputDir, outDir, opts = {}) {
-  await mkdir2(outDir, { recursive: true });
+  await mkdir(outDir, { recursive: true });
   const html = await renderChapters(inputDir, {
     title: opts.title,
     styles: opts.styles,
@@ -7170,12 +6725,12 @@ async function renderChaptersToFile(inputDir, outDir, opts = {}) {
     onStyleWarnings: opts.onStyleWarnings
   });
   const outFile = join2(outDir, BOOK_HTML_FILENAME);
-  await writeFile2(outFile, html);
+  await writeFile(outFile, html);
   return outFile;
 }
 
 // src/lib/markdownlint-fix.ts
-import { readFile as readFile19, writeFile as writeFile3 } from "node:fs/promises";
+import { readFile as readFile18, writeFile as writeFile2 } from "node:fs/promises";
 import { applyFixes } from "markdownlint";
 import { lint as lint2 } from "markdownlint/sync";
 async function uncommittedAmong(inputDir, files) {
@@ -7215,7 +6770,7 @@ async function applyMarkdownlintFixes(ctx) {
   for (const [file, violations] of Object.entries(results)) {
     if (!Array.isArray(violations) || violations.length === 0)
       continue;
-    const before = await readFile19(file, "utf8");
+    const before = await readFile18(file, "utf8");
     const after = applyFixes(before, violations);
     if (after !== before)
       pending.push({ file, content: after });
@@ -7226,7 +6781,7 @@ async function applyMarkdownlintFixes(ctx) {
   }
   const dirty = await uncommittedAmong(ctx.inputDir, pending.map((p) => p.file));
   for (const { file, content } of pending) {
-    await writeFile3(file, content, "utf8");
+    await writeFile2(file, content, "utf8");
   }
   log.warn(`--fix: rewrote ${pending.length} file(s):`);
   for (const { file } of pending)
@@ -7719,8 +7274,8 @@ import { randomBytes } from "node:crypto";
 
 // src/lib/build-fingerprint.ts
 import * as fs from "node:fs";
-import { mkdir as mkdir3, readFile as readFile20, writeFile as writeFile4 } from "node:fs/promises";
-import { createHash as createHash4 } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile19, writeFile as writeFile3 } from "node:fs/promises";
+import { createHash as createHash3 } from "node:crypto";
 import path7 from "node:path";
 import git from "isomorphic-git";
 var FINGERPRINT_FILENAME = "build-fingerprint.json";
@@ -7806,10 +7361,10 @@ async function getEngineBundleHash() {
       getAssetPath("engine/gutterpress-agent.js")
     ]);
     const [viewerBytes, agentBytes] = await Promise.all([
-      readFile20(viewerPath),
-      readFile20(agentPath)
+      readFile19(viewerPath),
+      readFile19(agentPath)
     ]);
-    const hash = createHash4("sha256");
+    const hash = createHash3("sha256");
     hash.update(viewerBytes);
     hash.update(agentBytes);
     return hash.digest("hex").slice(0, 12);
@@ -7829,7 +7384,6 @@ async function getToolVersions() {
     gutterpress: PACKAGE_META.version,
     bun: process.versions.bun ?? null,
     node: process.versions.node,
-    "puppeteer-core": PACKAGE_META.dependencies["puppeteer-core"] ?? null,
     engineBundle: engineBundleHash,
     ghostscript: gsVersion,
     qpdf: qpdfVersion,
@@ -7877,8 +7431,8 @@ async function writeBuildFingerprint(input) {
     sourceRevision,
     tools
   };
-  await mkdir3(outputDir, { recursive: true });
-  await writeFile4(outPath, stableJsonStringify(payload), "utf8");
+  await mkdir2(outputDir, { recursive: true });
+  await writeFile3(outPath, stableJsonStringify(payload), "utf8");
   return outPath;
 }
 
@@ -7887,12 +7441,9 @@ var INSTALL_HINTS2 = {
   gs: INSTALL_HINTS.gs.body,
   qpdf: INSTALL_HINTS.qpdf.body
 };
-function rendersInPooledChromium(format, opts) {
-  return format !== "html" && !opts.engineBrowser;
-}
 async function preflightBuildTools(format, opts, config) {
   const missing = [];
-  if (rendersInPooledChromium(format, opts) && !await resolveChromiumExecutable()) {
+  if (format !== "html" && !opts.engineBrowser && !await resolveChromiumExecutable()) {
     await requireChromiumExecutable();
   }
   if (format === "pdfx" && !await resolveGhostscript()) {
@@ -7916,24 +7467,6 @@ ${list}
 
 Install the missing tools and re-run, or set GHOSTSCRIPT_PATH, CHROMIUM_PATH, or system PATH so gutterpress can find them. See the User Guide Chapter 7 (System Setup) at examples/gutterpress-user-guide/07-system-setup.md for the full per-feature matrix.`, 2);
 }
-async function verifyNativeChromiumMilestone() {
-  let version;
-  try {
-    const browser = await getBrowser(RENDER_TIMEOUT_MS);
-    version = await browser.version();
-  } catch (err) {
-    throw new BuildError(`Could not launch a Chromium browser for the PDF build: ` + `${err instanceof Error ? err.message : String(err)}`, 2);
-  }
-  const milestone = Number(/Chrome\/(\d+)/.exec(version)?.[1] ?? 0);
-  if (milestone < REQUIRED_MILESTONE) {
-    await closeBrowser();
-    throw new BuildError(`The Gutterpress native engine requires Chromium ${REQUIRED_MILESTONE}+; found ${version}.
-
-` + `Install a newer Chrome, Chromium, or Edge, or point CHROMIUM_PATH ` + `(or PUPPETEER_EXECUTABLE_PATH) at a ${REQUIRED_MILESTONE}+ binary.
-
-` + `Note: this applies to the CLI's own Chromium only — the desktop app ` + `renders PDFs with its own bundled browser and needs no ` + `separate install.`, 2);
-  }
-}
 function computeGates(format, opts, config) {
   if (format === "html") {
     if (opts.skipLint || opts.skipPreValidate || opts.skipPostValidate) {
@@ -8182,7 +7715,9 @@ class HtmlOutput {
 }
 
 class PdfOutput {
-  async finish(ctx, htmlFile) {
+  async finish(ctx, htmlFile, browser) {
+    if (!browser)
+      throw new BuildError("PDF build reached the render stage without a browser");
     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");
@@ -8193,13 +7728,13 @@ class PdfOutput {
       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-qtfrfbpk.js");
+      const { buildNativePdf } = await import("./engine-mwshptgf.js");
       const engineDiagnostics = await buildNativePdf(htmlFile, rawPdf, {
         title: config.title,
         author: config.authors.length > 0 ? config.authors.join(", ") : undefined,
         signature: config.print.signature,
         allowShrink: opts.allowShrink
-      }, opts.engineBrowser);
+      }, browser);
       for (const d of engineDiagnostics)
         log.warn(d.message);
       if (!pdfxMode) {
@@ -8266,20 +7801,26 @@ async function runBuild(opts) {
   if (ctx.format !== "html") {
     await preflightBuildTools(ctx.format, opts, ctx.config);
   }
-  if (rendersInPooledChromium(ctx.format, opts))
-    prewarmBrowser(RENDER_TIMEOUT_MS);
+  const launch = opts.engineBrowser ?? (async () => (await import("./cdp-smdx6mr3.js")).launchChromium());
+  const browserPromise = ctx.format === "html" ? null : launch();
+  browserPromise?.catch(() => {});
   try {
     await fsp2.mkdir(ctx.workDir, { recursive: true });
     await runQualityGates(ctx);
-    if (rendersInPooledChromium(ctx.format, opts)) {
-      await verifyNativeChromiumMilestone();
+    let browser;
+    if (browserPromise) {
+      try {
+        browser = await browserPromise;
+      } catch (err) {
+        throw new BuildError(`Could not launch a Chromium browser for the PDF build: ${err instanceof Error ? err.message : String(err)}`, 2);
+      }
     }
     const htmlFile = await renderBook(ctx);
     const strategy = ctx.format === "html" ? new HtmlOutput : new PdfOutput;
-    return await strategy.finish(ctx, htmlFile);
+    return await strategy.finish(ctx, htmlFile, browser);
   } finally {
-    if (!opts.keepBrowserAlive)
-      await closeBrowser();
+    if (browserPromise)
+      await browserPromise.then((b) => b.close(), () => {});
     await fsp2.rm(ctx.workDir, { recursive: true, force: true });
   }
 }
@@ -8314,9 +7855,9 @@ function openPath(filePath) {
 
 // src/preview/lifecycle.ts
 import path10 from "path";
-import { tmpdir as tmpdir2 } from "os";
+import { tmpdir } from "os";
 import { randomBytes as randomBytes2 } from "crypto";
-import { readdir as readdir3, readFile as readFile21, writeFile as writeFile5 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile20, writeFile as writeFile4 } from "node:fs/promises";
 
 // src/utils/file-utils.ts
 import { promises as fs3 } from "fs";
@@ -8331,7 +7872,7 @@ async function fileExists(filePath) {
 async function remove(targetPath) {
   await fs3.rm(targetPath, { recursive: true, force: true });
 }
-async function mkdir4(dirPath) {
+async function mkdir3(dirPath) {
   await fs3.mkdir(dirPath, { recursive: true });
 }
 
@@ -8355,9 +7896,6 @@ var EMPTY_BOOK_HTML = `<!doctype html>
 </body>
 </html>
 `;
-function incrementalPreviewEnabled() {
-  return process.env.GUTTERPRESS_PREVIEW_INCREMENTAL !== "0";
-}
 async function renderPreviewBook(inputPath, config, opts) {
   const { plugins, pluginStyles } = await loadPluginsWithCss(config.extensions, inputPath, (ref, err) => warn(`Skipping plugin "${ref}" in preview — ${err.message}`));
   return renderChapters(inputPath, {
@@ -8366,7 +7904,6 @@ async function renderPreviewBook(inputPath, config, opts) {
     files: opts.files,
     plugins,
     pluginStyles,
-    wrapChapters: opts.wrapChapters,
     annotateSourceChapters: true,
     ...opts.onCssAssets ? { onCssAssets: opts.onCssAssets } : {},
     onChapterWarnings: (file, warnings) => {
@@ -8376,17 +7913,12 @@ async function renderPreviewBook(inputPath, config, opts) {
     }
   });
 }
-function injectPreviewScripts(html, pageIsolateChapters) {
+function injectPreviewScripts(html) {
   const scripts = `  <script src="/engine/gutterpress-viewer.js"></script>
   ` + `<script src="/preview/scripts/preview-interface.js"></script>
   ` + `<script src="/preview/scripts/preview-bridge.js"></script>
 `;
-  let output = /<\/head>/i.test(html) ? html.replace(/<\/head>/i, scripts + "</head>") : html + scripts;
-  if (pageIsolateChapters && /<\/head>/i.test(output)) {
-    output = output.replace(/<\/head>/i, `<style>.gutterpress-chapter{break-before:page}</style>
-</head>`);
-  }
-  return output;
+  return /<\/head>/i.test(html) ? html.replace(/<\/head>/i, scripts + "</head>") : html + scripts;
 }
 async function generateAndWriteHtml(inputPath, tempDir, config, cssAssets) {
   if (!inputPath) {
@@ -8397,7 +7929,6 @@ async function generateAndWriteHtml(inputPath, tempDir, config, cssAssets) {
   const nextAssets = new Map;
   const html = await renderPreviewBook(inputPath, config, {
     files: config.source?.files ?? null,
-    wrapChapters: false,
     onCssAssets: (copies) => {
       for (const copy of copies)
         nextAssets.set(copy.to, copy.from);
@@ -8406,39 +7937,7 @@ async function generateAndWriteHtml(inputPath, tempDir, config, cssAssets) {
   cssAssets.clear();
   for (const [to, from] of nextAssets)
     cssAssets.set(to, from);
-  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, {
-    files: [canonicalChapterId(file)],
-    wrapChapters: true
-  });
-  return injectPreviewScripts(html, true);
-}
-function describeChanges(changes, inputResolved) {
-  const files = [];
-  for (const [changedPath, event] of changes) {
-    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: path9.extname(changedPath).toLowerCase(),
-      event
-    });
-  }
-  return files;
-}
-function decideBroadcast(files, changeCount, incremental) {
-  const only = files.length === 1 ? files[0] : null;
-  if (incremental && changeCount === 1 && only?.ext === ".md" && only.event !== "unlink" && only.event !== "unlinkDir") {
-    return {
-      kind: "chapter-splice",
-      chapterId: canonicalChapterId(only.relativePath),
-      relativePath: only.relativePath
-    };
-  }
-  return { kind: "full-reload" };
+  await fsp3.writeFile(path9.join(tempDir, BOOK_HTML_FILENAME), injectPreviewScripts(html), "utf-8");
 }
 function isDotPathUnderRoot(candidatePath, root) {
   const normalizedRoot = root.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -8754,14 +8253,8 @@ function createFileWatcher(state) {
       await generateAndWriteHtml(inputResolved, state.tempDir, updatedConfig, state.cssAssets);
       if (closed)
         return;
-      const decision = decideBroadcast(describeChanges(changes, inputResolved), changes.length, incrementalPreviewEnabled());
-      if (decision.kind === "chapter-splice") {
-        state.previewServer?.broadcastContentUpdate(decision.chapterId);
-        info(`Chapter updated: ${decision.relativePath}`);
-      } else {
-        state.previewServer?.broadcastReload();
-        info(changes.length > 1 ? `Preview updated (${changes.length} files changed — full reload)` : "Preview updated");
-      }
+      state.previewServer?.broadcastReload();
+      info(changes.length > 1 ? `Preview updated (${changes.length} files changed)` : "Preview updated");
     } catch (err) {
       error("Failed to regenerate preview:", err);
     } finally {
@@ -8819,7 +8312,7 @@ async function stopFileWatcher(state) {
 }
 
 // src/preview/lifecycle.ts
-var TEMP_DIR_BASE = path10.join(tmpdir2(), "gutterpress-preview");
+var TEMP_DIR_BASE = path10.join(tmpdir(), "gutterpress-preview");
 var PID_FILE_NAME = ".gutterpress.pid";
 function isProcessAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0)
@@ -8842,7 +8335,7 @@ async function cleanupOrphanTempDirs() {
     const dir = path10.join(TEMP_DIR_BASE, entry);
     const pidFile = path10.join(dir, PID_FILE_NAME);
     try {
-      const raw = await readFile21(pidFile, "utf8");
+      const raw = await readFile20(pidFile, "utf8");
       const pid = parseInt(raw.trim(), 10);
       if (!isProcessAlive(pid)) {
         debug(`Removing orphan temp dir ${dir} (pid ${pid} not alive)`);
@@ -8855,9 +8348,9 @@ async function initializePreviewDirectories() {
   await cleanupOrphanTempDirs();
   const tempDirSuffix = randomBytes2(8).toString("hex");
   const tempDir = path10.join(TEMP_DIR_BASE, tempDirSuffix);
-  await mkdir4(tempDir);
+  await mkdir3(tempDir);
   debug(`Created temporary directory: ${tempDir}`);
-  await writeFile5(path10.join(tempDir, PID_FILE_NAME), `${process.pid}
+  await writeFile4(path10.join(tempDir, PID_FILE_NAME), `${process.pid}
 `, "utf8");
   return tempDir;
 }
@@ -8947,8 +8440,8 @@ function createServerState(inputPath, tempDir, config, options) {
 // src/preview/http-server.ts
 import http from "node:http";
 import net from "node:net";
-import { createHash as createHash5, randomUUID } from "node:crypto";
-import { readFile as readFile22, stat as stat4 } from "node:fs/promises";
+import { createHash as createHash4, randomUUID } from "node:crypto";
+import { readFile as readFile21, stat as stat4 } from "node:fs/promises";
 import path12 from "path";
 import { WebSocket, WebSocketServer } from "ws";
 
@@ -9003,169 +8496,6 @@ function resolveStaticPath(urlPathname, root) {
 
 // src/preview/http-server.ts
 var HMR_PATH = "/__gutterpress-hmr";
-function hmrClientSnippet(initialRevision, instanceId) {
-  return `
-<script>
-  (function () {
-    // When loaded by the preview SHELL (iframe double-buffer), the shell loads us
-    // with ?gutterpressshell=1 and owns HMR (it swaps frames + syncs scroll), so we stay
-    // inert. We must NOT bail merely because we're framed — other hosts (the
-    // Electron desktop's SPA) embed book.html directly and rely on this HMR client
-    // for scroll-anchor and reload.
-    if (/[?&]gutterpressshell=1/.test(location.search)) return;
-  var ANCHOR_KEY = 'gutterpress-scroll-anchor';
-  var appliedRevision = ${initialRevision};
-  var appliedInstance = ${JSON.stringify(instanceId)};
-  var readyToAcknowledge = false;
-  var reloadRequested = false;
-
-    // Find the element nearest the top of the viewport that carries a source
-    // line (markdown-it-source-map emits data-source-line on block elements).
-    // We anchor on SOURCE position, not pixels, because page breaks move when
-    // content re-paginates.
-    function captureAnchor() {
-      var els = document.querySelectorAll('[data-source-line]');
-      var best = null, bestTop = -Infinity;
-      for (var i = 0; i < els.length; i++) {
-        var r = els[i].getBoundingClientRect();
-        if (r.bottom < 0 || r.height === 0) continue;
-        if (r.top <= 80 && r.top > bestTop) { bestTop = r.top; best = els[i]; }
-      }
-      if (!best) {
-        for (var j = 0; j < els.length; j++) {
-          var rr = els[j].getBoundingClientRect();
-          if (rr.bottom > 0 && rr.height > 0) { best = els[j]; break; }
-        }
-      }
-      if (!best) return null;
-      var chapter = best.closest && best.closest('[data-chapter-src]');
-      return {
-        chapter: chapter ? chapter.getAttribute('data-chapter-src') : null,
-        line: best.getAttribute('data-source-line'),
-        offset: best.getBoundingClientRect().top
-      };
-    }
-
-    // After a content reload, put the same source line back at the same viewport
-    // offset so the author keeps their place (no jump to the top).
-    function restoreAnchor() {
-      var raw;
-      try { raw = sessionStorage.getItem(ANCHOR_KEY); } catch (_) { return; }
-      if (!raw) return;
-      try { sessionStorage.removeItem(ANCHOR_KEY); } catch (_) {}
-      var a; try { a = JSON.parse(raw); } catch (_) { return; }
-      var tries = 0;
-      (function attempt() {
-        var blocks = document.querySelectorAll('[data-source-line]');
-        var el = null;
-        for (var i = 0; i < blocks.length; i++) {
-          var chapter = blocks[i].closest && blocks[i].closest('[data-chapter-src]');
-          var chapterId = chapter ? chapter.getAttribute('data-chapter-src') : null;
-          if ((!a.chapter || chapterId === a.chapter) &&
-              blocks[i].getAttribute('data-source-line') === String(a.line)) {
-            el = blocks[i];
-            break;
-          }
-        }
-        if (el) {
-          window.scrollBy({
-            top: el.getBoundingClientRect().top - a.offset,
-            behavior: 'instant'
-          });
-          if (window.previewAPI && typeof window.previewAPI.refresh === 'function') {
-            window.previewAPI.refresh();
-          }
-          return;
-        }
-        if (tries++ < 240) setTimeout(attempt, 25); // wait for pagination
-      })();
-    }
-    var restored = false;
-    function restoreOnce() { if (restored) return; restored = true; restoreAnchor(); }
-    function finishInitialRender() {
-      restoreOnce();
-      readyToAcknowledge = true;
-      acknowledge();
-    }
-    // CRITICAL ordering: when the pagination engine is present it restructures
-    // the DOM after load, so restoring the scroll anchor early would target
-    // pre-pagination geometry. The Gutterpress engine viewer fires
-    // 'gp:layout' when its pagination completes — wait for it. In static
-    // mode (no engine) the content is final immediately, so restore right
-    // after load.
-    var hasEngine = !!document.querySelector('script[src*="/engine/gutterpress-viewer.js"]');
-    window.addEventListener('gp:layout', finishInitialRender, { once: true });
-    if (!hasEngine) {
-      if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', function () { setTimeout(finishInitialRender, 50); });
-      } else {
-        setTimeout(finishInitialRender, 50);
-      }
-    }
-    var ws = null;
-    var reconnectTimer = null;
-    var reconnectDelay = 250;
-    var stopped = false;
-
-    function acknowledge() {
-      if (!readyToAcknowledge || !ws || ws.readyState !== 1) return;
-      try {
-        ws.send(JSON.stringify({
-          type: 'reload-applied',
-          instance: appliedInstance,
-          revision: appliedRevision
-        }));
-      } catch (_) {}
-    }
-
-    function connect() {
-      if (stopped) return;
-      ws = new WebSocket(location.origin.replace(/^http/, 'ws') + '${HMR_PATH}');
-      ws.onopen = function () {
-        reconnectDelay = 250;
-        acknowledge();
-      };
-      ws.onmessage = function (e) {
-        var msg;
-        try { msg = JSON.parse(e.data); } catch (_) { return; }
-        if (
-          msg.type !== 'reload-state' &&
-          msg.type !== 'full-reload' &&
-          msg.type !== 'content-update'
-        ) return;
-        var instance = typeof msg.instance === 'string' ? msg.instance : null;
-        var revision = Number(msg.revision);
-        if (!instance || !Number.isSafeInteger(revision) || revision < 0) return;
-        if (instance === appliedInstance && revision <= appliedRevision) {
-          acknowledge();
-          return;
-        }
-        if (reloadRequested) return;
-        reloadRequested = true;
-        try { var a = captureAnchor(); if (a) sessionStorage.setItem(ANCHOR_KEY, JSON.stringify(a)); } catch (_) {}
-        location.reload();
-      };
-      ws.onclose = function () {
-        ws = null;
-        if (stopped || reconnectTimer !== null) return;
-        reconnectTimer = setTimeout(function () {
-          reconnectTimer = null;
-          connect();
-        }, reconnectDelay);
-        reconnectDelay = Math.min(reconnectDelay * 2, 5000);
-      };
-      ws.onerror = function () { try { ws.close(); } catch (_) {} };
-    }
-
-    window.addEventListener('beforeunload', function () {
-      stopped = true;
-      if (reconnectTimer !== null) clearTimeout(reconnectTimer);
-    });
-    connect();
-  })();
-</script>
-`;
-}
 function shellHtml(initialRevision, instanceId) {
   return `<!doctype html>
 <html lang="en"><head><meta charset="utf-8"><title>gutterpress preview</title>
@@ -9218,14 +8548,7 @@ async function findAvailablePort(startPort, host = "127.0.0.1") {
   }
   throw new BuildError(`Could not find an available port on ${host} from ${firstPort} to ${port - 1}; all are already in use. ` + "Stop another preview server or pass --port with an available port.", undefined, { cause: lastBusyError });
 }
-function injectHmrClient(html, revision, instanceId) {
-  const snippet = hmrClientSnippet(revision, instanceId);
-  const closingBody = html.lastIndexOf("</body>");
-  if (closingBody === -1)
-    return html + snippet;
-  return html.slice(0, closingBody) + snippet + html.slice(closingBody);
-}
-async function serveStatic(absPath, res, cacheControl = "no-store", extraHeaders = {}, hmrRevision = 0, hmrInstance = "") {
+async function serveStatic(absPath, res, cacheControl = "no-store", extraHeaders = {}) {
   let filePath = absPath;
   try {
     const s = await stat4(filePath);
@@ -9238,7 +8561,7 @@ async function serveStatic(absPath, res, cacheControl = "no-store", extraHeaders
   }
   let data;
   try {
-    data = await readFile22(filePath);
+    data = await readFile21(filePath);
   } catch {
     res.writeHead(404);
     res.end("Not Found");
@@ -9246,9 +8569,8 @@ async function serveStatic(absPath, res, cacheControl = "no-store", extraHeaders
   }
   const isHtml = filePath.endsWith(".html") || filePath.endsWith(".htm");
   if (isHtml) {
-    const withHmr = injectHmrClient(data.toString("utf-8"), hmrRevision, hmrInstance);
     res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
-    res.end(withHmr);
+    res.end(data);
     return;
   }
   const ct = STATIC_MIME[path12.extname(filePath).toLowerCase()] ?? "application/octet-stream";
@@ -9288,12 +8610,12 @@ async function serveRevalidatedStatic(req, absPath, res, validators) {
   let data;
   if (!validator || validator.stamp !== stamp) {
     try {
-      data = await readFile22(absPath);
+      data = await readFile21(absPath);
     } catch {
       await serveStatic(absPath, res);
       return;
     }
-    const digest = createHash5("sha256").update(data).digest("base64url");
+    const digest = createHash4("sha256").update(data).digest("base64url");
     validator = { stamp, etag: `"gutterpress-file-${digest}"` };
     validators.set(absPath, validator);
   }
@@ -9323,16 +8645,11 @@ async function createPreviewServer(state, port) {
   const projectAssetValidators = new Map;
   let reloadRevision = 0;
   const clients = new Map;
-  function sendRevision(ws, type, file) {
+  function sendRevision(ws, type) {
     if (ws.readyState !== WebSocket.OPEN)
       return;
     try {
-      ws.send(JSON.stringify({
-        type,
-        instance: instanceId,
-        revision: reloadRevision,
-        ...file ? { file } : {}
-      }));
+      ws.send(JSON.stringify({ type, instance: instanceId, revision: reloadRevision }));
     } catch {}
   }
   function waitForAcknowledgement(ws) {
@@ -9422,34 +8739,6 @@ async function createPreviewServer(state, port) {
       res.end("Not Found");
       return;
     }
-    if (url.pathname === "/__chapter" && req.method === "GET") {
-      const rawFile = url.searchParams.get("file");
-      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 || 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;
-      }
-      try {
-        const html = await renderChapterPreviewHtml(state.currentInputPath, file, state.config);
-        if (revision !== reloadRevision) {
-          res.writeHead(409);
-          res.end("Superseded");
-          return;
-        }
-        res.writeHead(200, {
-          "Content-Type": "text/html; charset=utf-8",
-          "Cache-Control": "no-store"
-        });
-        res.end(html);
-      } catch (error2) {
-        res.writeHead(500);
-        res.end(error2 instanceof Error ? error2.message : String(error2));
-      }
-      return;
-    }
     if (matchesEmbedded(url.pathname)) {
       if (req.headers["if-none-match"] === EMBEDDED_ETAG) {
         res.writeHead(304, { ETag: EMBEDDED_ETAG, "Cache-Control": EMBEDDED_CACHE_CONTROL });
@@ -9466,12 +8755,12 @@ async function createPreviewServer(state, port) {
       }
       return;
     }
-    if (url.pathname === "/" && incrementalPreviewEnabled()) {
+    if (url.pathname === "/") {
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
       res.end(shellHtml(reloadRevision, instanceId));
       return;
     }
-    const pathname = url.pathname === "/" ? "/book.html" : url.pathname;
+    const pathname = url.pathname;
     const cssAssetSource = state.cssAssets.get(pathname.replace(/^\/+/, ""));
     if (cssAssetSource) {
       await serveRevalidatedStatic(req, cssAssetSource, res, projectAssetValidators).catch((err) => {
@@ -9495,7 +8784,7 @@ async function createPreviewServer(state, port) {
       res.end("Not Found");
       return;
     }
-    const serve = servingProjectRoot ? serveRevalidatedStatic(req, absPath, res, projectAssetValidators) : serveStatic(absPath, res, "no-store", {}, reloadRevision, instanceId);
+    const serve = servingProjectRoot ? serveRevalidatedStatic(req, absPath, res, projectAssetValidators) : serveStatic(absPath, res);
     await serve.catch((err) => {
       if (!res.headersSent) {
         res.writeHead(500);
@@ -9523,22 +8812,6 @@ async function createPreviewServer(state, port) {
     openPath(serverUrl).catch(() => {});
   }
   let stopped = false;
-  const broadcastUpdate = (type, file) => {
-    if (stopped)
-      return;
-    reloadRevision++;
-    for (const [ws] of clients) {
-      sendRevision(ws, type, file);
-      waitForAcknowledgement(ws);
-    }
-  };
-  const updateInFlight = () => {
-    for (const client of clients.values()) {
-      if (client.acknowledgedRevision < reloadRevision)
-        return true;
-    }
-    return false;
-  };
   return {
     port: boundPort,
     async close() {
@@ -9560,13 +8833,13 @@ async function createPreviewServer(state, port) {
       });
     },
     broadcastReload() {
-      broadcastUpdate("full-reload");
-    },
-    broadcastContentUpdate(file) {
-      if (updateInFlight())
-        broadcastUpdate("full-reload");
-      else
-        broadcastUpdate("content-update", canonicalChapterId(file));
+      if (stopped)
+        return;
+      reloadRevision++;
+      for (const [ws] of clients) {
+        sendRevision(ws, "full-reload");
+        waitForAcknowledgement(ws);
+      }
     }
   };
 }
@@ -9627,14 +8900,14 @@ async function startPreviewServer(options) {
 }
 
 // src/lib/project-scaffold.ts
-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 { access, copyFile, cp, mkdir as mkdir5, readdir as readdir4, readFile as readFile23, stat as stat5, writeFile as writeFile5 } from "node:fs/promises";
 import { constants as FS, existsSync as existsSync11 } from "node:fs";
 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 readFile23, rename, rm as rm2 } from "node:fs/promises";
+import { mkdir as mkdir4, open, readFile as readFile22, rename, rm } from "node:fs/promises";
 import path13 from "node:path";
 import { parseDocument, isSeq, YAMLSeq } from "yaml";
 function resolveManifestPath(projectDir) {
@@ -9645,7 +8918,7 @@ async function loadManifestDoc(projectDir) {
   const file = resolveManifestPath(projectDir);
   let text = "";
   try {
-    text = await readFile23(file, "utf8");
+    text = await readFile22(file, "utf8");
   } catch (error2) {
     if (error2.code !== "ENOENT")
       throw error2;
@@ -9654,7 +8927,7 @@ async function loadManifestDoc(projectDir) {
 }
 async function writeManifestDoc(file, doc) {
   const dir = path13.dirname(file);
-  await mkdir5(dir, { recursive: true });
+  await mkdir4(dir, { recursive: true });
   const temporary = path13.join(dir, `.${path13.basename(file)}.tmp-${process.pid}-${randomUUID2()}`);
   try {
     const handle = await open(temporary, "wx", 438);
@@ -9671,7 +8944,7 @@ async function writeManifestDoc(file, doc) {
       await directory.close();
     }
   } finally {
-    await rm2(temporary, { force: true });
+    await rm(temporary, { force: true });
   }
 }
 function ensureSeq(doc, key) {
@@ -9780,23 +9053,23 @@ async function scaffoldProject(options) {
   const preset = customTemplateDir && options.preset === undefined ? undefined : requirePreset(options.preset, options.customPage);
   const targets = preset ? resolveScaffoldTargets(options.targets, preset) : undefined;
   try {
-    await mkdir6(projectDir, { recursive: true });
+    await mkdir5(projectDir, { recursive: true });
     if (customTemplateDir) {
       const entries = await readdir4(customTemplateDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name === ".gutterpress-template.json")
           continue;
-        await cp2(path14.join(customTemplateDir, entry.name), path14.join(projectDir, entry.name), { recursive: true });
+        await cp(path14.join(customTemplateDir, entry.name), path14.join(projectDir, entry.name), { recursive: true });
       }
-      await mkdir6(path14.join(projectDir, "assets"), { recursive: true });
+      await mkdir5(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(path14.join(projectDir, "assets"), { recursive: true });
+      await mkdir5(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");
+      await mkdir5(path14.join(projectDir, "styles"), { recursive: true });
+      await writeFile5(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)}`);
@@ -9843,7 +9116,7 @@ async function scaffoldProject(options) {
   let versionHistoryError;
   if (requested === "local-git") {
     try {
-      const { providerFor } = await import("./source-provider-ta09wegv.js");
+      const { providerFor } = await import("./source-provider-pzmz0br9.js");
       const provider = providerFor({ type: "local-folder", path: projectDir });
       await provider.initVersionHistory({
         projectDir,
@@ -9873,10 +9146,10 @@ async function ensureGitignoreHasDist(projectDir) {
   const gitignorePath = path14.join(projectDir, ".gitignore");
   let existing = null;
   try {
-    existing = await readFile24(gitignorePath, "utf8");
+    existing = await readFile23(gitignorePath, "utf8");
   } catch {}
   if (existing === null) {
-    await writeFile6(gitignorePath, `dist/
+    await writeFile5(gitignorePath, `dist/
 `, "utf8");
     return;
   }
@@ -9886,14 +9159,14 @@ async function ensureGitignoreHasDist(projectDir) {
     return;
   const needsLeadingNewline = existing.length > 0 && !existing.endsWith(`
 `);
-  await writeFile6(gitignorePath, existing + (needsLeadingNewline ? `
+  await writeFile5(gitignorePath, existing + (needsLeadingNewline ? `
 ` : "") + `dist/
 `, "utf8");
 }
 async function firstSourceFile(manifestPath) {
   let text;
   try {
-    text = await readFile24(manifestPath, "utf8");
+    text = await readFile23(manifestPath, "utf8");
   } catch {
     return;
   }
@@ -9905,15 +9178,15 @@ async function firstSourceFile(manifestPath) {
   return m ? m[1].trim() : undefined;
 }
 async function fillTemplateFile(filePath, substitutions) {
-  let text = await readFile24(filePath, "utf8");
+  let text = await readFile23(filePath, "utf8");
   for (const [token, value] of Object.entries(substitutions)) {
     text = text.split(token).join(value);
   }
-  await writeFile6(filePath, text, "utf8");
+  await writeFile5(filePath, text, "utf8");
 }
 
 // src/lib/extension-scaffold.ts
-import { access as access2, mkdir as mkdir7, readFile as readFile25, writeFile as writeFile7 } from "node:fs/promises";
+import { access as access2, mkdir as mkdir6, readFile as readFile24, writeFile as writeFile6 } from "node:fs/promises";
 import { constants as FS2 } from "node:fs";
 import path15 from "node:path";
 var EXTENSION_KINDS = ["plugin", "theme"];
@@ -10025,14 +9298,14 @@ async function scaffoldExtension(options) {
   const entries = TEMPLATE_FILES[kind];
   const written = [];
   try {
-    await mkdir7(extensionDir, { recursive: true });
+    await mkdir6(extensionDir, { recursive: true });
     for (const [assetName, relDest] of entries) {
       const src = await getAssetPath(`extension-templates/${kind}/${assetName}`);
       const dest = path15.join(extensionDir, relDest);
-      await mkdir7(path15.dirname(dest), { recursive: true });
-      const text = await readFile25(src, "utf8");
+      await mkdir6(path15.dirname(dest), { recursive: true });
+      const text = await readFile24(src, "utf8");
       const table = relDest.endsWith(".json") ? jsonSafe : plain;
-      await writeFile7(dest, substitute(text, table), "utf8");
+      await writeFile6(dest, substitute(text, table), "utf8");
       written.push(relDest);
     }
   } catch (e) {
@@ -10074,23 +9347,23 @@ var SKIP_ENTRIES = new Set([
 ]);
 
 // src/lib/extension-manager.ts
-import { cp as cp3, mkdir as mkdir9, readFile as readFile27, rm as rm4, stat as stat6 } from "node:fs/promises";
+import { cp as cp2, mkdir as mkdir8, readFile as readFile26, rm as rm3, stat as stat6 } from "node:fs/promises";
 import { existsSync as existsSync12 } from "node:fs";
 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 createHash6, randomUUID as randomUUID3, timingSafeEqual } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID3, timingSafeEqual } from "node:crypto";
 import { createReadStream } from "node:fs";
 import {
   lstat,
-  mkdir as mkdir8,
-  mkdtemp as mkdtemp2,
+  mkdir as mkdir7,
+  mkdtemp,
   open as open2,
-  readFile as readFile26,
+  readFile as readFile25,
   realpath,
   rename as rename2,
-  rm as rm3
+  rm as rm2
 } from "node:fs/promises";
 import path16 from "node:path";
 import { Transform } from "node:stream";
@@ -10131,6 +9404,25 @@ async function withFetchTimeout(options, run) {
   }
 }
 
+// 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/npm-plugin-installer.ts
 var DEFAULT_LIMITS = {
   metadataBytes: 15 * 1024 * 1024,
@@ -10345,7 +9637,7 @@ async function selectPackage(ctx, name, selector) {
 }
 async function downloadTarball(ctx, pkg, archivePath) {
   const file = await open2(archivePath, "wx");
-  const hash = createHash6(pkg.integrity.algorithm);
+  const hash = createHash5(pkg.integrity.algorithm);
   try {
     await withFetchTimeout({
       timeoutMs: TARBALL_TIMEOUT_MS,
@@ -10406,7 +9698,7 @@ async function extractTarball(ctx, archivePath, packageDir, packageName) {
     "OldGnuLongPath",
     "OldExtendedHeader"
   ]);
-  await mkdir8(packageDir, { recursive: true });
+  await mkdir7(packageDir, { recursive: true });
   const unpack = extract({
     cwd: packageDir,
     strip: 1,
@@ -10485,7 +9777,7 @@ async function readInstalledManifest(packageDir, selected) {
     const info2 = await lstat(packageJsonPath);
     if (!info2.isFile() || info2.isSymbolicLink())
       throw new Error("not a regular file");
-    manifest = object2(JSON.parse(await readFile26(packageJsonPath, "utf8")));
+    manifest = object2(JSON.parse(await readFile25(packageJsonPath, "utf8")));
   } catch (error2) {
     throw new SecurityInstallError(`Downloaded ${selected.name}@${selected.version} has no valid package.json (${error2 instanceof Error ? error2.message : String(error2)}).`);
   }
@@ -10494,16 +9786,6 @@ async function readInstalledManifest(packageDir, selected) {
   }
   return manifest;
 }
-async function optionalPackageEntry(packageDir, manifest, condition) {
-  try {
-    return await resolvePackageEntry(packageDir, manifest, condition);
-  } catch (error2) {
-    if (error2 instanceof Error && error2.message.includes("no contained JavaScript entry point")) {
-      return;
-    }
-    throw error2;
-  }
-}
 function platformAllowed(rule, current) {
   let values;
   if (typeof rule === "string") {
@@ -10528,11 +9810,9 @@ function relativePackagePath(parentPackagePath, name) {
 }
 async function installPackage(ctx, name, selector, parentPackagePath, ancestors, depth, optional) {
   const recordStart = ctx.records.length;
-  const skippedStart = ctx.skipped.length;
   const warningsBefore = new Set(ctx.warnings);
   const discardOptionalSubtree = () => {
     ctx.records.splice(recordStart);
-    ctx.skipped.splice(skippedStart);
     ctx.warnings = warningsBefore;
   };
   if (depth > ctx.limits.dependencyDepth) {
@@ -10558,39 +9838,35 @@ async function installPackage(ctx, name, selector, parentPackagePath, ancestors,
   const packageDir = path16.join(ctx.stageRoot, ...relativePath.split("/"));
   const archivePath = path16.join(ctx.downloadsDir, `${ctx.archiveCounter++}.tgz`);
   try {
-    await mkdir8(path16.dirname(packageDir), { recursive: true });
+    await mkdir7(path16.dirname(packageDir), { recursive: true });
     await downloadTarball(ctx, selected, archivePath);
     await extractTarball(ctx, archivePath, packageDir, selected.name);
     const manifest = await readInstalledManifest(packageDir, selected);
     if (!platformAllowed(manifest.os, process.platform) || !platformAllowed(manifest.cpu, process.arch)) {
       const reason = `${name}@${selected.version} does not support ${process.platform}/${process.arch}`;
       if (optional) {
-        await rm3(packageDir, { recursive: true, force: true });
+        await rm2(packageDir, { recursive: true, force: true });
         return { skipped: reason };
       }
       throw new PackageUnavailableError(reason);
     }
-    const importEntry = await optionalPackageEntry(packageDir, manifest, "import");
-    const requireEntry = await optionalPackageEntry(packageDir, manifest, "require");
-    if (parentPackagePath === null && !importEntry && !requireEntry) {
-      throw new SecurityInstallError(`${name}@${selected.version} has no JavaScript plugin entry.`);
+    if (parentPackagePath === null) {
+      try {
+        await resolvePackageEntry(packageDir, manifest);
+      } catch (cause) {
+        throw new SecurityInstallError(`${name}@${selected.version} has no JavaScript plugin entry.`, { cause });
+      }
     }
     const record = {
       path: relativePath,
       name,
       version: selected.version,
-      tarball: selected.tarball,
-      integrity: selected.integrity.label,
-      legacySha1: selected.integrity.legacySha1,
-      ...importEntry ? { entry: `${relativePath}/${importEntry}` } : {},
-      ...requireEntry ? { requireEntry: `${relativePath}/${requireEntry}` } : {},
-      dependencies: {},
       packageDir,
       manifest
     };
     ctx.records.push(record);
     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.`);
+      ctx.warnings.add(`${name}@${selected.version} is an old npm release with only SHA-1 registry integrity. It was accepted for compatibility.`);
     }
     const dependencies = stringMap(manifest.dependencies);
     const optionalDependencies = stringMap(manifest.optionalDependencies);
@@ -10610,38 +9886,21 @@ async function installPackage(ctx, name, selector, parentPackagePath, ancestors,
       const child = await installPackage(ctx, dependency, range, relativePath, nextAncestors, depth + 1, false);
       if (!child.path)
         throw new Error(`Required dependency ${dependency} was unexpectedly skipped.`);
-      record.dependencies[dependency] = child.path;
     }
     const optionalEntries = Object.entries(optionalDependencies).sort(([a], [b]) => a.localeCompare(b));
     for (const [dependency, range] of optionalEntries) {
-      const child = await installPackage(ctx, dependency, range, relativePath, nextAncestors, depth + 1, true);
-      if (child.path)
-        record.dependencies[dependency] = child.path;
-      else if (child.skipped) {
-        ctx.skipped.push({ from: relativePath, name: dependency, selector: range, kind: "optional", reason: child.skipped });
-      }
-    }
-    for (const [dependency, range] of Object.entries(peerDependencies)) {
-      if (object2(peerMeta[dependency])?.optional === true) {
-        ctx.skipped.push({
-          from: relativePath,
-          name: dependency,
-          selector: range,
-          kind: "optional-peer",
-          reason: "Optional peer dependencies are not auto-installed."
-        });
-      }
+      await installPackage(ctx, dependency, range, relativePath, nextAncestors, depth + 1, true);
     }
     return { path: relativePath };
   } catch (error2) {
-    await rm3(packageDir, { recursive: true, force: true });
+    await rm2(packageDir, { recursive: true, force: true });
     if (optional && isOptionalAvailabilityError(error2)) {
       discardOptionalSubtree();
       return { skipped: error2 instanceof Error ? error2.message : String(error2) };
     }
     throw error2;
   } finally {
-    await rm3(archivePath, { force: true });
+    await rm2(archivePath, { force: true });
   }
 }
 async function ensureDirectory(pathname) {
@@ -10653,14 +9912,14 @@ async function ensureDirectory(pathname) {
   } catch (error2) {
     if (error2.code !== "ENOENT")
       throw error2;
-    await mkdir8(pathname);
+    await mkdir7(pathname);
   }
 }
 async function prepareVendorParent(projectDir, name) {
   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 mkdir7(projectDir, { recursive: true });
   await ensureDirectory(plugins);
   await ensureDirectory(npm);
   await ensureDirectory(packageParent);
@@ -10673,29 +9932,16 @@ async function prepareVendorParent(projectDir, name) {
   }
   return realNpm;
 }
-function publicReceipt(record) {
-  return {
-    path: record.path,
-    name: record.name,
-    version: record.version,
-    tarball: record.tarball,
-    integrity: record.integrity,
-    legacySha1: record.legacySha1,
-    ...record.entry ? { entry: record.entry } : {},
-    ...record.requireEntry ? { requireEntry: record.requireEntry } : {},
-    dependencies: record.dependencies
-  };
-}
 async function installNpmPlugin(projectDirInput, packageSpec, options = {}) {
   const requestedProjectDir = path16.resolve(projectDirInput);
-  await mkdir8(requestedProjectDir, { recursive: true });
+  await mkdir7(requestedProjectDir, { recursive: true });
   const projectDir = await realpath(requestedProjectDir);
   const requested = parseNpmPluginSpec(packageSpec);
   const npmRoot = await prepareVendorParent(projectDir, requested.name);
-  const container = await mkdtemp2(path16.join(npmRoot, ".install-"));
+  const container = await mkdtemp(path16.join(npmRoot, ".install-"));
   const stageRoot = path16.join(container, "root");
   const downloadsDir = path16.join(container, "downloads");
-  await Promise.all([mkdir8(stageRoot), mkdir8(downloadsDir)]);
+  await Promise.all([mkdir7(stageRoot), mkdir7(downloadsDir)]);
   const ctx = {
     fetch: options.fetch ?? globalThis.fetch,
     signal: options.signal,
@@ -10704,7 +9950,6 @@ async function installNpmPlugin(projectDirInput, packageSpec, options = {}) {
     downloadsDir,
     packuments: new Map,
     records: [],
-    skipped: [],
     warnings: new Set,
     totalNetworkBytes: 0,
     totalUnpackedBytes: 0,
@@ -10720,34 +9965,6 @@ async function installNpmPlugin(projectDirInput, packageSpec, options = {}) {
     const rootRecord = ctx.records.find((record) => record.path === rootResult.path);
     if (!rootRecord)
       throw new Error("Root plugin package is missing from the dependency graph.");
-    const importEntry = rootRecord.entry ?? rootRecord.requireEntry;
-    if (!importEntry)
-      throw new Error("Root plugin package has no recorded JavaScript entry.");
-    const importFormat = packageEntryFormat(rootRecord.manifest, importEntry);
-    const entry = importFormat === "commonjs" ? rootRecord.requireEntry ?? importEntry : importEntry;
-    const format = packageEntryFormat(rootRecord.manifest, entry);
-    const tree = await computeVendorTreeDigest(stageRoot);
-    const receipt = {
-      schemaVersion: VENDOR_RECEIPT_VERSION,
-      root: {
-        name: rootRecord.name,
-        version: rootRecord.version,
-        packagePath: rootRecord.path,
-        entry,
-        format
-      },
-      packages: ctx.records.map(publicReceipt).sort((a, b) => a.path.localeCompare(b.path)),
-      skipped: ctx.skipped,
-      tree: { algorithm: "sha256", ...tree }
-    };
-    const receiptFile = await open2(path16.join(stageRoot, VENDOR_RECEIPT_FILE), "wx");
-    try {
-      await receiptFile.writeFile(`${JSON.stringify(receipt, null, 2)}
-`, "utf8");
-      await receiptFile.sync();
-    } finally {
-      await receiptFile.close();
-    }
     finalRoot = vendoredNpmPluginRoot(projectDir, rootRecord.name, rootRecord.version);
     const realFinalParent = await realpath(path16.dirname(finalRoot));
     if (!isContained(projectDir, realFinalParent)) {
@@ -10781,16 +9998,16 @@ async function installNpmPlugin(projectDirInput, packageSpec, options = {}) {
       warnings: [...ctx.warnings]
     };
   } finally {
-    await rm3(container, { recursive: true, force: true }).catch(() => {});
+    await rm2(container, { recursive: true, force: true }).catch(() => {});
   }
 }
 async function finalizeNpmPluginInstall(installed) {
   if (installed.backupRoot) {
-    await rm3(installed.backupRoot, { recursive: true, force: true });
+    await rm2(installed.backupRoot, { recursive: true, force: true });
   }
 }
 async function rollbackNpmPluginInstall(installed) {
-  await rm3(installed.installRoot, { recursive: true, force: true });
+  await rm2(installed.installRoot, { recursive: true, force: true });
   if (installed.backupRoot)
     await rename2(installed.backupRoot, installed.installRoot);
 }
@@ -11066,11 +10283,10 @@ async function removeExtension(projectDir, use) {
       return;
     }
     if (parsed.kind === "npm" && parsed.version) {
-      await rm4(vendoredNpmPluginRoot(projectDir, parsed.name, parsed.version), {
+      await rm3(vendoredNpmPluginRoot(projectDir, parsed.name, parsed.version), {
         recursive: true,
         force: true
       });
-      clearVendoredPluginResolver(projectDir, parsed.name, parsed.version);
     }
   });
 }
@@ -11152,7 +10368,6 @@ async function addExtensionUnlocked(projectDir, specifier, options) {
   } catch (cause) {
     try {
       await rollbackNpmPluginInstall(installed);
-      clearVendoredPluginResolver(projectDir, installed.name, installed.version);
     } catch (rollbackError) {
       throw new Error(`Extension install failed and its previous vendor tree could not be restored: ` + `${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`, { cause });
     }
@@ -11181,8 +10396,8 @@ async function addBuiltInStyleSet(projectDir, id) {
     const dest = path17.join(projectDir, EXTENSIONS_DIR, id);
     if (!existsSync12(dest)) {
       const src = path17.join(await getAssetsDir(), "themes", id);
-      await mkdir9(path17.dirname(dest), { recursive: true });
-      await cp3(src, dest, { recursive: true });
+      await mkdir8(path17.dirname(dest), { recursive: true });
+      await cp2(src, dest, { recursive: true });
     }
     return addExtensionUnlocked(projectDir, `./${EXTENSIONS_DIR}/${id}`, {});
   });
@@ -11190,8 +10405,8 @@ 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 readFile28, rm as rm5, writeFile as writeFile8 } from "node:fs/promises";
-import { tmpdir as tmpdir3 } from "node:os";
+import { cp as cp3, mkdir as mkdir9, mkdtemp as mkdtemp2, readFile as readFile27, rm as rm4, writeFile as writeFile7 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
 import path18 from "node:path";
 import { unzipSync } from "fflate";
 var MAX_THEME_ARCHIVE_BYTES = 25 * 1024 * 1024;
@@ -11263,7 +10478,7 @@ async function finalizeExtensionImport(projectDir, sourceDir, relPaths, fallback
   if (!existsSync13(cssPath)) {
     throw new Error("A theme must contain a theme.css file.");
   }
-  const css = await readFile28(cssPath, "utf8");
+  const css = await readFile27(cssPath, "utf8");
   const { reject, warnings: printFindings } = classifyThemeCssFindings(checkCss(css, "theme.css"));
   if (reject) {
     throw new Error(`theme.css could not be parsed — ${reject.message}`);
@@ -11291,7 +10506,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 readFile28(sheetPath, "utf8");
+    const sheetCss = await readFile27(sheetPath, "utf8");
     const { reject: sheetReject, warnings: sheetFindings } = classifyThemeCssFindings(checkCss(sheetCss, rel));
     if (sheetReject) {
       throw new Error(`${rel} could not be parsed — ${sheetReject.message}`);
@@ -11311,8 +10526,8 @@ async function finalizeExtensionImport(projectDir, sourceDir, relPaths, fallback
   }
   const id = await uniqueExtensionId(projectDir, meta.name?.trim() || fallbackName);
   const dest = path18.join(projectDir, EXTENSIONS_DIR, id);
-  await mkdir10(path18.dirname(dest), { recursive: true });
-  await cp4(sourceDir, dest, { recursive: true });
+  await mkdir9(path18.dirname(dest), { recursive: true });
+  await cp3(sourceDir, dest, { recursive: true });
   await completeLandedManifest(dest, id, meta, metaExists);
   const entry = await addExtension(projectDir, `./${EXTENSIONS_DIR}/${id}`);
   return { entry, warnings };
@@ -11324,14 +10539,14 @@ async function completeLandedManifest(dest, id, meta, metaExists) {
   let pkg = {};
   if (metaExists) {
     try {
-      const parsed = JSON.parse(await readFile28(file, "utf8"));
+      const parsed = JSON.parse(await readFile27(file, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         pkg = parsed;
       }
     } catch {}
   }
   const gutterpress = pkg.gutterpress && typeof pkg.gutterpress === "object" && !Array.isArray(pkg.gutterpress) ? pkg.gutterpress : {};
-  await writeFile8(file, JSON.stringify({
+  await writeFile7(file, JSON.stringify({
     ...pkg,
     name: typeof pkg.name === "string" && pkg.name.trim() ? pkg.name : id,
     gutterpress: { ...gutterpress, styles: ["theme.css"] }
@@ -11378,7 +10593,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(path18.join(tmpdir3(), "gutterpress-theme-"));
+  const tmp = await mkdtemp2(path18.join(tmpdir2(), "gutterpress-theme-"));
   try {
     const relPaths = [];
     for (const [name, data] of Object.entries(files)) {
@@ -11395,12 +10610,12 @@ async function importExtensionFromZip(projectDir, archive) {
         throw new Error(`The package contains an unsafe path and was rejected: ${name}`);
       }
       relPaths.push(rel);
-      await mkdir10(path18.dirname(dest), { recursive: true });
-      await writeFile8(dest, data);
+      await mkdir9(path18.dirname(dest), { recursive: true });
+      await writeFile7(dest, data);
     }
     return await finalizeExtensionImport(projectDir, tmp, relPaths, root || "imported-look");
   } finally {
-    await rm5(tmp, { recursive: true, force: true });
+    await rm4(tmp, { recursive: true, force: true });
   }
 }
 async function importExtensionFromCssText(projectDir, css, name) {
@@ -11409,10 +10624,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(path18.join(tmpdir3(), "gutterpress-theme-"));
+  const tmp = await mkdtemp2(path18.join(tmpdir2(), "gutterpress-theme-"));
   try {
-    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");
+    await writeFile7(path18.join(tmp, "theme.css"), css, "utf8");
+    await writeFile7(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",
@@ -11420,17 +10635,17 @@ async function importExtensionFromCssText(projectDir, css, name) {
     });
     return result;
   } finally {
-    await rm5(tmp, { recursive: true, force: true });
+    await rm4(tmp, { recursive: true, force: true });
   }
 }
 async function importExtensionFromFile(projectDir, filePath) {
   const ext = path18.extname(filePath).toLowerCase();
   if (ext === ".zip") {
-    const buf = await readFile28(filePath);
+    const buf = await readFile27(filePath);
     return importExtensionFromZip(projectDir, new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
   }
   if (ext === ".css") {
-    const css = await readFile28(filePath, "utf8");
+    const css = await readFile27(filePath, "utf8");
     return importExtensionFromCssText(projectDir, css, prettify(path18.basename(filePath, ".css")));
   }
   throw new Error("Choose a .zip extension package or a .css stylesheet.");
@@ -11493,9 +10708,9 @@ async function importExtensionFromUrl(projectDir, url) {
   if (!css.trim())
     throw new Error(`Fetched CSS from ${trimmed} was empty.`);
   assertLooksLikeCss(css, trimmed);
-  const tmp = await mkdtemp3(path18.join(tmpdir3(), "gutterpress-ext-"));
+  const tmp = await mkdtemp2(path18.join(tmpdir2(), "gutterpress-ext-"));
   try {
-    await writeFile8(path18.join(tmp, "theme.css"), css, "utf8");
+    await writeFile7(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"),
@@ -11507,10 +10722,10 @@ async function importExtensionFromUrl(projectDir, url) {
         preview: typeof gp.preview === "string" ? gp.preview : null
       }
     };
-    await writeFile8(path18.join(tmp, EXTENSION_MANIFEST_FILENAME), JSON.stringify(finalMeta, null, 2), "utf8");
+    await writeFile7(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 });
+    await rm4(tmp, { recursive: true, force: true });
   }
 }
 
@@ -12133,11 +11348,11 @@ ${tail}` : ""}`);
 };
 
 // src/lib/publish/providers/guided.ts
-import { copyFile as copyFile2, mkdir as mkdir11, writeFile as writeFile9 } from "node:fs/promises";
+import { copyFile as copyFile2, mkdir as mkdir10, writeFile as writeFile8 } from "node:fs/promises";
 import path19 from "node:path";
 async function stageGuidedPackage(req, providerId, listingLines) {
   const packageDir = path19.join(path19.dirname(req.artifact.path), "publish", providerId);
-  await mkdir11(packageDir, { recursive: true });
+  await mkdir10(packageDir, { recursive: true });
   await copyFile2(req.artifact.path, path19.join(packageDir, path19.basename(req.artifact.path)));
   const { title, authors } = req.project;
   const sheet = [
@@ -12151,7 +11366,7 @@ async function stageGuidedPackage(req, providerId, listingLines) {
     ""
   ].join(`
 `);
-  await writeFile9(path19.join(packageDir, "LISTING.md"), sheet, "utf8");
+  await writeFile8(path19.join(packageDir, "LISTING.md"), sheet, "utf8");
   return packageDir;
 }
 
@@ -12214,8 +11429,8 @@ var drivethrurpgProvider = {
 };
 
 // src/lib/publish/providers/gdrive.ts
-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 { mkdtemp as mkdtemp3, readFile as readFile28, readdir as readdir5, rm as rm5, stat as stat7, writeFile as writeFile9 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
 import path20 from "node:path";
 import { Zip, ZipDeflate } from "fflate";
 
@@ -12606,12 +11821,12 @@ async function collectZipEntries(root, dir, out, onWarn) {
       await collectZipEntries(root, full, out, onWarn);
     } else if (entry.isFile()) {
       const rel = path20.relative(root, full).split(path20.sep).join("/");
-      out[rel] = await readFile29(full);
+      out[rel] = await readFile28(full);
     } else if (entry.isSymbolicLink()) {
       const resolved = await stat7(full).catch(() => null);
       if (resolved?.isFile()) {
         const rel = path20.relative(root, full).split(path20.sep).join("/");
-        out[rel] = await readFile29(full);
+        out[rel] = await readFile28(full);
       } else if (resolved?.isDirectory()) {
         await collectZipEntries(root, full, out, onWarn);
       } else {
@@ -12622,11 +11837,11 @@ async function collectZipEntries(root, dir, out, onWarn) {
     }
   }
 }
-async function zipHtmlExport(exportDir, title, onWarn, writeArchiveImpl = writeFile10) {
+async function zipHtmlExport(exportDir, title, onWarn, writeArchiveImpl = writeFile9) {
   const entries = {};
   await collectZipEntries(exportDir, exportDir, entries, onWarn);
   const fileName = `${bookSlug(title)}-website.zip`;
-  const tmpRoot = await mkdtemp4(path20.join(tmpdir4(), "gutterpress-gdrive-"));
+  const tmpRoot = await mkdtemp3(path20.join(tmpdir3(), "gutterpress-gdrive-"));
   try {
     const filePath = path20.join(tmpRoot, fileName);
     const zipped = await zipEntriesNonBlocking(entries, { level: 6 });
@@ -12635,10 +11850,10 @@ async function zipHtmlExport(exportDir, title, onWarn, writeArchiveImpl = writeF
       filePath,
       fileName,
       mimeType: "application/zip",
-      cleanup: () => rm6(tmpRoot, { recursive: true, force: true })
+      cleanup: () => rm5(tmpRoot, { recursive: true, force: true })
     };
   } catch (e) {
-    await rm6(tmpRoot, { recursive: true, force: true }).catch(() => {});
+    await rm5(tmpRoot, { recursive: true, force: true }).catch(() => {});
     throw e;
   }
 }
@@ -12726,7 +11941,7 @@ var gdriveProvider = {
 };
 
 // src/lib/publish/butler.ts
-import { chmod, mkdir as mkdir12, stat as stat8, writeFile as writeFile11 } from "node:fs/promises";
+import { chmod, mkdir as mkdir11, stat as stat8, writeFile as writeFile10 } from "node:fs/promises";
 import path21 from "node:path";
 import { unzipSync as unzipSync2 } from "fflate";
 var BUTLER_DOWNLOAD_TIMEOUT_MS = 300000;
@@ -12787,13 +12002,13 @@ async function ensureButler(deps) {
     return new Uint8Array(await response.arrayBuffer());
   });
   const files = unzipSync2(archive);
-  await mkdir12(cacheDir, { recursive: true });
+  await mkdir11(cacheDir, { recursive: true });
   let foundBinary = false;
   for (const [name, data] of Object.entries(files)) {
     if (name.endsWith("/"))
       continue;
     const target = path21.join(cacheDir, path21.basename(name));
-    await writeFile11(target, data);
+    await writeFile10(target, data);
     if (path21.basename(name) === butlerBinaryName()) {
       await chmod(target, 493).catch(() => {});
       foundBinary = true;
@@ -12990,7 +12205,7 @@ var kdpProvider = {
 };
 
 // src/lib/publish/providers/local-folder.ts
-import { cp as cp5, mkdir as mkdir13, stat as stat9 } from "node:fs/promises";
+import { cp as cp4, mkdir as mkdir12, stat as stat9 } from "node:fs/promises";
 import path22 from "node:path";
 var LOCAL_PUBLISH_DEFAULT_DIR = "dist";
 var info7 = {
@@ -13028,10 +12243,10 @@ var localFolderProvider = {
   },
   async upload(req) {
     const dir = localPublishDir(req);
-    await mkdir13(dir, { recursive: true });
+    await mkdir12(dir, { recursive: true });
     const dest = req.artifact.format === "html" ? dir : path22.join(dir, path22.basename(req.artifact.path));
     if (path22.resolve(dest) !== path22.resolve(req.artifact.path)) {
-      await cp5(req.artifact.path, dest, { recursive: true });
+      await cp4(req.artifact.path, dest, { recursive: true });
     }
     return { kind: "published", detail: `Saved to ${dest}` };
   }
@@ -13595,7 +12810,7 @@ import git7 from "isomorphic-git";
 // src/lib/remote-auth/scorched-earth.ts
 import git8 from "isomorphic-git";
 // src/lib/publish/selections.ts
-import { chmod as chmod2, mkdir as mkdir14, readFile as readFile30, writeFile as writeFile12 } from "node:fs/promises";
+import { chmod as chmod2, mkdir as mkdir13, readFile as readFile29, writeFile as writeFile11 } from "node:fs/promises";
 import path24 from "node:path";
 class PublishSelectionsStore {
   filePath;
@@ -13605,7 +12820,7 @@ class PublishSelectionsStore {
   }
   async read() {
     try {
-      const raw = await readFile30(this.filePath, "utf8");
+      const raw = await readFile29(this.filePath, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") {
         return {
@@ -13618,8 +12833,8 @@ class PublishSelectionsStore {
     return { version: 1, global: {}, projects: {} };
   }
   async write(data) {
-    await mkdir14(path24.dirname(this.filePath), { recursive: true });
-    await writeFile12(this.filePath, JSON.stringify(data, null, 2), {
+    await mkdir13(path24.dirname(this.filePath), { recursive: true });
+    await writeFile11(this.filePath, JSON.stringify(data, null, 2), {
       encoding: "utf8",
       mode: 384
     });
@@ -13684,78 +12899,4 @@ function normalizeProjectKey(projectDir) {
 }
 // src/lib/publish/manifest-publish.ts
 import { isMap as isMap4 } from "yaml";
-// src/lib/lint-runner.ts
-import { resolve as resolve8 } from "node:path";
-import { readFile as readFile31 } from "node:fs/promises";
-async function runLint(opts = {}) {
-  const { glob } = await import("glob");
-  const { manifest, manifestDir } = await loadManifestWithPath(opts.manifest, {
-    explicit: opts.manifest !== undefined
-  });
-  const resolved = resolveConfig({}, manifest);
-  let files;
-  if (opts.files) {
-    files = await glob([opts.files], { nodir: true, ignore: ["**/*.min.css"] });
-  } else {
-    const relStyles = await resolveActiveStyles(manifestDir, resolved.styles);
-    const projectFiles = relStyles.map((rel) => resolve8(manifestDir, rel));
-    let pluginStylePaths = opts.pluginStylePaths;
-    if (pluginStylePaths === undefined) {
-      ({ pluginStylePaths } = await loadPluginsWithCss(resolved.extensions, manifestDir, (ref, err) => log.warn(`Skipping plugin "${ref}" for lint — ${err.message}`)));
-    }
-    files = [...projectFiles, ...pluginStylePaths].filter((f) => !f.endsWith(".min.css"));
-  }
-  if (files.length === 0) {
-    log.warn("No CSS files found to lint");
-    return { ok: true, riskyCount: 0, containmentCount: 0, filesLinted: 0 };
-  }
-  log.info(`Linting ${files.length} CSS file(s)`);
-  let errorCount = 0;
-  let riskyCount = 0;
-  let containmentCount = 0;
-  let linted = 0;
-  for (const file of files) {
-    let css;
-    try {
-      css = await readFile31(file, "utf8");
-    } catch (err) {
-      log.error(`  ${file}`);
-      log.error(`    cannot read stylesheet: ${err instanceof Error ? err.message : String(err)}`);
-      errorCount++;
-      continue;
-    }
-    linted++;
-    const warnings = checkCss(css, file);
-    const errors = warnings.filter((w) => w.severity === "error");
-    const risky = warnings.filter((w) => w.rule === ruleRiskyProps);
-    const containment = warnings.filter((w) => w.rule === rulePageContainment);
-    riskyCount += risky.length;
-    containmentCount += containment.length;
-    if (errors.length > 0) {
-      log.error(`  ${file}`);
-      for (const w of errors) {
-        log.error(`    ${w.line}:${w.column}  ${w.message}  (${w.rule})`);
-      }
-      errorCount += errors.length;
-    }
-    const nonErrorWarnings = [...risky, ...containment].sort((a, b) => a.line - b.line);
-    if (nonErrorWarnings.length > 0) {
-      log.warn(`  ${file}`);
-      for (const w of nonErrorWarnings) {
-        log.warn(`    ${w.line}:${w.column}  ${w.message}  (${w.rule})`);
-      }
-    }
-  }
-  if (errorCount > 0) {
-    log.error("CSS lint errors found");
-    return { ok: false, riskyCount, containmentCount, filesLinted: linted };
-  }
-  const totalWarnings = riskyCount + containmentCount;
-  if (totalWarnings > 0) {
-    log.warn(`${totalWarnings} print-safety warning(s): ${riskyCount} risky effect(s), ${containmentCount} page-containment`);
-  } else {
-    log.success("CSS lint passed");
-  }
-  return { ok: true, riskyCount, containmentCount, filesLinted: linted };
-}
-export { isPathSpecifier, parseExtensionSpecifier, PRESET_IDS, PRESETS, TARGETS, TARGET_IDS, publishTargetFor, MANIFEST_FILENAMES, loadManifestWithPath, reportMissingTools, executeValidation, executeAndReport, splitOutPath, runBuild, openPath, startPreviewServer, scaffoldProject, EXTENSION_KINDS, scaffoldExtension, BUILT_IN_TEMPLATE_IDS, BUILT_IN_STYLE_SET_IDS, listProjectExtensions, setExtensionEnabled, removeExtension, addExtension, addBuiltInStyleSet, importExtensionFromFile, importExtensionFromUrl, searchNpmExtensions, publishCredentialKey, publishConnectionStatus, listPublishAccounts, connectGoogleDrive, listPublishProviders, publishProviderFor, resolvePublishFormat, runPublish, connectPublishProvider, disconnectPublishCredential, runLint };
+export { isPathSpecifier, parseExtensionSpecifier, PRESET_IDS, PRESETS, TARGETS, TARGET_IDS, publishTargetFor, loadManifestWithPath, reportMissingTools, executeValidation, executeAndReport, splitOutPath, runBuild, openPath, startPreviewServer, scaffoldProject, EXTENSION_KINDS, scaffoldExtension, BUILT_IN_TEMPLATE_IDS, BUILT_IN_STYLE_SET_IDS, listProjectExtensions, setExtensionEnabled, removeExtension, addExtension, addBuiltInStyleSet, importExtensionFromFile, importExtensionFromUrl, searchNpmExtensions, publishCredentialKey, publishConnectionStatus, listPublishAccounts, connectGoogleDrive, listPublishProviders, publishProviderFor, resolvePublishFormat, runPublish, connectPublishProvider, disconnectPublishCredential };