@hajimism/dek 0.3.2 → 0.4.0

package/src/cli/init.ts

@@ -3,10 +3,12 @@ import { basename, join, resolve } from "node:path";
 import { parseCss, publishedTokens } from "../core/css.ts";
 import { deckPaths } from "../core/deck-paths.ts";
 import { DekError } from "../core/error.ts";
+import { shellQuote } from "../core/escape.ts";
 import { REQUIRED_TOKENS } from "../core/lint/tokens.ts";
 import { walkUp } from "../core/optional.ts";
 import { DECK_NAME_HINT, isDeckName } from "../core/path.ts";
-import { readTextIfExists } from "../core/resolve.ts";
+import { refuseInsideRef } from "../core/ref.ts";
+import { readSourceIfExists } from "../core/safe-fs.ts";
 import {
   defaultTsconfig,
   dekFilePaths,
@@ -25,7 +27,6 @@ import {
   nextSteps,
   type PlannedPath,
   playwrightStep,
-  shellQuote,
 } from "./files.ts";
 
 export type InitResult = {
@@ -84,7 +85,7 @@ export function initCommand(options: { cwd: string; dir?: string; deck?: string
 /** The tokens every deck needs that the project's theme.css does not publish on `.slide`. */
 function missingThemeTokens(root: string): string[] {
   const published = new Set(
-    publishedTokens(parseCss(readTextIfExists(join(root, "theme.css")) ?? "")).map(
+    publishedTokens(parseCss(readSourceIfExists(join(root, "theme.css"), root) ?? "")).map(
       (token) => token.name,
     ),
   );
@@ -100,8 +101,10 @@ function syncDeckFiles(deckDir: string, created: string[]): FileChanges {
 /** Everything init writes but `.dek/` and AGENTS.md, in the order a reader meets it. */
 function projectPlan(root: string, deck: string | undefined): PlannedPath[] {
   const themePath = join(root, "theme.css");
-  // A first deck is drawn in the theme that will be there: the one kept, or dek's.
-  const theme = readTextIfExists(themePath) ?? defaultTheme();
+  // A first deck is drawn in the theme that will be there: the one kept, or dek's. A folder that
+  // is not there yet holds no theme.
+  const theme =
+    (existsSync(root) ? readSourceIfExists(themePath, root) : undefined) ?? defaultTheme();
   return [
     { path: join(root, "dek.toml"), contents: defaultToml() },
     { path: themePath, contents: defaultTheme() },
@@ -123,6 +126,8 @@ function checkTarget(root: string): void {
   if (existsSync(root) && !statSync(root).isDirectory()) {
     throw new DekError("not a directory", { path: root, hint: "pass a directory to init" });
   }
+  // A ref is someone else's project, read where it is: init would write its files into it.
+  refuseInsideRef(root);
   const outer = walkUp(root, (dir) => {
     const config = join(dir, "dek.toml");
     return existsSync(config) && statSync(config).isFile() ? dir : undefined;

package/src/cli/lint.ts

@@ -1,13 +1,14 @@
 import { existsSync } from "node:fs";
 import { relative } from "node:path";
 import type { Diagnostic } from "../core/diagnostic.ts";
+import { shellQuote } from "../core/escape.ts";
 import { lintDeck, lintProject, unreadableScriptDiagnostics } from "../core/lint.ts";
 import { playwrightMissingError } from "../core/playwright.ts";
 import { resolveRumdlBin, runRumdl } from "../core/rumdl.ts";
 import { mergeSarif, type SarifLog } from "../core/sarif.ts";
 import { syncDeck } from "../core/sync.ts";
 import { lintVisualDeck } from "../core/visual.ts";
-import { type SkippedCheck, skippedChecks, visualSkipped } from "./result.ts";
+import { RENDERED_RULES, type SkippedCheck, skippedChecks, visualSkipped } from "./result.ts";
 import type { DecksTarget } from "./scope.ts";
 
 export type LintCliResult = {
@@ -60,7 +61,7 @@ export async function lintCommand(
         ? []
         : [
             visualSkipped("dekc lint --visual", {
-              reason: "overflow and contrast are measured only with --visual",
+              reason: `${RENDERED_RULES} are measured only with --visual`,
             }),
           ]),
     ]),
@@ -79,6 +80,6 @@ function rumdlSkipped(scriptPath: string, cwd: string): SkippedCheck {
   return {
     check: "rumdl",
     reason: "rumdl ran but gave no result",
-    hint: `run \`${bin} check ${relative(cwd, scriptPath) || scriptPath}\` to see why`,
+    hint: `run \`${shellQuote(bin)} check ${shellQuote(relative(cwd, scriptPath) || scriptPath)}\` to see why`,
   };
 }

package/src/cli/main.ts

@@ -1,8 +1,9 @@
 import { DekError } from "../core/error.ts";
+import { shellQuote } from "../core/escape.ts";
 import { either } from "../core/prose.ts";
 import { isRefName } from "../core/ref-name.ts";
 import { resolveProject } from "../core/resolve.ts";
-import { addressHint } from "./address.ts";
+import { addressHint, deckWord, type HintDeck, withPlaceholderNote } from "./address.ts";
 import {
   type AnySpec,
   type CliResult,
@@ -13,7 +14,6 @@ import {
   subcommandAt,
   subcommandsOf,
 } from "./commands.ts";
-import { shellQuote } from "./files.ts";
 import { type CommandLine, parseCommandLine, wantsJson } from "./flags.ts";
 import { writeFailure, writeSuccess } from "./result.ts";
 import { DeckRequiredError, namesDeck, peelDeckArg, resolveTarget } from "./scope.ts";
@@ -197,12 +197,14 @@ function retypedWithDeck<T>(line: CommandLine, cwd: string, resolve: () => T): T
     }
     const typed = `\`dekc ${line.typed.map(shellQuote).join(" ")}\``;
     const [first] = error.decks;
+    // Each command is retyped for one deck; where to find a name left as <deck> is said once.
+    const retyped = (deck: HintDeck) => addressHint(typed, deck, cwd, { note: false });
     const hint = !first
       ? "run `dekc new <name>` to make a deck"
       : error.decks.length > NAMED_DECKS
-        ? `run ${addressHint(typed, first, cwd)}, or name another deck in place of ${first.name}; \`dekc ls\` lists them`
-        : `run ${either(error.decks.map((deck) => addressHint(typed, deck, cwd)))}`;
-    throw new DekError(error.message, { hint, cause: error });
+        ? `run ${retyped(first)}, or name another deck in place of ${deckWord(first.name)}; \`dekc ls\` lists them`
+        : `run ${either(error.decks.map(retyped))}`;
+    throw new DekError(error.message, { hint: withPlaceholderNote(hint), cause: error });
   }
 }
 

package/src/cli/new.ts

@@ -1,12 +1,15 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { loadConfig } from "../core/config.ts";
 import { deckPaths } from "../core/deck-paths.ts";
 import { DekError } from "../core/error.ts";
 import { DECK_NAME_HINT, isDeckName } from "../core/path.ts";
+import { isRefName } from "../core/ref-name.ts";
+import { readDeckFile } from "../core/resolve.ts";
+import { readSourceIfExists } from "../core/safe-fs.ts";
 import { syncDeck } from "../core/sync.ts";
 import { applyPlan, deckPlan, nextSteps } from "./files.ts";
-import { requireDeckFromCwd, requireProject } from "./scope.ts";
+import { type RefInfo, requireDeckFromCwd, requireProject, resolveTarget } from "./scope.ts";
 
 export type NewResult = {
   name: string;
@@ -16,6 +19,8 @@ export type NewResult = {
   updated: string[];
   /** The commands to run next, from the directory new ran in. */
   next: string[];
+  /** Set when the theme came from a ref with no license. */
+  warnings: string[];
 };
 
 export function newCommand(options: { cwd: string; name: string; themeFrom?: string }): NewResult {
@@ -35,19 +40,34 @@ export function newCommand(options: { cwd: string; name: string; themeFrom?: str
     });
   }
 
-  const themeSource = options.themeFrom
-    ? deckPaths(requireDeckFromCwd(options.cwd, options.themeFrom).deck.dir).theme
-    : join(project.root, "theme.css");
-  if (!existsSync(themeSource)) {
+  // A ref is read where it is, never written: only the copy below is the new deck's.
+  const fromRef =
+    options.themeFrom !== undefined && isRefName(options.themeFrom)
+      ? resolveTarget(options.cwd, "deck", { refs: true, deck: options.themeFrom })
+      : undefined;
+  const ref = fromRef?.ref;
+  const fromDeck = fromRef
+    ? fromRef.deck
+    : options.themeFrom
+      ? requireDeckFromCwd(options.cwd, options.themeFrom).deck
+      : undefined;
+  const themeSource = fromDeck ? deckPaths(fromDeck.dir).theme : join(project.root, "theme.css");
+  // What is copied is published with the new deck: a link out of its project is refused.
+  const source = fromDeck
+    ? readDeckFile(fromDeck.dir, themeSource)
+    : readSourceIfExists(themeSource, project.root);
+  if (source === undefined) {
     throw new DekError("theme.css not found", {
       path: themeSource,
-      hint: options.themeFrom
-        ? "run `dekc ls` and pick a deck that has theme.css"
-        : "add theme.css at the project root",
+      hint: ref
+        ? "run `dekc ref` to list the refs, and pick one whose deck has theme.css"
+        : options.themeFrom
+          ? "run `dekc ls` and pick a deck that has theme.css"
+          : "add theme.css at the project root",
     });
   }
 
-  const theme = readFileSync(themeSource, "utf8");
+  const theme = `${ref ? provenance(ref) : ""}${source}`;
   const { created } = applyPlan(
     deckPlan(project.root, name, theme, loadConfig(project.configPath)),
   );
@@ -61,5 +81,16 @@ export function newCommand(options: { cwd: string; name: string; themeFrom?: str
     created,
     updated: synced.dekFiles.updated,
     next: nextSteps(options.cwd, project.root, dir),
+    warnings:
+      ref && ref.license === null
+        ? [
+            `${ref.name} has no license; ask its author before you present or share a deck built on its theme`,
+          ]
+        : [],
   };
 }
+
+/** The first line of a theme copied from a ref: where it came from, for its reader and its credit. */
+function provenance(ref: RefInfo): string {
+  return `/* Theme from the ref ${ref.name} at ${ref.rev.slice(0, 7)}. */\n`;
+}

package/src/cli/pack.ts

@@ -0,0 +1,21 @@
+import { writePack } from "../core/pack.ts";
+import type { DecksTarget } from "./scope.ts";
+
+/** One file per deck, a single deck included, as `dekc pdf` answers, and what to fix first. */
+export type PackCliResult = { outs: string[]; warnings: string[] };
+
+export async function packCommand(
+  { project, decks }: DecksTarget,
+  options: { rootDist?: boolean } = {},
+): Promise<PackCliResult> {
+  const outs: string[] = [];
+  const warnings = new Set<string>();
+  for (const entry of decks) {
+    const done = await writePack(project, entry, { rootDist: options.rootDist });
+    outs.push(done.outPath);
+    for (const warning of done.warnings) {
+      warnings.add(warning);
+    }
+  }
+  return { outs, warnings: [...warnings] };
+}

package/src/cli/pptx.ts

@@ -1,20 +1,25 @@
-import { pptxDeck } from "../core/pptx.ts";
+import { type PptxLifted, pptxDeck } from "../core/pptx.ts";
 import type { DecksTarget } from "./scope.ts";
 
-/** One file per deck, a single deck included, as `dekc pdf` answers. */
-export type PptxCliResult = { outs: string[] };
+/**
+ * One file per deck, a single deck included, as `dekc pdf` answers, and what each file laid
+ * over its pictures, for the text output alone (`--json` is `outs`).
+ */
+export type PptxCliResult = { outs: string[]; lifted?: PptxLifted[] };
 
 export async function pptxCommand(
   { project, decks }: DecksTarget,
   options: { rootDist?: boolean; public?: boolean } = {},
 ): Promise<PptxCliResult> {
   const outs: string[] = [];
+  const lifted: PptxLifted[] = [];
   for (const entry of decks) {
     const done = await pptxDeck(
       { project, deck: entry },
       { rootDist: options.rootDist, public: options.public },
     );
     outs.push(done.outPath);
+    lifted.push(done.lifted);
   }
-  return { outs };
+  return { outs, lifted };
 }

package/src/cli/ref.ts

@@ -1,20 +1,30 @@
-import { existsSync, lstatSync, readdirSync, readFileSync, rmdirSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, lstatSync, readdirSync, readFileSync, rmdirSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { loadConfig } from "../core/config.ts";
 import { DekError } from "../core/error.ts";
+import { isPlainWord, shellQuote } from "../core/escape.ts";
 import { downloadTarball, resolveRev } from "../core/github.ts";
 import {
+  deckOfPack,
   installSnapshot,
   isPinnedRev,
+  packFile,
   parseRefSource,
-  type RefSource,
+  pickSnapshot,
+  readPack,
   readTarball,
+  refDir,
   refLicense,
   refState,
   refTitle,
+  refuseLinkUnderPacks,
+  refuseLinkUnderRefs,
+  type Snapshot,
+  snapshotDigest,
+  writeSnapshot,
 } from "../core/ref.ts";
-import { readTextIfExists } from "../core/resolve.ts";
-import { readSourceIfExists, removeInside, writeInside } from "../core/safe-fs.ts";
+import type { FileRefSource, GithubRefSource, RefSource } from "../core/ref-name.ts";
+import { readSourceIfExists, removeInside, requireInside, writeInside } from "../core/safe-fs.ts";
 import { writeAgentsMd } from "../core/sync.ts";
 import { setTableKey } from "../core/toml-keys.ts";
 import { requireProject } from "./scope.ts";
@@ -29,6 +39,8 @@ export type RefAddResult = {
   changed: boolean;
   dir: string;
   license: string | null;
+  /** A pack's ref: its committed copy, which a clone unpacks the ref from. */
+  pack?: string;
   warnings: string[];
 };
 
@@ -49,23 +61,82 @@ export type RefCliResult = RefAddResult | RefListResult | RefRmResult;
 export async function restoreRef(cwd: string, arg: string): Promise<void> {
   const source = parseRefSource(arg);
   const project = requireProject(cwd);
-  const { pinned, fetched } = refState(project, source.name);
+  const { pinned, dir, fetched } = refState(project, source.name);
   if (pinned === undefined || fetched) {
     return;
   }
+  // Said before a download that the write would refuse anyway.
+  refuseLinkUnderRefs(project.root, dir);
+  if (source.kind === "file") {
+    await unpackSnapshot(project.root, source, pinned);
+    return;
+  }
   await fetchSnapshot(project.root, source, pinned);
 }
 
-async function fetchSnapshot(root: string, source: RefSource, sha: string) {
+async function fetchSnapshot(root: string, source: GithubRefSource, sha: string) {
   const files = await readTarball(await downloadTarball(source.owner, source.repo, sha));
   return installSnapshot(root, source, sha, files);
 }
 
+/** A pack's snapshot, unpacked again from its committed copy, which must be the pinned one. */
+async function unpackSnapshot(root: string, source: FileRefSource, pin: string): Promise<void> {
+  const rel = packFile(source.deck);
+  const path = join(root, rel);
+  if (!existsSync(path)) {
+    throw new DekError(`${rel} is missing`, {
+      path,
+      hint: `a pack's ref is unpacked from its copy in packs/, so commit packs/ with dek.toml; run \`dekc ref <file>.tgz\` with the pack you were sent to add it again`,
+    });
+  }
+  const snapshot = await readPackFile(path, source, root);
+  if ((await snapshotDigest(snapshot)) !== pin) {
+    throw new DekError(`${rel} is not the pack ${source.name} is pinned to`, {
+      path,
+      hint: `run \`dekc ref ${shellQuote(rel)}\` to pin the pack that is there, or put back the one dek.toml pins`,
+    });
+  }
+  await writeSnapshot(root, source.name, pin, snapshot);
+}
+
+/** What a snapshot keeps of the pack at `path`; an error says which file it was about. */
+async function readPackFile(
+  path: string,
+  source: FileRefSource | undefined,
+  root?: string,
+): Promise<Snapshot & { source: FileRefSource; bytes: Uint8Array }> {
+  try {
+    const bytes = readFileSync(root === undefined ? path : requireInside(path, root));
+    const files = await readPack(bytes);
+    const found = source ?? parseRefSource(`file/${deckOfPack(files)}`);
+    if (found.kind !== "file") {
+      throw new DekError("the pack's deck cannot be named as a ref");
+    }
+    return { ...pickSnapshot(files, found), source: found, bytes };
+  } catch (error) {
+    if (error instanceof DekError && error.path === undefined) {
+      throw new DekError(error.message, { path, ...(error.hint ? { hint: error.hint } : {}) });
+    }
+    throw error;
+  }
+}
+
 /** `dekc ref <source>`: pin and fetch, or move the pin to the latest or to the rev after `@`. */
 export async function addRef(cwd: string, arg: string): Promise<RefAddResult> {
+  if (isPackPath(arg)) {
+    return addPack(cwd, arg);
+  }
   const source = parseRefSource(arg);
+  if (source.kind === "file") {
+    throw new DekError(`"${arg}" names a pack's ref`, {
+      hint: "add a pack by its file, `dekc ref <file>.tgz`; `dekc ref` lists the refs already added",
+    });
+  }
   const project = requireProject(cwd);
+  refuseSharedFolders(project, source);
   const { pinned: from, dir, fetched } = refState(project, source.name);
+  // Said before a download that the write would refuse anyway.
+  refuseLinkUnderRefs(project.root, dir);
   const rev =
     source.rev !== undefined && isPinnedRev(source.rev)
       ? source.rev
@@ -78,7 +149,7 @@ export async function addRef(cwd: string, arg: string): Promise<RefAddResult> {
     changed = true;
   }
   if (from !== rev) {
-    const toml = readTextIfExists(project.configPath) ?? "";
+    const toml = readSourceIfExists(project.configPath, project.root) ?? "";
     writeInside(project.configPath, setTableKey(toml, "refs", source.name, rev), project.root);
     changed = true;
   }
@@ -103,6 +174,153 @@ export async function addRef(cwd: string, arg: string): Promise<RefAddResult> {
   };
 }
 
+/**
+ * Refuses a pin whose folders another pin, or a folder already on disk, takes. refs/ and packs/
+ * are named by the ref, and macOS and Windows read a name without its case, so `file/Talk` and
+ * `file/talk` would share one snapshot and one pack, and adding the second would replace the
+ * first's.
+ */
+function refuseSharedFolders(
+  project: { root: string; configPath: string },
+  source: RefSource,
+): void {
+  const { name } = source;
+  const other = Object.keys(loadConfig(project.configPath).refs ?? {}).find(
+    (pinned) => pinned !== name && folded(pinned) === folded(name),
+  );
+  if (other !== undefined) {
+    throw new DekError(`${name} would share its folders with ${other}, which dek.toml pins`, {
+      path: project.configPath,
+      hint: `a ref's folders are named without their case on macOS and Windows; to pin ${name} in its place, run \`dekc ref rm ${shellQuote(other)}\` first`,
+    });
+  }
+  const paths = [relative(project.root, refDir(project.root, name))];
+  if (source.kind === "file") {
+    paths.push(packFile(source.deck));
+  }
+  const left = paths
+    .map((path) => spelledOtherwise(project.root, path))
+    .find((path) => path !== undefined);
+  if (left !== undefined) {
+    const shown = isPlainWord(left) ? left : "another folder";
+    throw new DekError(
+      `${name} would share a folder with ${shown}, which is already in the project`,
+      {
+        path: join(project.root, left),
+        hint: "no ref in dek.toml pins it, so a ref removed by hand left it; delete it and add the ref again",
+      },
+    );
+  }
+}
+
+/** A name as a file system blind to case and form reads it: APFS folds ς as σ, and fi as fi. */
+function folded(name: string): string {
+  return name.normalize("NFKC").toUpperCase().toLowerCase();
+}
+
+/**
+ * The path, under `root`, of a folder or file a file system blind to case and form would read as
+ * `path` though it is spelled otherwise, found segment by segment.
+ */
+function spelledOtherwise(root: string, path: string): string | undefined {
+  let dir = root;
+  const walked: string[] = [];
+  for (const segment of path.split(sep)) {
+    const entries = existsSync(dir) && statSync(dir).isDirectory() ? readdirSync(dir) : [];
+    const other = entries.find((entry) => entry !== segment && folded(entry) === folded(segment));
+    if (other !== undefined) {
+      return join(...walked, other);
+    }
+    if (!entries.includes(segment)) {
+      return undefined;
+    }
+    walked.push(segment);
+    dir = join(dir, segment);
+  }
+  return undefined;
+}
+
+/** An argument that ends in .tgz or .tar.gz is a pack's path, never a ref name. */
+function isPackPath(arg: string): boolean {
+  return /\.(tgz|tar\.gz)$/i.test(arg);
+}
+
+/**
+ * `dekc ref <file>.tgz`: pin the pack's deck as `file/<deck>` to the digest of its files, keep
+ * the pack as packs/<deck>.tgz for git, and unpack the snapshot. Everything is read and checked
+ * before the first write.
+ */
+async function addPack(cwd: string, arg: string): Promise<RefAddResult> {
+  const project = requireProject(cwd);
+  const given = resolve(cwd, arg);
+  if (!existsSync(given)) {
+    throw new DekError(`no such file: ${arg}`, {
+      path: given,
+      hint: "pass the path of the .tgz `dekc pack` wrote",
+    });
+  }
+  const read = await readPackFile(given, undefined);
+  const { source, bytes } = read;
+  refuseSharedFolders(project, source);
+  const rev = await snapshotDigest(read);
+  const { pinned: from, dir, fetched } = refState(project, source.name);
+  const stored = join(project.root, packFile(source.deck));
+  // Before the first write: the copy below is written by name.
+  refuseLinkUnderPacks(project.root, source.deck);
+
+  let changed = false;
+  if (!(fetched && from === rev)) {
+    await writeSnapshot(project.root, source.name, rev, read);
+    changed = true;
+  }
+  if (!(await isPackOf(stored, source, rev, project.root))) {
+    writeInside(stored, bytes, project.root);
+    changed = true;
+  }
+  if (from !== rev) {
+    const toml = readSourceIfExists(project.configPath, project.root) ?? "";
+    writeInside(project.configPath, setTableKey(toml, "refs", source.name, rev), project.root);
+    changed = true;
+  }
+  ignoreRefs(project.root);
+  writeAgentsMd(project.root);
+
+  const license = refLicense(dir);
+  return {
+    action: "add",
+    name: source.name,
+    rev,
+    ...(from !== undefined && from !== rev ? { from } : {}),
+    changed,
+    dir,
+    license,
+    pack: stored,
+    warnings:
+      license === null
+        ? [
+            "the pack has no license; read it as a model, but ask its author before reusing its text or assets",
+          ]
+        : [],
+  };
+}
+
+/** True when the pack at `path` holds the files `rev` pins. */
+async function isPackOf(
+  path: string,
+  source: FileRefSource,
+  rev: string,
+  root: string,
+): Promise<boolean> {
+  if (!existsSync(path)) {
+    return false;
+  }
+  try {
+    return (await snapshotDigest(await readPackFile(path, source, root))) === rev;
+  } catch {
+    return false;
+  }
+}
+
 export function listRefs(cwd: string): RefListResult {
   const project = requireProject(cwd);
   const refs = Object.keys(loadConfig(project.configPath).refs ?? {}).map((name) => {
@@ -123,8 +341,13 @@ export function removeRef(cwd: string, arg: string): RefRmResult {
       hint: "run `dekc ref` to list refs",
     });
   }
+  // Before anything changes: the deletes below must not reach what a link there points to.
+  refuseLinkUnderRefs(project.root, dir);
+  if (source.kind === "file") {
+    refuseLinkUnderPacks(project.root, source.deck);
+  }
   if (pinned !== undefined) {
-    const toml = readFileSync(project.configPath, "utf8");
+    const toml = readSourceIfExists(project.configPath, project.root) ?? "";
     writeInside(
       project.configPath,
       setTableKey(toml, "refs", source.name, undefined),
@@ -133,6 +356,17 @@ export function removeRef(cwd: string, arg: string): RefRmResult {
   }
   removeInside(dir, project.root, { recursive: true });
   removeEmptyParents(dirname(dir), project.root);
+  if (source.kind === "file") {
+    const packs = join(project.root, "packs");
+    removeInside(join(project.root, packFile(source.deck)), project.root);
+    if (
+      existsSync(packs) &&
+      !lstatSync(packs).isSymbolicLink() &&
+      readdirSync(packs).length === 0
+    ) {
+      rmdirSync(packs);
+    }
+  }
   writeAgentsMd(project.root);
   return { action: "rm", name: source.name };
 }

package/src/cli/result.ts

@@ -13,15 +13,18 @@ export function skippedChecks(skipped: SkippedCheck[]): { skipped?: SkippedCheck
   return skipped.length > 0 ? { skipped } : {};
 }
 
+/** What `--visual` measures in a browser, as a hint or a reason names it. */
+export const RENDERED_RULES = "overflow, contrast, line breaks, and alignment";
+
 /**
- * The overflow and contrast rules, when a run leaves them out: why, and `rerun`, the command that
+ * The rules a browser measures, when a run leaves them out: why, and `rerun`, the command that
  * measures them. Without Playwright, installing it comes first, whatever the reason was.
  */
 export function visualSkipped(
   rerun: string,
   options: { reason: string; runner?: PlaywrightRunner },
 ): SkippedCheck {
-  const measure = `run \`${rerun}\` to measure overflow and contrast`;
+  const measure = `run \`${rerun}\` to measure ${RENDERED_RULES}`;
   return playwrightReady(options.runner)
     ? { check: "visual", reason: options.reason, hint: measure }
     : {