srcpack 0.2.0 → 1.0.0

package/src/cli.ts

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 // SPDX-License-Identifier: MIT
 
-import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { mkdir, readdir, readFile, rm } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import ora from "ora";
+import { parseCliArgs, UsageError } from "./args.ts";
 import { bundleOne, type BundleResult } from "./bundle.ts";
 import {
   ConfigError,
   loadConfig,
   parseConfig,
-  type BundleConfig,
   type UploadConfig,
 } from "./config.ts";
-import { GitError } from "./git.ts";
+import { isInside, physicalPath, writeFileAtomic } from "./fs.ts";
 import {
   ensureAuthenticated,
   login,
@@ -20,13 +20,17 @@ import {
   uploadFile,
   type UploadResult,
 } from "./gdrive.ts";
+import { GitError } from "./git.ts";
 import { runInit } from "./init.ts";
-
-interface BundleOutput {
-  name: string;
-  outfile: string;
-  result: BundleResult;
-}
+import { LinearError } from "./linear.ts";
+import { planOutputs, selectBundles, type ResolvedBundle } from "./plan.ts";
+import {
+  createCapturer,
+  imageFileName,
+  isImageOf,
+  ScreenshotError,
+  type CapturedPage,
+} from "./screenshot.ts";
 
 function sumLines(result: BundleResult): number {
   return result.index.reduce((sum, entry) => sum + entry.lines, 0);
@@ -40,22 +44,48 @@ function plural(n: number, singular: string, pluralForm?: string): string {
   return n === 1 ? singular : (pluralForm ?? singular + "s");
 }
 
-function isInside(path: string, dir: string): boolean {
-  const rel = relative(dir, path);
-  // Compare against ".." as a whole segment — "..cache/x" is a child, not an escape
-  return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+/**
+ * "3 bundles, 42 files, 3,120 lines, 15 images". Files and lines appear only
+ * when some bundle wrote text; images aren't counted in a dry run, which never
+ * renders them.
+ */
+function formatCounts(outputs: ResolvedBundle[]): string {
+  const texts = outputs.flatMap((o) => (o.text ? [o.text] : []));
+  const files = texts.reduce((sum, t) => sum + t.index.length, 0);
+  const lines = texts.reduce((sum, t) => sum + sumLines(t), 0);
+  const images = outputs.reduce(
+    (sum, o) => sum + (o.images?.images.length ?? 0),
+    0,
+  );
+  const counts = [`${outputs.length} ${plural(outputs.length, "bundle")}`];
+  if (texts.length) {
+    counts.push(
+      `${formatNumber(files)} ${plural(files, "file")}`,
+      `${formatNumber(lines)} ${plural(lines, "line")}`,
+    );
+  }
+  if (images) counts.push(`${formatNumber(images)} ${plural(images, "image")}`);
+  return counts.join(", ");
 }
 
+/** The directory srcpack owns by convention, and the only one it clears unasked. */
+const DEFAULT_OUT_DIR = ".srcpack";
+
 /**
  * Empty a directory while preserving specified entries (e.g., `.git`).
- * Uses `force: true` to handle read-only or in-use files.
  */
 async function emptyDirectory(dir: string, skip: string[] = []): Promise<void> {
   let entries: string[];
   try {
     entries = await readdir(dir);
-  } catch {
-    return; // Directory doesn't exist, nothing to empty
+  } catch (error) {
+    // Only a missing directory is "nothing to empty". Anything else — a
+    // permission error, a file where a directory belongs — would otherwise be
+    // reported as a clean run that then writes into a directory it never read.
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
+    throw new ConfigError(
+      `Cannot empty outDir "${dir}": ${(error as Error).message}`,
+    );
   }
   const skipSet = new Set(skip);
   await Promise.all(
@@ -66,50 +96,30 @@ async function emptyDirectory(dir: string, skip: string[] = []): Promise<void> {
 }
 
 /**
- * One-off bundle from a `git:` source instead of a configured one. Needs no
- * config file — reviewing what you just wrote is throwaway, not worth committing.
+ * Write a bundle's images, then remove the stale ones: a page that shrank from
+ * six images to four would otherwise leave `-04` and `-05` to be attached with
+ * the new set. Stale files match exactly, never folded — folding could only
+ * widen what gets deleted (ADR 004). Returns the paths written, in order.
  */
-interface AdHocBundle {
-  name: string;
-  patterns: string[];
-}
-
-const AD_HOC_FLAGS = ["--staged", "--dirty", "--since"] as const;
-
-function parseAdHocBundle(args: string[]): AdHocBundle | null {
-  const flags = AD_HOC_FLAGS.filter((flag) => args.includes(flag));
-
-  if (flags.length > 1) {
-    console.error(`Cannot combine ${flags.join(" and ")}.`);
-    process.exit(1);
-  }
-
-  switch (flags[0]) {
-    case "--staged":
-      return { name: "staged", patterns: ["git:staged"] };
-    case "--dirty":
-      return { name: "dirty", patterns: ["git:dirty"] };
-    case "--since": {
-      const rev = args[args.indexOf("--since") + 1];
-      if (!rev || rev.startsWith("-")) {
-        console.error("Missing revision: --since <rev> (e.g. --since main)");
-        process.exit(1);
-      }
-      // A range pins both endpoints, so it would silently drop the uncommitted
-      // work --since promises. Ranges belong in a config `git:` source.
-      if (rev.includes("..")) {
-        console.error(
-          `--since takes a revision, not a range: "${rev}". Use a git: source in your config for ranges.`,
-        );
-        process.exit(1);
-      }
-      // `git diff` can't see untracked files, but a new file written on this
-      // branch is part of "what changed since <rev>"
-      return { name: "since", patterns: [`git:${rev}`, "git:untracked"] };
-    }
-    default:
-      return null;
+async function writeImages(
+  name: string,
+  dir: string,
+  captured: CapturedPage,
+): Promise<string[]> {
+  await mkdir(dir, { recursive: true });
+  const highest = Math.max(...captured.images.map((image) => image.index));
+  const written: string[] = [];
+  for (const { index, data } of captured.images) {
+    const path = join(dir, imageFileName(name, index, highest));
+    await writeFileAtomic(path, data);
+    written.push(path);
   }
+  const current = new Set(written.map((path) => basename(path)));
+  const stale = (await readdir(dir)).filter(
+    (file) => isImageOf(name, file) && !current.has(file),
+  );
+  await Promise.all(stale.map((file) => rm(join(dir, file), { force: true })));
+  return written;
 }
 
 /** Resolves to the package root from both `src/cli.ts` and `dist/cli.js`. */
@@ -134,59 +144,52 @@ async function main() {
 srcpack - Bundle and upload tool
 
 Usage:
-  npx srcpack              Bundle all, upload if configured
-  npx srcpack web api      Bundle specific bundles only
-  npx srcpack --staged     Bundle staged changes (no config needed)
-  npx srcpack --dry-run    Preview bundles without writing files
-  npx srcpack --no-upload  Bundle only, skip upload
-  npx srcpack init         Interactive config setup
-  npx srcpack login        Authenticate with Google Drive
+  npx srcpack                  Bundle all except on-demand, upload if configured
+  npx srcpack web api          Bundle specific bundles only
+  npx srcpack --staged         Bundle staged changes (no config needed)
+  npx srcpack --screenshot localhost:5173
+                               Capture a page as PNGs (no config needed)
+  npx srcpack --dry-run        Preview bundles without writing files
+  npx srcpack --no-upload      Bundle only, skip upload
+  npx srcpack init             Interactive config setup
+  npx srcpack login            Authenticate with Google Drive
 
 Options:
-  --staged         Bundle staged changes only
-  --dirty          Bundle staged, unstaged, and untracked changes
-  --since <rev>    Bundle changes since <rev> (e.g. --since main)
-  --dry-run        Preview bundles without writing files
-  --emptyOutDir    Empty output directory before bundling
-  --no-emptyOutDir Keep existing files in output directory
-  --no-upload      Skip uploading to cloud storage
-  -h, --help       Show this help message
-  -v, --version    Show version
+  --staged             Bundle staged changes only
+  --dirty              Bundle staged, unstaged, and untracked changes
+  --since <rev>        Bundle changes since <rev> (e.g. --since main)
+  --screenshot <url>   Capture a page as numbered PNGs
+  --viewport <name>    desktop (default) or mobile, with --screenshot
+  --dry-run            Preview bundles without writing files
+  --emptyOutDir        Empty output directory before writing
+  --no-emptyOutDir     Skip clearing the output directory
+  --no-upload          Skip uploading to cloud storage
+  -h, --help           Show this help message
+  -v, --version        Show version
 `);
     return;
   }
 
   // Only in first position: elsewhere the word is a bundle name or a revision,
   // and `--since init` must diff against the `init` branch, not run the wizard.
-  if (args[0] === "init") {
-    await runInit();
-    return;
-  }
-
-  if (args[0] === "login") {
-    await runLogin();
+  if (args[0] === "init" || args[0] === "login") {
+    // Neither takes arguments, so anything after is a misunderstanding worth
+    // saying out loud rather than a flag that silently does nothing.
+    if (args.length > 1) {
+      console.error(`srcpack ${args[0]} takes no arguments.`);
+      process.exit(1);
+    }
+    await (args[0] === "init" ? runInit() : runLogin());
     return;
   }
 
-  const dryRun = args.includes("--dry-run");
-  const noUpload = args.includes("--no-upload");
-  // CLI flags: --emptyOutDir forces true, --no-emptyOutDir forces false
-  const emptyOutDirFlag = args.includes("--emptyOutDir")
-    ? true
-    : args.includes("--no-emptyOutDir")
-      ? false
-      : undefined;
-  const adHoc = parseAdHocBundle(args);
-  const sinceIndex = args.indexOf("--since");
-  const sinceValueIndex = sinceIndex === -1 ? -1 : sinceIndex + 1;
-  const requestedBundles = args.filter(
-    (arg, i) => !arg.startsWith("-") && i !== sinceValueIndex,
-  );
-
-  if (adHoc && requestedBundles.length) {
-    console.error(`Cannot combine --${adHoc.name} with named bundles.`);
-    process.exit(1);
-  }
+  const {
+    bundles: requestedBundles,
+    adHoc,
+    dryRun,
+    emptyOutDir: emptyOutDirFlag,
+    upload,
+  } = parseCliArgs(args);
 
   let config = await loadConfig();
 
@@ -201,52 +204,61 @@ Options:
     config = parseConfig({ bundles: {} });
   }
 
-  const bundles = adHoc ? { [adHoc.name]: adHoc.patterns } : config.bundles;
+  const bundles = adHoc ? { [adHoc.name]: adHoc.source } : config.bundles;
 
-  // Determine which bundles to process
-  const bundleNames = requestedBundles.length
-    ? requestedBundles
-    : Object.keys(bundles);
-
-  // Validate requested bundle names exist
-  for (const name of bundleNames) {
-    if (!(name in bundles)) {
-      console.error(`Unknown bundle: ${name}`);
-      process.exit(1);
-    }
-  }
+  const { names: bundleNames, skipped } = selectBundles(
+    bundles,
+    requestedBundles,
+  );
+  const onDemandNote = skipped.length
+    ? `On demand: ${skipped.join(", ")}`
+    : undefined;
 
-  if (bundleNames.length === 0) {
+  // Every bundle on demand is still a full run: it goes on to empty outDir
+  if (bundleNames.length === 0 && !onDemandNote) {
     console.log("No bundles configured.");
     return;
   }
 
   const root = config.root;
 
-  // Resolve emptyOutDir: CLI flag > config > auto (true if inside root).
-  // Ad-hoc runs never empty by default — they shouldn't delete configured bundles.
+  // Resolve emptyOutDir: CLI flag > config > auto.
+  //
+  // Auto means only the conventional `.srcpack`: recursive deletion needs a
+  // directory srcpack demonstrably owns, and `outDir: "src"` reads as an
+  // ordinary setting while turning a bundling run into a source-tree wipe.
+  // Every other directory belongs to the user until they say otherwise.
+  //
+  // The comparison is physical, not lexical: `.srcpack -> ../shared` looks
+  // inside the project and deletes somewhere else. Ad-hoc runs never empty by
+  // default either — they shouldn't delete configured bundles.
+  // Lexical is what gets written to and excluded from bundles; physical is what
+  // decides ownership. Conflating them is what let a symlink redirect a delete.
+  const rootPath = await physicalPath(root);
   const outDirPath = resolve(root, config.outDir);
-  const outDirInsideRoot = isInside(outDirPath, root);
-  const emptyOutDir =
-    emptyOutDirFlag ??
-    (adHoc ? false : (config.emptyOutDir ?? outDirInsideRoot));
+  const outDirPhysical = await physicalPath(outDirPath);
+  const defaultOutDir = join(rootPath, DEFAULT_OUT_DIR);
 
-  // Warn if outDir is outside root and emptyOutDir is not explicitly set
+  // The conventional name is a claim about a place. A `.srcpack` that resolves
+  // somewhere else keeps the name while writing into a directory srcpack was
+  // never given — and would overwrite whatever shares a filename there.
   if (
-    !adHoc &&
-    !outDirInsideRoot &&
-    emptyOutDirFlag === undefined &&
-    config.emptyOutDir === undefined
+    resolve(root, DEFAULT_OUT_DIR) === outDirPath &&
+    outDirPhysical !== defaultOutDir
   ) {
-    console.warn(
-      `Warning: outDir "${config.outDir}" is outside project root. ` +
-        "Use --emptyOutDir to suppress this warning and empty the directory.",
+    throw new ConfigError(
+      `Refusing to use "${DEFAULT_OUT_DIR}": it resolves to "${outDirPhysical}", not "${defaultOutDir}". ` +
+        "Set outDir to that path explicitly if that is where bundles belong.",
     );
   }
 
+  const ownsOutDir = outDirPhysical === defaultOutDir;
+  const emptyOutDir =
+    emptyOutDirFlag ?? (adHoc ? false : (config.emptyOutDir ?? ownsOutDir));
+
   // `outDir: "."` resolves to the project root, where emptying deletes the
   // whole project — sources, config and all. Refuse rather than warn.
-  const outDirHoldsRoot = isInside(root, outDirPath);
+  const outDirHoldsRoot = isInside(rootPath, outDirPhysical);
   if (emptyOutDir && outDirHoldsRoot) {
     throw new ConfigError(
       `Refusing to empty outDir "${config.outDir}": it contains the project root. ` +
@@ -254,116 +266,190 @@ Options:
     );
   }
 
-  // Empty outDir before bundling (unless dry-run). Only for a full run: a named
-  // subset can't tell what is stale, so `srcpack web` must not delete api.txt.
-  if (emptyOutDir && !dryRun && requestedBundles.length === 0) {
-    await emptyDirectory(outDirPath, [".git"]);
-  }
-
-  // srcpack never bundles what srcpack writes. Every configured outfile is
-  // named explicitly; outDir covers stale bundles from renamed config entries
-  // too, but not when it holds the root — that would exclude the whole project.
-  const ownOutputs = Object.entries(config.bundles).map(
-    ([name, bundleConfig]) =>
-      resolve(root, getOutfile(bundleConfig, name, config.outDir)),
+  // srcpack never bundles what srcpack writes. Every output is named
+  // explicitly; outDir covers stale bundles from renamed config entries too,
+  // but not when it holds the root — that would exclude the whole project.
+  const { bundles: plans, ownOutputs } = await planOutputs(
+    root,
+    config.outDir,
+    config.bundles,
+    bundleNames.map((name) => [name, bundles[name]!]),
   );
-  if (!outDirHoldsRoot) ownOutputs.push(outDirPath);
+  if (!outDirHoldsRoot) ownOutputs.push(outDirPath, outDirPhysical);
 
-  const outputs: BundleOutput[] = [];
+  const outputs: ResolvedBundle[] = [];
+  // Printed once the spinner stops, which would otherwise draw over them
+  const warnings: string[] = [];
+  // Images stay in memory until every bundle has resolved, so a failure in
+  // any capture leaves the previous run's files in place (ADR 003 run order).
+  // A dry run previews without a browser: counting images needs a render.
+  const capturer = createCapturer(root);
 
   // Process all bundles with progress
   const bundleSpinner = ora({
-    text: `Bundling ${bundleNames[0]}...`,
+    text: "Bundling...",
     color: "cyan",
   }).start();
 
   try {
-    for (let i = 0; i < bundleNames.length; i++) {
-      const name = bundleNames[i]!;
-      bundleSpinner.text = `Bundling ${name}... (${i + 1}/${bundleNames.length})`;
-      const bundleConfig = bundles[name]!;
-      const result = await bundleOne(bundleConfig, root, ownOutputs);
-      const outfile = getOutfile(bundleConfig, name, config.outDir);
-      outputs.push({ name, outfile, result });
+    for (let i = 0; i < plans.length; i++) {
+      const plan = plans[i]!;
+      const progress = `${plan.name}... (${i + 1}/${plans.length})`;
+      const output: ResolvedBundle = { plan };
+      try {
+        if (plan.text) {
+          bundleSpinner.text = `Bundling ${progress}`;
+          output.text = await bundleOne(plan.source, root, ownOutputs);
+        }
+        if (plan.images && !dryRun) {
+          bundleSpinner.text = `Capturing ${progress}`;
+          output.images = await capturer.capture(
+            plan.images.target,
+            (message) => warnings.push(`Bundle "${plan.name}": ${message}`),
+          );
+        }
+      } catch (error) {
+        // A dev server that isn't running fails every full run; say how to
+        // keep the bundle without that
+        if (
+          error instanceof ScreenshotError &&
+          error.unreachable &&
+          requestedBundles.length === 0 &&
+          !adHoc
+        ) {
+          error.message += " Set onDemand: true to capture it only when named.";
+        }
+        // A config can declare many bundles; the underlying message says what
+        // broke but not which bundle asked for it.
+        if (
+          error instanceof ConfigError ||
+          error instanceof GitError ||
+          error instanceof LinearError ||
+          error instanceof ScreenshotError
+        ) {
+          error.message = `Bundle "${plan.name}": ${error.message}`;
+        }
+        throw error;
+      }
+      outputs.push(output);
     }
   } finally {
     bundleSpinner.stop();
+    await capturer.close();
+    // Also when a later bundle fails: a page-growth warning may explain it
+    for (const warning of warnings) console.warn(warning);
+  }
+
+  // Clear only after all sources resolve, preserving prior output on failure.
+  // Named runs keep other bundles; ad-hoc runs reach this only with an explicit
+  // --emptyOutDir. `ownOutputs` excludes prior output during resolution.
+  if (emptyOutDir && !dryRun && requestedBundles.length === 0) {
+    await emptyDirectory(outDirPath, [".git"]);
   }
 
+  if (outputs.length === 0) {
+    console.log(onDemandNote);
+    return;
+  }
+
+  const textResults = outputs.flatMap((o) => (o.text ? [o.text] : []));
+
   // Calculate column widths for aligned output
-  const maxNameLen = Math.max(...outputs.map((o) => o.name.length));
+  const maxNameLen = Math.max(...outputs.map((o) => o.plan.name.length));
   const maxFilesLen = Math.max(
-    ...outputs.map((o) => formatNumber(o.result.index.length).length),
+    0,
+    ...textResults.map((text) => formatNumber(text.index.length).length),
   );
   const maxLinesLen = Math.max(
-    ...outputs.map((o) => formatNumber(sumLines(o.result)).length),
+    0,
+    ...textResults.map((text) => formatNumber(sumLines(text)).length),
   );
 
-  // Print each bundle
+  // Print each bundle. A mixed bundle prints its text line, then its images.
   console.log();
-  for (const { name, outfile, result } of outputs) {
-    const fileCount = result.index.length;
-    const lineCount = sumLines(result);
-    const outPath = resolve(root, outfile);
-
-    const nameCol = name.padEnd(maxNameLen);
-    const filesCol = formatNumber(fileCount).padStart(maxFilesLen);
-    const linesCol = formatNumber(lineCount).padStart(maxLinesLen);
-
-    if (dryRun) {
-      console.log(
-        `  ${nameCol}  ${filesCol} ${plural(fileCount, "file")}  ${linesCol} ${plural(lineCount, "line")}`,
-      );
-      for (const entry of result.index) {
-        console.log(`    ${entry.path}`);
+  for (const { plan, text: result, images } of outputs) {
+    const nameCol = plan.name.padEnd(maxNameLen);
+
+    if (plan.text && result) {
+      const fileCount = result.index.length;
+      const lineCount = sumLines(result);
+      const outPath = plan.text.outfile;
+      const filesCol = formatNumber(fileCount).padStart(maxFilesLen);
+      const linesCol = formatNumber(lineCount).padStart(maxLinesLen);
+
+      if (dryRun) {
+        console.log(
+          `  ${nameCol}  ${filesCol} ${plural(fileCount, "file")}  ${linesCol} ${plural(lineCount, "line")}`,
+        );
+        for (const entry of result.index) {
+          console.log(`    ${entry.path}`);
+        }
+      } else if (fileCount === 0) {
+        // Remove stale text only inside outDir; custom outfiles outside it survive.
+        if (isInside(outPath, outDirPath)) {
+          await rm(outPath, { force: true });
+        }
+        console.log(
+          `  ${nameCol}  ${filesCol} ${plural(fileCount, "file")}  ${linesCol} ${plural(lineCount, "line")}  → skipped`,
+        );
+      } else {
+        await mkdir(dirname(outPath), { recursive: true });
+        await writeFileAtomic(outPath, result.content);
+        const displayPath = relative(process.cwd(), outPath);
+        console.log(
+          `  ${nameCol}  ${filesCol} ${plural(fileCount, "file")}  ${linesCol} ${plural(lineCount, "line")}  → ${displayPath}`,
+        );
       }
-    } else if (fileCount === 0) {
-      // Drop a previous run's file so the bundle never goes stale, but only
-      // inside outDir — a custom outfile points at a location srcpack doesn't own
-      if (isInside(outPath, outDirPath)) {
-        await rm(outPath, { force: true });
+    }
+
+    if (plan.images) {
+      const { target, dir } = plan.images;
+      if (!images) {
+        const pattern = join(dir, `${plan.name}-NN.png`);
+        console.log(
+          `  ${nameCol}  screenshot  ${target.url}  ${target.viewport}  → ${relative(process.cwd(), pattern)}`,
+        );
+      } else {
+        const written = await writeImages(plan.name, dir, images);
+        const first = relative(process.cwd(), written[0]!);
+        const range =
+          written.length === 1
+            ? first
+            : `${first} … ${basename(written.at(-1)!)}`;
+        console.log(
+          `  ${nameCol}  ${formatNumber(written.length)} ${plural(written.length, "image")}  page ${images.width}×${formatNumber(images.height)}  → ${range}`,
+        );
       }
-      console.log(
-        `  ${nameCol}  ${filesCol} ${plural(fileCount, "file")}  ${linesCol} ${plural(lineCount, "line")}  → skipped`,
-      );
-    } else {
-      await mkdir(dirname(outPath), { recursive: true });
-      await writeFile(outPath, result.content);
-      const displayPath = relative(process.cwd(), outPath);
-      console.log(
-        `  ${nameCol}  ${filesCol} ${plural(fileCount, "file")}  ${linesCol} ${plural(lineCount, "line")}  → ${displayPath}`,
-      );
     }
   }
 
-  // Print summary
-  const totalFiles = outputs.reduce((sum, o) => sum + o.result.index.length, 0);
-  const totalLines = outputs.reduce((sum, o) => sum + sumLines(o.result), 0);
-  const bundleWord = plural(outputs.length, "bundle");
-  const fileWord = plural(totalFiles, "file");
-  const lineWord = plural(totalLines, "line");
-
   console.log();
   if (dryRun) {
-    console.log(
-      `Dry run: ${outputs.length} ${bundleWord}, ${formatNumber(totalFiles)} ${fileWord}, ${formatNumber(totalLines)} ${lineWord}`,
-    );
+    console.log(`Dry run: ${formatCounts(outputs)}`);
+    if (onDemandNote) console.log(onDemandNote);
   } else {
-    console.log(
-      `Bundled: ${outputs.length} ${bundleWord}, ${formatNumber(totalFiles)} ${fileWord}, ${formatNumber(totalLines)} ${lineWord}`,
-    );
+    console.log(`Bundled: ${formatCounts(outputs)}`);
+    if (onDemandNote) console.log(onDemandNote);
 
     // Ad-hoc bundles stay local: uploading work-in-progress to Drive is not
     // what --staged asks for, and `upload.exclude` can't name a bundle the
     // config doesn't declare. Configure a named bundle to publish changes.
-    if (config.upload && !noUpload && !adHoc) {
+    if (config.upload && upload && !adHoc) {
       const uploads = Array.isArray(config.upload)
         ? config.upload
         : [config.upload];
 
+      // Drive finds files by name and updates them in place, so a page that
+      // shrank would leave its old slices there with nothing to remove them.
+      // A mixed bundle's text file still uploads.
+      const local = outputs.filter((o) => o.images).map((o) => o.plan.name);
+      if (local.length && uploads.some(isGdriveConfigured)) {
+        console.log(`Images stay local: ${local.join(", ")}`);
+      }
+
       for (const uploadConfig of uploads) {
         if (isGdriveConfigured(uploadConfig)) {
-          await handleGdriveUpload(uploadConfig, outputs, root);
+          await handleGdriveUpload(uploadConfig, outputs);
         }
       }
     }
@@ -378,16 +464,6 @@ function isGdriveConfigured(config: UploadConfig): boolean {
   );
 }
 
-function getGdriveConfig(config: {
-  upload?: UploadConfig | UploadConfig[];
-}): UploadConfig | null {
-  if (!config.upload) return null;
-  const uploads = Array.isArray(config.upload)
-    ? config.upload
-    : [config.upload];
-  return uploads.find(isGdriveConfigured) ?? null;
-}
-
 async function runLogin(): Promise<void> {
   let config;
   try {
@@ -453,13 +529,14 @@ function printUploadConfigHelp(): void {
 
 async function handleGdriveUpload(
   uploadConfig: UploadConfig,
-  outputs: BundleOutput[],
-  root: string,
+  outputs: ResolvedBundle[],
 ): Promise<void> {
   // Filter out excluded bundles and empty ones (never written to disk)
   const excludeSet = new Set(uploadConfig.exclude ?? []);
-  const toUpload = outputs.filter(
-    (o) => !excludeSet.has(o.name) && o.result.index.length > 0,
+  const toUpload = outputs.flatMap(({ plan, text }) =>
+    plan.text && text && text.index.length > 0 && !excludeSet.has(plan.name)
+      ? [{ name: plan.name, outfile: plan.text.outfile }]
+      : [],
   );
 
   if (toUpload.length === 0) {
@@ -479,10 +556,9 @@ async function handleGdriveUpload(
 
     try {
       for (let i = 0; i < toUpload.length; i++) {
-        const output = toUpload[i]!;
-        const filePath = resolve(root, output.outfile);
-        uploadSpinner.text = `Uploading ${output.name}... (${i + 1}/${toUpload.length})`;
-        const result = await uploadFile(filePath, uploadConfig);
+        const { name, outfile } = toUpload[i]!;
+        uploadSpinner.text = `Uploading ${name}... (${i + 1}/${toUpload.length})`;
+        const result = await uploadFile(outfile, uploadConfig);
         results.push(result);
       }
     } finally {
@@ -515,25 +591,17 @@ async function handleGdriveUpload(
   }
 }
 
-function getOutfile(
-  bundleConfig: BundleConfig,
-  name: string,
-  outDir: string,
-): string {
-  if (
-    typeof bundleConfig === "object" &&
-    !Array.isArray(bundleConfig) &&
-    bundleConfig.outfile
-  ) {
-    return bundleConfig.outfile;
-  }
-  return join(outDir, `${name}.txt`);
-}
-
 main().catch((err) => {
-  // Config and git failures are user-facing; a stack trace only adds noise
+  // Usage, config, git, Linear and screenshot failures are user-facing; a stack
+  // trace adds noise
   console.error(
-    err instanceof ConfigError || err instanceof GitError ? err.message : err,
+    err instanceof UsageError ||
+      err instanceof ConfigError ||
+      err instanceof GitError ||
+      err instanceof LinearError ||
+      err instanceof ScreenshotError
+      ? err.message
+      : err,
   );
   process.exit(1);
 });