livemark 0.25.0 → 0.27.0

package/source/actions/config/define.unit.ts

@@ -31,4 +31,13 @@ describe("defineConfig", () => {
     const config = defineConfig({})
     expect(config.include).toBe("**/*.md")
   })
+
+  it("should accept an inline Markdown banner", () => {
+    const config = defineConfig({ banner: "Hi · [x](/y/)" })
+    expect(config.banner).toBe("Hi · [x](/y/)")
+  })
+
+  it("should leave banner unset by default", () => {
+    expect(defineConfig({}).banner).toBeUndefined()
+  })
 })

package/source/actions/escape/copy.ts

@@ -0,0 +1,35 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from "../../settings.ts"
+
+/**
+ * Copy a livemark default into `<root>/.livemark/<path>`.
+ *
+ * Throws when the path is not escapable, is not a livemark file, or the
+ * destination already exists. Returns the destination path.
+ */
+export function copyEscape(props: { root: string; sourceRoot: string; path: string }) {
+  const isTopLevelFile = !props.path.includes("/") && ESCAPABLE_FILES.includes(props.path)
+  const [first] = props.path.split("/")
+  const isFolderPath =
+    !!first && ESCAPABLE_FOLDERS.includes(first) && !props.path.includes("..")
+  if (!isTopLevelFile && !isFolderPath) {
+    throw new Error(
+      `'${props.path}' is not escapable (folders: ${ESCAPABLE_FOLDERS.join(", ")}; files: ${ESCAPABLE_FILES.join(", ")})`,
+    )
+  }
+
+  const src = join(props.sourceRoot, props.path)
+  if (!existsSync(src) || !statSync(src).isFile()) {
+    throw new Error(`'${props.path}' is not a livemark file`)
+  }
+
+  const dest = join(props.root, ".livemark", props.path)
+  if (existsSync(dest)) {
+    throw new Error(`.livemark/${props.path} already exists`)
+  }
+
+  mkdirSync(dirname(dest), { recursive: true })
+  writeFileSync(dest, readFileSync(src))
+  return dest
+}

package/source/actions/escape/copy.unit.ts

@@ -0,0 +1,51 @@
+import fs from "node:fs"
+import { join } from "node:path"
+import { temporaryDirectoryTask } from "tempy"
+import { describe, expect, it } from "vite-plus/test"
+import { copyEscape } from "./copy.ts"
+
+describe("copyEscape", () => {
+  it("should copy a default into .livemark/", () =>
+    temporaryDirectoryTask(async tmpDir => {
+      const sourceRoot = createSource(tmpDir)
+      const dest = copyEscape({ root: tmpDir, sourceRoot, path: "components/Footer.tsx" })
+      expect(dest).toBe(join(tmpDir, ".livemark", "components", "Footer.tsx"))
+      expect(fs.readFileSync(dest, "utf8")).toBe("default\n")
+    }))
+
+  it("should refuse to overwrite an existing override", () =>
+    temporaryDirectoryTask(async tmpDir => {
+      const sourceRoot = createSource(tmpDir)
+      copyEscape({ root: tmpDir, sourceRoot, path: "client.tsx" })
+      expect(() => copyEscape({ root: tmpDir, sourceRoot, path: "client.tsx" })).toThrow(
+        /already exists/,
+      )
+    }))
+
+  it("should reject paths outside the escape contract", () =>
+    temporaryDirectoryTask(async tmpDir => {
+      const sourceRoot = createSource(tmpDir)
+      for (const path of ["index.ts", "components/../index.ts", "helpers/toc.ts"]) {
+        expect(() => copyEscape({ root: tmpDir, sourceRoot, path })).toThrow(
+          /not escapable/,
+        )
+      }
+    }))
+
+  it("should reject an escapable path with no livemark file", () =>
+    temporaryDirectoryTask(async tmpDir => {
+      const sourceRoot = createSource(tmpDir)
+      expect(() =>
+        copyEscape({ root: tmpDir, sourceRoot, path: "components/Missing.tsx" }),
+      ).toThrow(/not a livemark file/)
+    }))
+})
+
+function createSource(tmpDir: string) {
+  const sourceRoot = join(tmpDir, "source")
+  fs.mkdirSync(join(sourceRoot, "components"), { recursive: true })
+  fs.writeFileSync(join(sourceRoot, "components", "Footer.tsx"), "default\n")
+  fs.writeFileSync(join(sourceRoot, "client.tsx"), "default\n")
+  fs.writeFileSync(join(sourceRoot, "index.ts"), "default\n")
+  return sourceRoot
+}

package/source/actions/escape/list.ts

@@ -0,0 +1,30 @@
+import { existsSync, readdirSync, statSync } from "node:fs"
+import { join } from "node:path"
+import { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from "../../settings.ts"
+
+/** An escapable livemark file and whether the project already shadows it. */
+export interface Escape {
+  path: string
+  escaped: boolean
+}
+
+/**
+ * List every file a project can shadow under `.livemark/`, sorted by path.
+ */
+export function listEscapes(props: { root: string; sourceRoot: string }) {
+  const paths: string[] = []
+  for (const folder of ESCAPABLE_FOLDERS) {
+    const dir = join(props.sourceRoot, folder)
+    if (!existsSync(dir)) continue
+    for (const entry of readdirSync(dir)) {
+      if (statSync(join(dir, entry)).isFile()) paths.push(`${folder}/${entry}`)
+    }
+  }
+  for (const file of ESCAPABLE_FILES) {
+    if (existsSync(join(props.sourceRoot, file))) paths.push(file)
+  }
+  return paths.sort().map((path): Escape => ({
+    path,
+    escaped: existsSync(join(props.root, ".livemark", path)),
+  }))
+}

package/source/actions/escape/list.unit.ts

@@ -0,0 +1,42 @@
+import fs from "node:fs"
+import { join } from "node:path"
+import { temporaryDirectoryTask } from "tempy"
+import { describe, expect, it } from "vite-plus/test"
+import { listEscapes } from "./list.ts"
+
+describe("listEscapes", () => {
+  it("should list folder files and top-level files, sorted", () =>
+    temporaryDirectoryTask(async tmpDir => {
+      const sourceRoot = join(tmpDir, "source")
+      writeFile(join(sourceRoot, "components", "Footer.tsx"))
+      writeFile(join(sourceRoot, "styles", "general.css"))
+      writeFile(join(sourceRoot, "client.tsx"))
+      writeFile(join(sourceRoot, "index.ts"))
+      fs.mkdirSync(join(sourceRoot, "elements", "nested"), { recursive: true })
+
+      const escapes = listEscapes({ root: tmpDir, sourceRoot })
+      expect(escapes.map(escape => escape.path)).toEqual([
+        "client.tsx",
+        "components/Footer.tsx",
+        "styles/general.css",
+      ])
+    }))
+
+  it("should mark files the project already shadows", () =>
+    temporaryDirectoryTask(async tmpDir => {
+      const sourceRoot = join(tmpDir, "source")
+      writeFile(join(sourceRoot, "components", "Footer.tsx"))
+      writeFile(join(sourceRoot, "components", "Header.tsx"))
+      writeFile(join(tmpDir, ".livemark", "components", "Footer.tsx"))
+
+      expect(listEscapes({ root: tmpDir, sourceRoot })).toEqual([
+        { path: "components/Footer.tsx", escaped: true },
+        { path: "components/Header.tsx", escaped: false },
+      ])
+    }))
+})
+
+function writeFile(path: string) {
+  fs.mkdirSync(join(path, ".."), { recursive: true })
+  fs.writeFileSync(path, "default\n")
+}

package/source/actions/target/build.ts

@@ -1,86 +1,66 @@
-import { createHash } from "node:crypto"
-import { cpSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs"
-import { dirname, join } from "node:path"
+import { cpSync, existsSync, mkdirSync, readlinkSync, rmSync, symlinkSync } from "node:fs"
+import { basename, dirname, join, relative, resolve } from "node:path"
+import { resolveDependencyDir } from "../../helpers/dependency-dir.ts"
 import { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from "../../settings.ts"
 
-// This file ships at <livemark-pkg>/source/actions/target/build.ts AND
-// gets copied into <livemark-pkg>/targets/<hash>/actions/target/build.ts
-// as part of every per-consumer mount. content-collections loads the
-// COPIED version, so `import.meta.dirname` can land inside `targets/`.
-// Walk up to the first directory holding livemark's `package.json` so
-// SOURCE_DIR / TARGETS_ROOT always anchor at the package, never at a
-// per-consumer dir.
-const LIVEMARK_PKG = findLivemarkPkg(import.meta.dirname)
-const SOURCE_DIR = join(LIVEMARK_PKG, "source")
-const TARGETS_ROOT = join(LIVEMARK_PKG, "targets")
-
-function findLivemarkPkg(start: string) {
-  let cur = start
-  while (cur !== dirname(cur)) {
-    if (existsSync(join(cur, "package.json"))) return cur
-    cur = dirname(cur)
-  }
-  throw new Error(`Could not locate livemark package root from ${start}`)
-}
-
 /**
- * Synthesize a fully self-contained per-consumer Vite mount at
- * `<livemark-pkg>/targets/<hash>/`.
- *
- * The mount is built by copying livemark's `source/` wholesale, then
- * overlaying any matching files from the consumer's `.livemark/`. Every
- * file lives at its target path as a real file — no symlinks — so
- * Vite's relative-import and bare-specifier resolution all anchor
- * inside the target dir, where node_modules walks reach livemark's pnpm
- * subtree natively.
- *
- * Behavior:
- * - First run (target dir missing): full source copy + overlay.
- * - Subsequent runs: skip the source copy. Source is immutable in
- *   installed mode; in livemark's own dev the watcher keeps the target
- *   in sync. Only the `.livemark/` overlay is re-applied each time —
- *   cheap, and may have changed between runs.
- * - With `--clear` in argv: wipe the entire target dir (including
- *   downstream caches like `.vite/`, `.content-collections/`,
- *   `cache/`, `routeTree.gen.ts`) and rebuild from scratch. Use this
- *   to recover from a stale or corrupted cache.
- *
- * Returns the absolute path to the target dir.
+ * Synthesize the project's Vite mount at `.livemark/.target/`: livemark's `source/` with
+ * the project's `.livemark/` escapes copied over it, plus a `node_modules` link to
+ * livemark's dependencies. Escapable folders are rebuilt on every run, so a removed escape
+ * never keeps rendering. Returns the target dir.
  */
-export function buildTarget(configPath: string) {
-  const targetDir = targetDirFor(configPath)
-  const overridesRoot = join(dirname(configPath), ".livemark")
-  const clear = process.argv.includes("--clear")
-
-  if (clear) rmSync(targetDir, { recursive: true, force: true })
-
-  if (!existsSync(targetDir)) {
-    mkdirSync(targetDir, { recursive: true })
-    cpSync(SOURCE_DIR, targetDir, { recursive: true })
-  }
+export function buildTarget(props: { configPath: string; sourceDir: string }) {
+  const targetDir = targetDirFor(props.configPath)
+  const overridesRoot = dirname(targetDir)
+  mkdirSync(targetDir, { recursive: true })
 
+  cpSync(props.sourceDir, targetDir, {
+    recursive: true,
+    filter: src => isPackageFile(src) && !isEscapableFolder(src, props.sourceDir),
+  })
   for (const folder of ESCAPABLE_FOLDERS) {
-    const overlay = join(overridesRoot, folder)
-    if (!existsSync(overlay)) continue
     const dest = join(targetDir, folder)
-    if (!existsSync(dest)) mkdirSync(dest, { recursive: true })
-    for (const f of readdirSync(overlay)) {
-      cpSync(join(overlay, f), join(dest, f), { recursive: true, force: true })
-    }
+    rmSync(dest, { recursive: true, force: true })
+    const source = join(props.sourceDir, folder)
+    if (existsSync(source))
+      cpSync(source, dest, { recursive: true, filter: isPackageFile })
+    const overlay = join(overridesRoot, folder)
+    if (existsSync(overlay)) cpSync(overlay, dest, { recursive: true })
   }
   for (const file of ESCAPABLE_FILES) {
     const overlay = join(overridesRoot, file)
-    if (!existsSync(overlay)) continue
-    cpSync(overlay, join(targetDir, file), { force: true })
+    if (existsSync(overlay)) cpSync(overlay, join(targetDir, file))
   }
 
+  linkDependencies(targetDir, resolveDependencyDir(props.sourceDir))
   return targetDir
 }
 
-/** Compute the target dir for a given consumer config path without
- *  rebuilding it. Used by code that needs to write into the target
- *  (e.g. cache writers) outside of `buildTarget`'s setup phase. */
+/** Locate the project's target dir without building it. */
 export function targetDirFor(configPath: string) {
-  const hash = createHash("sha256").update(configPath).digest("hex").slice(0, 16)
-  return join(TARGETS_ROOT, hash)
+  return join(dirname(configPath), ".livemark", ".target")
+}
+
+function isPackageFile(src: string) {
+  return !/\.unit\.tsx?$/.test(src) && basename(src) !== "fixtures"
+}
+
+function isEscapableFolder(src: string, sourceDir: string) {
+  return ESCAPABLE_FOLDERS.includes(relative(sourceDir, src))
+}
+
+function linkDependencies(targetDir: string, dependencyDir: string) {
+  const link = join(targetDir, "node_modules")
+  if (readLink(link) === resolve(dependencyDir)) return
+  // Not recursive: a stale link must go without touching the store it points into.
+  rmSync(link, { force: true })
+  symlinkSync(dependencyDir, link, "junction")
+}
+
+function readLink(path: string) {
+  try {
+    return resolve(dirname(path), readlinkSync(path))
+  } catch {
+    return undefined
+  }
 }

package/source/actions/target/build.unit.ts

@@ -0,0 +1,95 @@
+import { existsSync, readFileSync, readlinkSync, realpathSync } from "node:fs"
+import { mkdir, rm, symlink, writeFile } from "node:fs/promises"
+import { dirname, join } from "node:path"
+import { temporaryDirectoryTask } from "tempy"
+import { describe, expect, it } from "vite-plus/test"
+import { buildTarget, targetDirFor } from "./build.ts"
+
+describe("buildTarget", () => {
+  it("copies the source, overlays escapes and skips unit tests", () =>
+    temporaryDirectoryTask(async root => {
+      const { configPath, sourceDir } = await createFixture(root)
+      await put(join(root, "project/.livemark/components/Footer.tsx"), "escaped")
+      await put(join(root, "project/.livemark/head.ts"), "escaped head")
+
+      const targetDir = buildTarget({ configPath, sourceDir })
+
+      expect(targetDir).toBe(join(root, "project/.livemark/.target"))
+      expect(read(targetDir, "components/Footer.tsx")).toBe("escaped")
+      expect(read(targetDir, "components/Header.tsx")).toBe("default")
+      expect(read(targetDir, "head.ts")).toBe("escaped head")
+      expect(read(targetDir, "helpers/util.ts")).toBe("util")
+      expect(existsSync(join(targetDir, "helpers/util.unit.ts"))).toBe(false)
+    }))
+
+  it("drops escapes removed since the last run", () =>
+    temporaryDirectoryTask(async root => {
+      const { configPath, sourceDir } = await createFixture(root)
+      const overrides = join(root, "project/.livemark")
+      await put(join(overrides, "components/Footer.tsx"), "escaped")
+      await put(join(overrides, "routes/about.tsx"), "about")
+      await put(join(overrides, "head.ts"), "escaped head")
+      buildTarget({ configPath, sourceDir })
+
+      await rm(join(overrides, "components"), { recursive: true })
+      await rm(join(overrides, "routes"), { recursive: true })
+      await rm(join(overrides, "head.ts"))
+      const targetDir = buildTarget({ configPath, sourceDir })
+
+      expect(read(targetDir, "components/Footer.tsx")).toBe("default")
+      expect(existsSync(join(targetDir, "routes/about.tsx"))).toBe(false)
+      expect(read(targetDir, "head.ts")).toBe("head")
+    }))
+
+  it("keeps generated entries between runs", () =>
+    temporaryDirectoryTask(async root => {
+      const { configPath, sourceDir } = await createFixture(root)
+      const targetDir = buildTarget({ configPath, sourceDir })
+      await put(join(targetDir, "cache/changelog/entry.md"), "cached")
+
+      buildTarget({ configPath, sourceDir })
+
+      expect(read(targetDir, "cache/changelog/entry.md")).toBe("cached")
+    }))
+
+  it("links node_modules to livemark's dependencies and repairs a stale link", () =>
+    temporaryDirectoryTask(async root => {
+      const { configPath, sourceDir } = await createFixture(root)
+      const link = join(targetDirFor(configPath), "node_modules")
+      const dependencyDir = realpathSync(join(root, "livemark/node_modules"))
+
+      buildTarget({ configPath, sourceDir })
+      expect(readlinkSync(link)).toBe(dependencyDir)
+
+      await rm(link)
+      await mkdir(join(root, "elsewhere"))
+      await symlink(join(root, "elsewhere"), link, "junction")
+      buildTarget({ configPath, sourceDir })
+
+      expect(readlinkSync(link)).toBe(dependencyDir)
+      expect(existsSync(join(root, "elsewhere"))).toBe(true)
+    }))
+})
+
+async function createFixture(root: string) {
+  const sourceDir = join(root, "livemark/source")
+  await put(join(sourceDir, "components/Footer.tsx"), "default")
+  await put(join(sourceDir, "components/Header.tsx"), "default")
+  await put(join(sourceDir, "routes/index.tsx"), "index")
+  await put(join(sourceDir, "helpers/util.ts"), "util")
+  await put(join(sourceDir, "helpers/util.unit.ts"), "test")
+  await put(join(sourceDir, "head.ts"), "head")
+  await mkdir(join(root, "livemark/node_modules"))
+  const configPath = join(root, "project/livemark.config.ts")
+  await put(configPath, "export default {}")
+  return { configPath, sourceDir }
+}
+
+async function put(path: string, content: string) {
+  await mkdir(dirname(path), { recursive: true })
+  await writeFile(path, content)
+}
+
+function read(dir: string, path: string) {
+  return readFileSync(join(dir, path), "utf-8")
+}

package/source/actions/target/clear.ts

@@ -0,0 +1,14 @@
+import { rmSync } from "node:fs"
+import { join } from "node:path"
+import { targetDirFor } from "./build.ts"
+
+/**
+ * Wipe the project's target dir so the next run rebuilds it from scratch.
+ */
+export function clearTarget(configPath: string) {
+  const targetDir = targetDirFor(configPath)
+  // Unlink the dependency link first so the recursive remove cannot reach the store.
+  rmSync(join(targetDir, "node_modules"), { force: true })
+  rmSync(targetDir, { recursive: true, force: true })
+  return targetDir
+}

package/source/actions/target/clear.unit.ts

@@ -0,0 +1,25 @@
+import { existsSync } from "node:fs"
+import { mkdir, symlink, writeFile } from "node:fs/promises"
+import { join } from "node:path"
+import { temporaryDirectoryTask } from "tempy"
+import { describe, expect, it } from "vite-plus/test"
+import { targetDirFor } from "./build.ts"
+import { clearTarget } from "./clear.ts"
+
+describe("clearTarget", () => {
+  it("removes the target dir without following its dependency link", () =>
+    temporaryDirectoryTask(async root => {
+      const configPath = join(root, "livemark.config.ts")
+      const targetDir = targetDirFor(configPath)
+      await mkdir(join(targetDir, "cache"), { recursive: true })
+      await writeFile(join(targetDir, "cache", "entry.md"), "cached")
+      await mkdir(join(root, "deps"))
+      await writeFile(join(root, "deps", "kept.js"), "")
+      await symlink(join(root, "deps"), join(targetDir, "node_modules"), "junction")
+
+      expect(clearTarget(configPath)).toBe(targetDir)
+      expect(existsSync(targetDir)).toBe(false)
+      expect(existsSync(join(root, "deps", "kept.js"))).toBe(true)
+      expect(() => clearTarget(configPath)).not.toThrow()
+    }))
+})

package/source/commands/build.ts

@@ -9,7 +9,6 @@ const configFile = join(import.meta.dirname, "..", "..", "source", "vite.config.
  */
 export const build = new Command("build")
   .description("Build the site for production")
-  .option("--clear", "Wipe and fully rebuild the runtime target dir")
   .action(async () => {
     const builder = await createBuilder({ configFile })
     await builder.buildApp()

package/source/commands/clear.ts

@@ -0,0 +1,15 @@
+import { Command } from "commander"
+import pc from "picocolors"
+import { loadConfig } from "../actions/config/load.ts"
+import { clearTarget } from "../actions/target/clear.ts"
+
+/**
+ * Wipe the generated `.livemark/.target/` mount.
+ */
+export const clear = new Command("clear")
+  .description("Wipe the generated .livemark/.target/ mount")
+  .action(async () => {
+    const config = await loadConfig()
+    const targetDir = clearTarget(config.configPath)
+    console.log(`Cleared ${pc.dim(targetDir)}`)
+  })

package/source/commands/escape.ts

@@ -1,79 +1,62 @@
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  statSync,
-  writeFileSync,
-} from "node:fs"
-import { dirname, join } from "node:path"
+import { join } from "node:path"
+import { autocompleteMultiselect, cancel, isCancel } from "@clack/prompts"
 import { Command } from "commander"
 import pc from "picocolors"
-import { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from "../settings.ts"
+import { copyEscape } from "../actions/escape/copy.ts"
+import { listEscapes } from "../actions/escape/list.ts"
 
-const defaultsRoot = join(import.meta.dirname, "..", "..", "source")
+const sourceRoot = join(import.meta.dirname, "..", "..", "source")
 
 /**
- * List or copy escapable livemark files into `.livemark/`.
+ * Pick, list or copy escapable livemark files into `.livemark/`.
  *
- * Without an argument, prints every file you can shadow. With a path, copies
- * the default from the livemark package into `.livemark/<path>`; fails if the
+ * Without an argument, opens a searchable picker in a terminal and prints every
+ * file you can shadow otherwise (or with `--list`). With paths, copies each
+ * default from the livemark package into `.livemark/<path>`; fails if a
  * destination already exists.
  */
 export const escape = new Command("escape")
-  .description("List or copy escapable livemark files into .livemark/")
+  .description("Pick, list or copy escapable livemark files into .livemark/")
   .argument(
-    "[path]",
-    "path relative to .livemark/ (e.g. components/Footer.tsx, client.tsx)",
+    "[paths...]",
+    "paths relative to .livemark/ (e.g. components/Footer.tsx, client.tsx)",
   )
-  .action((relPath?: string) => {
-    if (!relPath) {
-      for (const file of listEscapable()) console.log(file)
+  .option("-l, --list", "print every escapable file instead of opening the picker")
+  .action(async (paths: string[], options: { list?: boolean }) => {
+    const root = process.cwd()
+    if (paths.length) return copyPaths(root, paths)
+
+    const escapes = listEscapes({ root, sourceRoot })
+    if (options.list || !process.stdin.isTTY || !process.stdout.isTTY) {
+      for (const escape of escapes) console.log(escape.path)
       console.log(pc.dim("\nRun 'livemark escape <path>' to copy a file into .livemark/"))
       return
     }
 
-    const isTopLevelFile = !relPath.includes("/") && ESCAPABLE_FILES.includes(relPath)
-    const [first] = relPath.split("/")
-    const isFolderPath =
-      !!first && ESCAPABLE_FOLDERS.includes(first) && !relPath.includes("..")
-    if (!isTopLevelFile && !isFolderPath) {
-      console.error(
-        pc.red(
-          `Error: '${relPath}' is not escapable (folders: ${ESCAPABLE_FOLDERS.join(", ")}; files: ${ESCAPABLE_FILES.join(", ")})`,
-        ),
-      )
-      process.exit(1)
-    }
-
-    const src = join(defaultsRoot, relPath)
-    if (!existsSync(src) || !statSync(src).isFile()) {
-      console.error(pc.red(`Error: '${relPath}' is not a livemark file`))
-      process.exit(1)
-    }
-
-    const dest = join(process.cwd(), ".livemark", relPath)
-    if (existsSync(dest)) {
-      console.error(pc.red(`Error: .livemark/${relPath} already exists`))
-      process.exit(1)
-    }
-
-    mkdirSync(dirname(dest), { recursive: true })
-    writeFileSync(dest, readFileSync(src))
-    console.log(`Copied ${pc.dim(relPath)} → ${pc.green(`.livemark/${relPath}`)}`)
+    const selected = await autocompleteMultiselect({
+      message: "Select files to escape into .livemark/",
+      placeholder: "Type to search...",
+      options: escapes.map(escape => ({
+        value: escape.path,
+        label: escape.path,
+        hint: escape.escaped ? "already escaped" : undefined,
+        disabled: escape.escaped,
+      })),
+      required: false,
+    })
+    if (isCancel(selected)) return cancel("Nothing copied")
+    copyPaths(root, selected)
   })
 
-function listEscapable() {
-  const files: string[] = []
-  for (const folder of ESCAPABLE_FOLDERS) {
-    const dir = join(defaultsRoot, folder)
-    if (!existsSync(dir)) continue
-    for (const entry of readdirSync(dir)) {
-      if (statSync(join(dir, entry)).isFile()) files.push(`${folder}/${entry}`)
+function copyPaths(root: string, paths: string[]) {
+  for (const path of paths) {
+    try {
+      copyEscape({ root, sourceRoot, path })
+      console.log(`Copied ${pc.dim(path)} → ${pc.green(`.livemark/${path}`)}`)
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      console.error(pc.red(`Error: ${message}`))
+      process.exitCode = 1
     }
   }
-  for (const file of ESCAPABLE_FILES) {
-    if (existsSync(join(defaultsRoot, file))) files.push(file)
-  }
-  return files.sort()
 }

package/source/commands/preview.ts

@@ -9,7 +9,6 @@ const configFile = join(import.meta.dirname, "..", "..", "source", "vite.config.
  */
 export const preview = new Command("preview")
   .description("Preview the production build locally")
-  .option("--clear", "Wipe and fully rebuild the runtime target dir")
   .action(async () => {
     const server = await vitePreview({
       configFile,

package/source/commands/start.ts

@@ -9,7 +9,6 @@ const configFile = join(import.meta.dirname, "..", "..", "source", "vite.config.
  */
 export const start = new Command("start")
   .description("Start a live server")
-  .option("--clear", "Wipe and fully rebuild the runtime target dir")
   .action(async () => {
     const server = await createServer({
       configFile,

package/source/components/AnsiCode.tsx

@@ -1,7 +1,7 @@
 /** Renders pre-formatted HTML produced from ANSI escape sequences */
 export function AnsiCode(props: { html: string }) {
   return (
-    <figure className="shiki not-prose my-4 relative rounded-xl border shadow-sm overflow-hidden text-sm bg-sidebar dark:bg-sidebar">
+    <figure className="shiki not-prose my-4 relative rounded-card border shadow-sm overflow-hidden text-sm bg-sidebar dark:bg-sidebar">
       <div className="text-[0.8125rem] py-3.5 overflow-auto">
         <pre className="min-w-full w-max">
           <code