@visulima/vis 1.0.0-alpha.11 → 1.0.0-alpha.13

package/dist/packem_chunks/handler47.js

@@ -1,1491 +1,27 @@
-import { createRequire as __cjs_createRequire } from "node:module";
+var Ee=Object.defineProperty;var f=(e,t)=>Ee(e,"name",{value:t,configurable:!0});import{createRequire as Ae}from"node:module";import{isAccessibleSync as se,isFsCaseSensitive as je}from"@visulima/fs";import{isAbsolute as Fe,join as X,relative as D,basename as ve}from"@visulima/path";import{execa as ye}from"execa";import{o as ke}from"../packem_shared/index-DH-5hsrC.js";import{jsx as b,jsxs as C}from"react/jsx-runtime";import{Spinner as Ge,Text as $,Box as A,render as _e}from"@visulima/tui";import{C as be,D as B,T as Te}from"../packem_shared/symbols-CQmER5MT.js";import{dim as I,green as De,yellow as ne,cyan as K,red as Y}from"@visulima/colorize";const Me=Ae(import.meta.url),F=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,ee=f(e=>{if(typeof F<"u"&&F.versions&&F.versions.node){const[t,r]=F.versions.node.split(".").map(Number);if(t>22||t===22&&r>=3||t===20&&r>=16)return F.getBuiltinModule(e)}return Me(e)},"__cjs_getBuiltinModule"),{readFileSync:Oe,writeFileSync:Pe,unlinkSync:Re}=ee("node:fs"),{randomBytes:Ne}=ee("node:crypto"),{availableParallelism:ae}=ee("node:os");var He=Object.defineProperty,Le=f((e,t)=>He(e,"name",{value:t,configurable:!0}),"s$4");class O extends Error{static{f(this,"StagedError")}static{Le(this,"StagedError")}constructor(t,r){super(t,r),this.name=this.constructor.name}}var Be=Object.defineProperty,Ue=f((e,t)=>Be(e,"name",{value:t,configurable:!0}),"o$6");class qe extends O{static{f(this,"ApplyEmptyCommitError")}static{Ue(this,"ApplyEmptyCommitError")}}var Ve=Object.defineProperty,ze=f((e,t)=>Ve(e,"name",{value:t,configurable:!0}),"o$5");class T extends O{static{f(this,"ConfigError")}static{ze(this,"ConfigError")}}var We=Object.defineProperty,Ke=f((e,t)=>We(e,"name",{value:t,configurable:!0}),"t$1");class ie extends O{static{f(this,"GetBackupStashError")}static{Ke(this,"GetBackupStashError")}}var Ye=Object.defineProperty,Je=f((e,t)=>Ye(e,"name",{value:t,configurable:!0}),"s$3");class _ extends O{static{f(this,"GitError")}static{Je(this,"GitError")}stderr;constructor(t,r,n){super(t,n),this.stderr=r}}var Qe=Object.defineProperty,Xe=f((e,t)=>Qe(e,"name",{value:t,configurable:!0}),"e");class oe extends O{static{f(this,"RestoreOriginalStateError")}static{Xe(this,"RestoreOriginalStateError")}}var Ze=Object.defineProperty,et=f((e,t)=>Ze(e,"name",{value:t,configurable:!0}),"o$2");class M extends O{static{f(this,"TaskError")}static{et(this,"TaskError")}commandTitle;constructor(t,r,n){super(r,n),this.commandTitle=t}}var tt=Object.defineProperty,q=f((e,t)=>tt(e,"name",{value:t,configurable:!0}),"i");const rt=q(async e=>{if(e.config!==void 0)return e.config;throw new T(`No staged config provided. Add \`staged\` to your vis.config.ts:
 
-const __cjs_require = __cjs_createRequire(import.meta.url);
+  import { defineConfig } from "@visulima/vis/config";
 
-const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
-
-const __cjs_getBuiltinModule = (module) => {
-    // Check if we're in Node.js and version supports getBuiltinModule
-    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
-        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
-        // Node.js 20.16.0+ and 22.3.0+
-        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
-            return __cjs_getProcess.getBuiltinModule(module);
-        }
-    }
-    // Fallback to createRequire
-    return __cjs_require(module);
-};
-
-import { isAccessibleSync, isFsCaseSensitive } from '@visulima/fs';
-const {
-  readFileSync,
-  writeFileSync,
-  unlinkSync
-} = __cjs_getBuiltinModule("node:fs");
-import { isAbsolute, join, relative, basename } from '@visulima/path';
-import { execa } from 'execa';
-import zeptomatch from 'zeptomatch';
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { render, Box, Text, Spinner } from '@visulima/tui';
-import { C as CROSS, D as DASH, T as TICK } from '../packem_shared/symbols-Ta7g2nU-.js';
-import { yellow, dim, cyan, red, green } from '@visulima/colorize';
-const {
-  availableParallelism
-} = __cjs_getBuiltinModule("node:os");
-
-class StagedError extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = this.constructor.name;
-  }
-}
-
-class ApplyEmptyCommitError extends StagedError {
-}
-
-class ConfigError extends StagedError {
-}
-
-class GetBackupStashError extends StagedError {
-}
-
-class GitError extends StagedError {
-  stderr;
-  constructor(message, stderr, options) {
-    super(message, options);
-    this.stderr = stderr;
-  }
-}
-
-class RestoreOriginalStateError extends StagedError {
-}
-
-class TaskError extends StagedError {
-  commandTitle;
-  constructor(commandTitle, message, options) {
-    super(message, options);
-    this.commandTitle = commandTitle;
-  }
-}
-
-const resolveConfig = async (options) => {
-  if (options.config !== void 0) {
-    return options.config;
-  }
-  throw new ConfigError(
-    'No staged config provided. Add `staged` to your vis.config.ts:\n\n  import { defineConfig } from "@visulima/vis/config";\n\n  export default defineConfig({\n    staged: { "*.ts": "eslint --fix" },\n  });\n\nComing from lint-staged or nano-staged? Run `vis migrate lint-staged` (or `vis migrate nano-staged`) to move the config in and remove the legacy files.'
-  );
-};
-const validateConfig = (config) => {
-  if (typeof config !== "object" || config === null) {
-    throw new ConfigError("Staged config must be an object mapping glob patterns to tasks.");
-  }
-  const entries = Object.entries(config);
-  if (entries.length === 0) {
-    throw new ConfigError("Staged config is empty — at least one glob pattern is required.");
-  }
-  for (const [pattern, value] of entries) {
-    if (!pattern || pattern.trim() === "") {
-      throw new ConfigError("Staged config keys must be non-empty glob patterns.");
-    }
-    validateTask(pattern, value);
-  }
-  return config;
-};
-const validateTask = (pattern, value) => {
-  if (typeof value === "string") {
-    if (value.trim() === "") {
-      throw new ConfigError(`Task for "${pattern}" is an empty string.`);
-    }
-    return;
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      throw new ConfigError(`Task array for "${pattern}" is empty.`);
-    }
-    for (const item of value) {
-      validateTask(pattern, item);
-    }
-    return;
-  }
-  if (typeof value === "function") {
-    return;
-  }
-  if (isCustomTask$1(value)) {
-    return;
-  }
-  throw new ConfigError(`Invalid task for "${pattern}" — expected string, string[], function, or { title, task } object.`);
-};
-const isCustomTask$1 = (value) => typeof value === "object" && value !== null && typeof value.title === "string" && typeof value.task === "function";
-
-const MAX_STDERR_PREVIEW = 2048;
-const git = async (args, options) => {
-  const result = await execa("git", [...args], {
-    cwd: options.cwd,
-    env: options.env ? { ...process.env, ...options.env } : void 0,
-    input: options.input,
-    reject: false,
-    stderr: "pipe",
-    stdin: options.input === void 0 ? "ignore" : "pipe",
-    stdout: "pipe"
+  export default defineConfig({
+    staged: { "*.ts": "eslint --fix" },
   });
-  const exitCode = typeof result.exitCode === "number" ? result.exitCode : 1;
-  if (exitCode !== 0 && !options.lenient) {
-    const stderr = typeof result.stderr === "string" ? result.stderr : "";
-    const preview = stderr.length > MAX_STDERR_PREVIEW ? `${stderr.slice(0, MAX_STDERR_PREVIEW)}…` : stderr;
-    throw new GitError(`git ${args.join(" ")} failed with exit code ${exitCode}: ${preview.trim()}`, stderr);
-  }
-  return {
-    exitCode,
-    stderr: typeof result.stderr === "string" ? result.stderr : "",
-    stdout: typeof result.stdout === "string" ? result.stdout : ""
-  };
-};
-const gitOut = async (args, options) => {
-  const { stdout } = await git(args, options);
-  return stdout.trim();
-};
-const isGitRepo = async (cwd) => {
-  const result = await git(["rev-parse", "--is-inside-work-tree"], { cwd, lenient: true });
-  return result.exitCode === 0 && result.stdout.trim() === "true";
-};
-const getGitDirectory = async (cwd) => gitOut(["rev-parse", "--absolute-git-dir"], { cwd });
-const getWorkTree = async (cwd) => gitOut(["rev-parse", "--show-toplevel"], { cwd });
-const writeIndexTree = async (cwd) => gitOut(["write-tree"], { cwd });
-const headTreeSha = async (cwd) => {
-  const result = await git(["rev-parse", "HEAD^{tree}"], { cwd, lenient: true });
-  return result.exitCode === 0 ? result.stdout.trim() : "";
-};
-const MIN_GIT_VERSION = { major: 2, minor: 32 };
-const parseGitVersion = (output) => {
-  const match = /git version (\d+)\.(\d+)/.exec(output);
-  if (!match) {
-    return null;
-  }
-  const major = Number.parseInt(match[1] ?? "", 10);
-  const minor = Number.parseInt(match[2] ?? "", 10);
-  if (Number.isNaN(major) || Number.isNaN(minor)) {
-    return null;
-  }
-  return { major, minor };
-};
-const assertGitVersion = async (cwd) => {
-  const version = parseGitVersion(await gitOut(["--version"], { cwd }));
-  if (version === null) {
-    return;
-  }
-  const tooOld = version.major < MIN_GIT_VERSION.major || version.major === MIN_GIT_VERSION.major && version.minor < MIN_GIT_VERSION.minor;
-  if (tooOld) {
-    throw new GitError(`Git ${MIN_GIT_VERSION.major}.${MIN_GIT_VERSION.minor} or newer is required; found ${version.major}.${version.minor}.`);
-  }
-};
-
-const DEFAULT_DIFF_FILTER = "ACMR";
-const PATH_BATCH_SIZE = 500;
-const getIntentToAddPaths = async (cwd) => {
-  const { stdout } = await git(["diff-files", "--raw", "-z"], { cwd });
-  const tokens = stdout.split("\0").filter((token) => token.length > 0);
-  const paths = [];
-  for (let i = 0; i < tokens.length; i += 1) {
-    const header = tokens[i];
-    if (!header?.startsWith(":")) {
-      continue;
-    }
-    const parts = header.slice(1).split(" ");
-    const dstSha = parts[3];
-    const status = parts[4];
-    const path = tokens[i + 1];
-    i += 1;
-    if (status === "A" && dstSha !== void 0 && /^0+$/.test(dstSha) && path !== void 0) {
-      paths.push(path);
-    }
-  }
-  return paths;
-};
-const getUntrackedFiles = async (cwd) => {
-  const { stdout } = await git(["ls-files", "--others", "--exclude-standard", "-z"], { cwd });
-  return stdout.split("\0").filter((path) => path.length > 0);
-};
-const removeFromIndex = async (paths, options) => {
-  if (paths.length === 0) {
-    return;
-  }
-  const pathspec = `${paths.join("\0")}\0`;
-  await git(["rm", "--cached", "--quiet", "--pathspec-from-file=-", "--pathspec-file-nul", "--"], { cwd: options.cwd, input: pathspec });
-};
-const getFiles = async (options) => {
-  const filter = options.diffFilter ?? DEFAULT_DIFF_FILTER;
-  const args = options.diff === void 0 ? ["diff", "--name-only", "-z", `--diff-filter=${filter}`, "--staged"] : ["diff", "--name-only", "-z", `--diff-filter=${filter}`, ...options.diff.split(/\s+/).filter(Boolean)];
-  const { stdout } = await git(args, { cwd: options.cwd });
-  const relativePaths = stdout.split("\0").filter((path) => path.length > 0);
-  if (relativePaths.length === 0) {
-    return [];
-  }
-  const worktree = options.workTree ?? await getWorkTree(options.cwd);
-  return relativePaths.map((p) => isAbsolute(p) ? p : join(worktree, p));
-};
-const capturePatch = async (paths, options) => {
-  if (paths.length === 0) {
-    return null;
-  }
-  const fragments = [];
-  for (let start = 0; start < paths.length; start += PATH_BATCH_SIZE) {
-    const batch = paths.slice(start, start + PATH_BATCH_SIZE);
-    const { stdout } = await git(
-      [
-        "diff",
-        "--binary",
-        "--unified=0",
-        "--no-color",
-        "--no-ext-diff",
-        "--src-prefix=a/",
-        "--dst-prefix=b/",
-        "--patch",
-        "--submodule=short",
-        "--",
-        ...batch
-      ],
-      { cwd: options.cwd }
-    );
-    if (stdout.length > 0) {
-      fragments.push(stdout);
-    }
-  }
-  if (fragments.length === 0) {
-    return null;
-  }
-  const combined = fragments.join("");
-  const normalized = combined.endsWith("\n") ? combined : `${combined}
-`;
-  return Buffer.from(normalized, "utf8");
-};
-const getPartiallyStagedFiles = async (cwd) => {
-  const { stdout } = await git(["status", "--porcelain=v1", "-z"], { cwd });
-  const records = stdout.split("\0");
-  const partial = [];
-  for (let i = 0; i < records.length; i += 1) {
-    const record = records[i];
-    if (record === void 0 || record.length < 4) {
-      continue;
-    }
-    const indexState = record.charAt(0);
-    const worktreeState = record.charAt(1);
-    const path = record.slice(3);
-    const consumesNextRecord = indexState === "R" || indexState === "C" || worktreeState === "R" || worktreeState === "C";
-    if (indexState !== " " && indexState !== "?" && worktreeState !== " " && worktreeState !== "?") {
-      partial.push(path);
-    }
-    if (consumesNextRecord) {
-      i += 1;
-    }
-  }
-  return partial;
-};
-const checkoutPaths = async (paths, options) => {
-  if (paths.length === 0) {
-    return;
-  }
-  const pathspec = `${paths.join("\0")}\0`;
-  await git(["checkout", "--force", "--pathspec-from-file=-", "--pathspec-file-nul", "--"], { cwd: options.cwd, input: pathspec });
-};
-const updateIndexAgain = async (paths, options) => {
-  await git(["update-index", "--again"], { cwd: options.cwd, lenient: true });
-  if (paths.length === 0) {
-    return;
-  }
-  const pathspec = `${paths.join("\0")}\0`;
-  await git(["add", "-u", "--pathspec-from-file=-", "--pathspec-file-nul", "--"], { cwd: options.cwd, input: pathspec });
-};
 
-const STASH_MESSAGE_PREFIX = "vis_staged_automatic_backup";
-const buildMessage = () => `${STASH_MESSAGE_PREFIX}-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-const createBackupStash = async (cwd) => {
-  const sha = await gitOut(["stash", "create"], { cwd });
-  if (sha.length === 0) {
-    return null;
-  }
-  await git(["stash", "store", "-m", buildMessage(), sha], { cwd });
-  return sha;
-};
-const createHideAllStash = async (cwd) => {
-  const message = buildMessage();
-  const { exitCode, stdout } = await git(["stash", "push", "--keep-index", "--include-untracked", "--quiet", "-m", message], { cwd, lenient: true });
-  if (exitCode !== 0) {
-    return null;
-  }
-  const note = stdout.trim();
-  if (note.length > 0 && /no local changes/i.test(note)) {
-    return null;
-  }
-  return gitOut(["rev-parse", "stash@{0}"], { cwd });
-};
-const findStashRefBySha = async (cwd, sha) => {
-  const { exitCode, stdout } = await git(["reflog", "--format=%H %gd", "refs/stash"], { cwd, lenient: true });
-  if (exitCode !== 0) {
-    return null;
-  }
-  for (const line of stdout.split(/\r?\n/)) {
-    const [entrySha, ref] = line.split(/\s+/, 2);
-    if (entrySha === sha && ref !== void 0) {
-      return ref;
-    }
-  }
-  return null;
-};
-const dropBackupStash = async (cwd, sha) => {
-  if (sha === null) {
-    return;
-  }
-  const reference = await findStashRefBySha(cwd, sha);
-  if (reference === null) {
-    return;
-  }
-  await git(["stash", "drop", "--quiet", reference], { cwd });
-};
-const applyBackupStash = async (cwd, sha) => {
-  if (sha === null) {
-    throw new GetBackupStashError("Backup stash was not found — can't revert working tree.");
-  }
-  const reference = await findStashRefBySha(cwd, sha);
-  if (reference === null) {
-    throw new GetBackupStashError(`Backup stash ${sha} is no longer reachable — can't revert working tree.`);
-  }
-  await git(["reset", "--hard", "HEAD"], { cwd });
-  await git(["stash", "apply", "--index", "--quiet", reference], { cwd });
-};
-const popHideAllStash = async (cwd, sha) => {
-  if (sha === null) {
-    return;
-  }
-  const reference = await findStashRefBySha(cwd, sha);
-  if (reference === null) {
-    return;
-  }
-  await git(["stash", "pop", "--quiet", reference], { cwd });
-};
-
-class GitWorkflow {
-  stagedFiles = [];
-  partiallyStaged = [];
-  workTree = "";
-  gitDir = "";
-  /** Index tree sha captured at the end of `prepare()`, before tasks run. */
-  preTaskIndexTree = "";
-  /** Index tree sha captured at the end of `applyModifications()`, after tasks' in-place edits are staged. */
-  postTaskIndexTree = "";
-  /** HEAD tree sha captured in `prepare()` — used to detect empty-after-revert commits. */
-  headTree = "";
-  /** Becomes true after a successful `revert()` so the caller can skip the unstaged-patch re-apply that would duplicate the restored deltas. */
-  revertApplied = false;
-  /** Emitted by `prepare()` when we skip the backup stash but still have partially-staged files — the caller can surface this to the user. */
-  warnings = [];
-  cwd;
-  options;
-  patch = null;
-  backupStashSha = null;
-  merge = [];
-  shouldStash;
-  shouldHidePartial;
-  shouldHideUnstaged;
-  shouldHideAll;
-  /** Sha of the hide-all push stash (if `--hide-all` is set), tracked separately from the create+store backup. */
-  hideAllStashSha = null;
-  /** Paths that were `git add -N`'d (intent-to-add) — removed from the index before stashing, restored after. */
-  intentToAddPaths = [];
-  /** Untracked files observed at the end of `prepare()`. Diffed post-run to detect task-created files for `--autoStage`. */
-  preTaskUntracked = /* @__PURE__ */ new Set();
-  constructor(options) {
-    this.cwd = options.cwd ?? process.cwd();
-    this.options = options;
-    this.shouldStash = options.stash !== false && options.diff === void 0;
-    this.shouldHidePartial = options.hidePartiallyStaged !== false;
-    this.shouldHideUnstaged = options.hideUnstaged === true;
-    this.shouldHideAll = options.hideAll === true;
-  }
-  async prepare() {
-    if (!await isGitRepo(this.cwd)) {
-      throw new GitError(`Not a git repository: ${this.cwd}`);
-    }
-    await assertGitVersion(this.cwd);
-    this.workTree = await getWorkTree(this.cwd);
-    this.gitDir = await getGitDirectory(this.cwd);
-    this.stagedFiles = await getFiles({ cwd: this.cwd, diff: this.options.diff, diffFilter: this.options.diffFilter, workTree: this.workTree });
-    this.partiallyStaged = this.stagedFiles.length === 0 ? [] : await getPartiallyStagedFiles(this.cwd);
-    this.snapshotMergeState();
-    this.intentToAddPaths = await getIntentToAddPaths(this.workTree);
-    if (this.intentToAddPaths.length > 0) {
-      await removeFromIndex(this.intentToAddPaths, { cwd: this.workTree });
-    }
-    if (this.shouldStash) {
-      this.backupStashSha = await createBackupStash(this.workTree);
-    } else if (this.partiallyStaged.length > 0) {
-      this.warnings.push(
-        "Running with --no-stash on partially-staged files — unstaged deltas will be captured to a patch, but if re-applying the patch fails after tasks run the changes cannot be recovered."
-      );
-    }
-    if (this.shouldHideAll) {
-      this.hideAllStashSha = await createHideAllStash(this.workTree);
-    } else {
-      await this.hideUnstagedChanges();
-    }
-    this.preTaskIndexTree = this.stagedFiles.length === 0 ? "" : await writeIndexTree(this.workTree);
-    this.postTaskIndexTree = this.preTaskIndexTree;
-    this.headTree = await headTreeSha(this.workTree);
-    this.preTaskUntracked = new Set(await getUntrackedFiles(this.workTree));
-  }
-  /**
-   * Refreshes the index against the working tree, so task edits
-   * (including deletions of already-tracked files) are re-staged.
-   * Uses `git update-index --again` for parity with lint-staged v17,
-   * which behaves correctly when the original commit used a pathspec.
-   */
-  async applyModifications({ autoStage = false } = {}) {
-    if (this.stagedFiles.length === 0) {
-      return;
-    }
-    const worktreeRelative = this.stagedFiles.map((path) => relative(this.workTree, path));
-    await updateIndexAgain(worktreeRelative, { cwd: this.workTree });
-    if (autoStage) {
-      const postUntracked = await getUntrackedFiles(this.workTree);
-      const newFiles = postUntracked.filter((path) => !this.preTaskUntracked.has(path));
-      if (newFiles.length > 0) {
-        const pathspec = `${newFiles.join("\0")}\0`;
-        await git(["add", "--pathspec-from-file=-", "--pathspec-file-nul", "--"], { cwd: this.workTree, input: pathspec });
-      }
-    }
-    if (this.intentToAddPaths.length > 0) {
-      try {
-        await git(["add", "--intent-to-add", "--", ...this.intentToAddPaths], { cwd: this.workTree });
-      } catch {
-      }
-    }
-    this.postTaskIndexTree = await writeIndexTree(this.workTree);
-  }
-  /** True when tasks modified at least one staged file's content (index tree changed). */
-  indexTreeChanged() {
-    return this.preTaskIndexTree.length > 0 && this.postTaskIndexTree.length > 0 && this.preTaskIndexTree !== this.postTaskIndexTree;
-  }
-  /** True when the post-task index tree matches HEAD — i.e. tasks reverted every staged change. */
-  postTaskIndexMatchesHead() {
-    return this.postTaskIndexTree.length > 0 && this.headTree.length > 0 && this.postTaskIndexTree === this.headTree;
-  }
-  /**
-   * Re-applies the hidden unstaged patch. Falls back to 3-way on conflict.
-   * Skips silently when `revert()` already restored the working tree from the backup stash,
-   * since the stash already carries those deltas and re-applying would duplicate them.
-   * When `--hide-all` is active this is also a no-op — the `popHideAllStash()` call in
-   * `cleanup()` handles restore for that mode.
-   */
-  async restoreUnstagedChanges() {
-    if (this.revertApplied || this.patch === null || this.shouldHideAll) {
-      return;
-    }
-    const applyArguments = ["apply", "--whitespace=nowarn", "--recount", "--unidiff-zero"];
-    let firstError;
-    try {
-      await git(applyArguments, { cwd: this.workTree, input: this.patch });
-      return;
-    } catch (error) {
-      firstError = error instanceof GitError ? error.stderr : String(error);
-    }
-    try {
-      await git([...applyArguments, "--3way"], { cwd: this.workTree, input: this.patch });
-    } catch (error) {
-      const detail = error instanceof GitError && error.stderr ? error.stderr : String(error);
-      throw new RestoreOriginalStateError(
-        `Failed to re-apply unstaged changes after running tasks. Original changes remain in the backup stash — recover with \`git stash list\` and \`git stash apply\`.
-First attempt: ${firstError ?? "(no stderr)"}
-Second attempt: ${detail}`,
-        { cause: error }
-      );
-    }
-  }
-  /** Restores index + working tree from the backup stash and drops it. */
-  async revert() {
-    if (this.backupStashSha === null) {
-      return;
-    }
-    try {
-      await applyBackupStash(this.workTree, this.backupStashSha);
-    } catch (error) {
-      throw new RestoreOriginalStateError("Revert failed while restoring the backup stash. Use `git stash list` to recover manually.", {
-        cause: error
-      });
-    }
-    await dropBackupStash(this.workTree, this.backupStashSha);
-    if (this.intentToAddPaths.length > 0) {
-      try {
-        await git(["add", "--intent-to-add", "--", ...this.intentToAddPaths], { cwd: this.workTree });
-      } catch {
-      }
-    }
-    this.revertApplied = true;
-  }
-  /**
-   * On success, drops the backup stash and pops the hide-all stash (if any).
-   * On failure without --revert, leaves the backup stash in place so the
-   * user can recover manually.
-   */
-  async cleanup(success) {
-    this.restoreMergeState();
-    if (this.hideAllStashSha !== null) {
-      try {
-        await popHideAllStash(this.workTree, this.hideAllStashSha);
-      } catch {
-      }
-    }
-    if (success && this.backupStashSha !== null && !this.revertApplied) {
-      await dropBackupStash(this.workTree, this.backupStashSha);
-    }
-  }
-  /**
-   * Returns a user-facing hint that points at the backup stash when
-   * tasks failed and we kept it around (no --revert).
-   */
-  recoveryHint() {
-    if (this.backupStashSha === null) {
-      return null;
-    }
-    return `Backup stash is preserved (sha ${this.backupStashSha.slice(0, 7)}) — restore with: git stash apply --index ${this.backupStashSha}`;
-  }
-  async hideUnstagedChanges() {
-    const stagedRelative = new Set(this.stagedFiles.map((path) => relative(this.workTree, path)));
-    const candidatesRelative = this.shouldHideUnstaged ? [...stagedRelative] : this.shouldHidePartial ? this.partiallyStaged.filter((path) => stagedRelative.has(path)) : [];
-    if (candidatesRelative.length === 0) {
-      return;
-    }
-    this.patch = await capturePatch(candidatesRelative, { cwd: this.workTree });
-    if (this.patch === null) {
-      return;
-    }
-    await checkoutPaths(candidatesRelative, { cwd: this.workTree });
-  }
-  snapshotMergeState() {
-    if (this.gitDir.length === 0) {
-      return;
-    }
-    this.merge = ["MERGE_HEAD", "MERGE_MODE", "MERGE_MSG"].map((name) => {
-      const target = join(this.gitDir, name);
-      if (isAccessibleSync(target)) {
-        return { body: readFileSync(target), existed: true, name };
-      }
-      return { body: null, existed: false, name };
-    });
-  }
-  restoreMergeState() {
-    if (this.gitDir.length === 0 || this.merge.length === 0) {
-      return;
-    }
-    for (const entry of this.merge) {
-      const target = join(this.gitDir, entry.name);
-      try {
-        if (entry.existed && entry.body !== null) {
-          writeFileSync(target, entry.body);
-        } else if (isAccessibleSync(target)) {
-          unlinkSync(target);
-        }
-      } catch {
-      }
-    }
-  }
-}
-
-const isPathStyle = (pattern) => pattern.includes("/");
-const normalizeForMatch = (value, caseInsensitive) => caseInsensitive ? value.toLowerCase() : value;
-const matchFiles = (pattern, files, cwd, options = {}) => {
-  const pathStyle = isPathStyle(pattern);
-  const caseInsensitive = options.caseInsensitive === true;
-  const effectivePattern = normalizeForMatch(pattern, caseInsensitive);
-  const matched = [];
-  for (const absolute of files) {
-    const candidate = pathStyle ? relative(cwd, absolute) : basename(absolute);
-    if (zeptomatch(effectivePattern, normalizeForMatch(candidate, caseInsensitive))) {
-      matched.push(absolute);
-    }
-  }
-  return matched;
-};
-const applyIgnore = (files, ignore, cwd, options = {}) => {
-  if (!ignore || ignore.length === 0) {
-    return [...files];
-  }
-  const caseInsensitive = options.caseInsensitive === true;
-  return files.filter((absolute) => {
-    for (const pattern of ignore) {
-      const candidate = isPathStyle(pattern) ? relative(cwd, absolute) : basename(absolute);
-      const effectivePattern = normalizeForMatch(pattern, caseInsensitive);
-      if (zeptomatch(effectivePattern, normalizeForMatch(candidate, caseInsensitive))) {
-        return false;
-      }
-    }
-    return true;
+Coming from lint-staged or nano-staged? Run \`vis migrate lint-staged\` (or \`vis migrate nano-staged\`) to move the config in and remove the legacy files.`)},"resolveConfig"),ce=q(e=>{if(typeof e!="object"||e===null)throw new T("Staged config must be an object mapping glob patterns to tasks.");const t=Object.entries(e);if(t.length===0)throw new T("Staged config is empty — at least one glob pattern is required.");for(const[r,n]of t){if(!r||r.trim()==="")throw new T("Staged config keys must be non-empty glob patterns.");Se(r,n)}return e},"validateConfig"),Se=q((e,t)=>{if(typeof t=="string"){if(t.trim()==="")throw new T(`Task for "${e}" is an empty string.`);return}if(Array.isArray(t)){if(t.length===0)throw new T(`Task array for "${e}" is empty.`);for(const r of t)Se(e,r);return}if(typeof t!="function"&&!st(t))throw new T(`Invalid task for "${e}" — expected string, string[], function, or { title, task } object.`)},"validateTask"),st=q(e=>typeof e=="object"&&e!==null&&typeof e.title=="string"&&typeof e.task=="function","isCustomTask");var nt=Object.defineProperty,x=f((e,t)=>nt(e,"name",{value:t,configurable:!0}),"n$1");const de=2048,g=x(async(e,t)=>{const r=await ye("git",[...e],{cwd:t.cwd,env:t.env?{...process.env,...t.env}:void 0,input:t.input,reject:!1,stderr:"pipe",stdin:t.input===void 0?"ignore":"pipe",stdout:"pipe"}),n=typeof r.exitCode=="number"?r.exitCode:1;if(n!==0&&!t.lenient){const s=typeof r.stderr=="string"?r.stderr:"",i=s.length>de?`${s.slice(0,de)}…`:s;throw new _(`git ${e.join(" ")} failed with exit code ${n}: ${i.trim()}`,s)}return{exitCode:n,stderr:typeof r.stderr=="string"?r.stderr:"",stdout:typeof r.stdout=="string"?r.stdout:""}},"git"),R=x(async(e,t)=>{const{stdout:r}=await g(e,t);return r.trim()},"gitOut"),at=x(async e=>{const t=await g(["rev-parse","--is-inside-work-tree"],{cwd:e,lenient:!0});return t.exitCode===0&&t.stdout.trim()==="true"},"isGitRepo"),it=x(async e=>R(["rev-parse","--absolute-git-dir"],{cwd:e}),"getGitDirectory"),$e=x(async e=>R(["rev-parse","--show-toplevel"],{cwd:e}),"getWorkTree"),le=x(async e=>R(["write-tree"],{cwd:e}),"writeIndexTree"),ot=x(async e=>{const t=await g(["rev-parse","HEAD^{tree}"],{cwd:e,lenient:!0});return t.exitCode===0?t.stdout.trim():""},"headTreeSha"),N={major:2,minor:32},ct=x(e=>{const t=/git version (\d+)\.(\d+)/.exec(e);if(!t)return null;const r=Number.parseInt(t[1]??"",10),n=Number.parseInt(t[2]??"",10);return Number.isNaN(r)||Number.isNaN(n)?null:{major:r,minor:n}},"parseGitVersion"),dt=x(async e=>{const t=ct(await R(["--version"],{cwd:e}));if(t!==null&&(t.major<N.major||t.major===N.major&&t.minor<N.minor))throw new _(`Git ${N.major}.${N.minor} or newer is required; found ${t.major}.${t.minor}.`)},"assertGitVersion");var lt=Object.defineProperty,E=f((e,t)=>lt(e,"name",{value:t,configurable:!0}),"a$2");const ut="ACMR",ue=500,ft=E(async e=>{const{stdout:t}=await g(["diff-files","--raw","-z"],{cwd:e}),r=t.split("\0").filter(s=>s.length>0),n=[];for(let s=0;s<r.length;s+=1){const i=r[s];if(!i?.startsWith(":"))continue;const o=i.slice(1).split(" "),a=o[3],c=o[4],l=r[s+1];s+=1,c==="A"&&a!==void 0&&/^0+$/.test(a)&&l!==void 0&&n.push(l)}return n},"getIntentToAddPaths"),fe=E(async e=>{const{stdout:t}=await g(["ls-files","--others","--exclude-standard","-z"],{cwd:e});return t.split("\0").filter(r=>r.length>0)},"getUntrackedFiles"),ht=E(async(e,t)=>{if(e.length===0)return;const r=`${e.join("\0")}\0`;await g(["rm","--cached","--quiet","--pathspec-from-file=-","--pathspec-file-nul","--"],{cwd:t.cwd,input:r})},"removeFromIndex"),pt=E(async e=>{const t=e.diffFilter??ut,r=e.diff===void 0?["diff","--name-only","-z",`--diff-filter=${t}`,"--staged"]:["diff","--name-only","-z",`--diff-filter=${t}`,...e.diff.split(/\s+/).filter(Boolean)],{stdout:n}=await g(r,{cwd:e.cwd}),s=n.split("\0").filter(o=>o.length>0);if(s.length===0)return[];const i=e.workTree??await $e(e.cwd);return s.map(o=>Fe(o)?o:X(i,o))},"getFiles"),gt=E(async(e,t)=>{if(e.length===0)return null;const r=[];for(let i=0;i<e.length;i+=ue){const o=e.slice(i,i+ue),{stdout:a}=await g(["diff","--binary","--unified=0","--no-color","--no-ext-diff","--src-prefix=a/","--dst-prefix=b/","--patch","--submodule=short","--",...o],{cwd:t.cwd});a.length>0&&r.push(a)}if(r.length===0)return null;const n=r.join(""),s=n.endsWith(`
+`)?n:`${n}
+`;return Buffer.from(s,"utf8")},"capturePatch"),mt=E(async e=>{const{stdout:t}=await g(["status","--porcelain=v1","-z"],{cwd:e}),r=t.split("\0"),n=[];for(let s=0;s<r.length;s+=1){const i=r[s];if(i===void 0||i.length<4)continue;const o=i.charAt(0),a=i.charAt(1),c=i.slice(3),l=o==="R"||o==="C"||a==="R"||a==="C";o!==" "&&o!=="?"&&a!==" "&&a!=="?"&&n.push(c),l&&(s+=1)}return n},"getPartiallyStagedFiles"),wt=E(async(e,t)=>{if(e.length===0)return;const r=`${e.join("\0")}\0`;await g(["checkout","--force","--pathspec-from-file=-","--pathspec-file-nul","--"],{cwd:t.cwd,input:r})},"checkoutPaths"),vt=E(async(e,t)=>{if(await g(["update-index","--again"],{cwd:t.cwd,lenient:!0}),e.length===0)return;const r=`${e.join("\0")}\0`;await g(["add","-u","--pathspec-from-file=-","--pathspec-file-nul","--"],{cwd:t.cwd,input:r})},"updateIndexAgain");var yt=Object.defineProperty,P=f((e,t)=>yt(e,"name",{value:t,configurable:!0}),"r$1");const kt="vis_staged_automatic_backup",xe=P(()=>`${kt}-${process.pid}-${Date.now()}-${Ne(3).toString("hex")}`,"buildMessage"),bt=P(async e=>{const t=await R(["stash","create"],{cwd:e});return t.length===0?null:(await g(["stash","store","-m",xe(),t],{cwd:e}),t)},"createBackupStash"),Tt=P(async e=>{const t=xe(),{exitCode:r,stdout:n}=await g(["stash","push","--keep-index","--include-untracked","--quiet","-m",t],{cwd:e,lenient:!0});if(r!==0)return null;const s=n.trim();return s.length>0&&/no local changes/i.test(s)?null:R(["rev-parse","stash@{0}"],{cwd:e})},"createHideAllStash"),te=P(async(e,t)=>{const{exitCode:r,stdout:n}=await g(["reflog","--format=%H %gd","refs/stash"],{cwd:e,lenient:!0});if(r!==0)return null;for(const s of n.split(/\r?\n/)){const[i,o]=s.split(/\s+/,2);if(i===t&&o!==void 0)return o}return null},"findStashRefBySha"),he=P(async(e,t)=>{if(t===null)return;const r=await te(e,t);r!==null&&await g(["stash","drop","--quiet",r],{cwd:e})},"dropBackupStash"),St=P(async(e,t)=>{if(t===null)throw new ie("Backup stash was not found — can't revert working tree.");const r=await te(e,t);if(r===null)throw new ie(`Backup stash ${t} is no longer reachable — can't revert working tree.`);await g(["reset","--hard","HEAD"],{cwd:e}),await g(["stash","apply","--index","--quiet",r],{cwd:e})},"applyBackupStash"),$t=P(async(e,t)=>{if(t===null)return;const r=await te(e,t);r!==null&&await g(["stash","pop","--quiet",r],{cwd:e})},"popHideAllStash");var xt=Object.defineProperty,Ct=f((e,t)=>xt(e,"name",{value:t,configurable:!0}),"l");class It{static{f(this,"GitWorkflow")}static{Ct(this,"GitWorkflow")}stagedFiles=[];partiallyStaged=[];workTree="";gitDir="";preTaskIndexTree="";postTaskIndexTree="";headTree="";revertApplied=!1;warnings=[];cwd;options;patch=null;backupStashSha=null;merge=[];shouldStash;shouldHidePartial;shouldHideUnstaged;shouldHideAll;hideAllStashSha=null;intentToAddPaths=[];preTaskUntracked=new Set;constructor(t){this.cwd=t.cwd??process.cwd(),this.options=t,this.shouldStash=t.stash!==!1&&t.diff===void 0,this.shouldHidePartial=t.hidePartiallyStaged!==!1,this.shouldHideUnstaged=t.hideUnstaged===!0,this.shouldHideAll=t.hideAll===!0}async prepare(){if(!await at(this.cwd))throw new _(`Not a git repository: ${this.cwd}`);await dt(this.cwd),this.workTree=await $e(this.cwd),this.gitDir=await it(this.cwd),this.stagedFiles=await pt({cwd:this.cwd,diff:this.options.diff,diffFilter:this.options.diffFilter,workTree:this.workTree}),this.partiallyStaged=this.stagedFiles.length===0?[]:await mt(this.cwd),this.snapshotMergeState(),this.intentToAddPaths=await ft(this.workTree),this.intentToAddPaths.length>0&&await ht(this.intentToAddPaths,{cwd:this.workTree}),this.shouldStash?this.backupStashSha=await bt(this.workTree):this.partiallyStaged.length>0&&this.warnings.push("Running with --no-stash on partially-staged files — unstaged deltas will be captured to a patch, but if re-applying the patch fails after tasks run the changes cannot be recovered."),this.shouldHideAll?this.hideAllStashSha=await Tt(this.workTree):await this.hideUnstagedChanges(),this.preTaskIndexTree=this.stagedFiles.length===0?"":await le(this.workTree),this.postTaskIndexTree=this.preTaskIndexTree,this.headTree=await ot(this.workTree),this.preTaskUntracked=new Set(await fe(this.workTree))}async applyModifications({autoStage:t=!1}={}){if(this.stagedFiles.length===0)return;const r=this.stagedFiles.map(n=>D(this.workTree,n));if(await vt(r,{cwd:this.workTree}),t){const n=(await fe(this.workTree)).filter(s=>!this.preTaskUntracked.has(s));if(n.length>0){const s=`${n.join("\0")}\0`;await g(["add","--pathspec-from-file=-","--pathspec-file-nul","--"],{cwd:this.workTree,input:s})}}if(this.intentToAddPaths.length>0)try{await g(["add","--intent-to-add","--",...this.intentToAddPaths],{cwd:this.workTree})}catch{}this.postTaskIndexTree=await le(this.workTree)}indexTreeChanged(){return this.preTaskIndexTree.length>0&&this.postTaskIndexTree.length>0&&this.preTaskIndexTree!==this.postTaskIndexTree}postTaskIndexMatchesHead(){return this.postTaskIndexTree.length>0&&this.headTree.length>0&&this.postTaskIndexTree===this.headTree}async restoreUnstagedChanges(){if(this.revertApplied||this.patch===null||this.shouldHideAll)return;const t=["apply","--whitespace=nowarn","--recount","--unidiff-zero"];let r;try{await g(t,{cwd:this.workTree,input:this.patch});return}catch(n){r=n instanceof _?n.stderr:String(n)}try{await g([...t,"--3way"],{cwd:this.workTree,input:this.patch})}catch(n){const s=n instanceof _&&n.stderr?n.stderr:String(n);throw new oe(`Failed to re-apply unstaged changes after running tasks. Original changes remain in the backup stash — recover with \`git stash list\` and \`git stash apply\`.
+First attempt: ${r??"(no stderr)"}
+Second attempt: ${s}`,{cause:n})}}async revert(){if(this.backupStashSha!==null){try{await St(this.workTree,this.backupStashSha)}catch(t){throw new oe("Revert failed while restoring the backup stash. Use `git stash list` to recover manually.",{cause:t})}if(await he(this.workTree,this.backupStashSha),this.intentToAddPaths.length>0)try{await g(["add","--intent-to-add","--",...this.intentToAddPaths],{cwd:this.workTree})}catch{}this.revertApplied=!0}}async cleanup(t){if(this.restoreMergeState(),this.hideAllStashSha!==null)try{await $t(this.workTree,this.hideAllStashSha)}catch{}t&&this.backupStashSha!==null&&!this.revertApplied&&await he(this.workTree,this.backupStashSha)}recoveryHint(){return this.backupStashSha===null?null:`Backup stash is preserved (sha ${this.backupStashSha.slice(0,7)}) — restore with: git stash apply --index ${this.backupStashSha}`}async hideUnstagedChanges(){const t=new Set(this.stagedFiles.map(n=>D(this.workTree,n))),r=this.shouldHideUnstaged?[...t]:this.shouldHidePartial?this.partiallyStaged.filter(n=>t.has(n)):[];r.length!==0&&(this.patch=await gt(r,{cwd:this.workTree}),this.patch!==null&&await wt(r,{cwd:this.workTree}))}snapshotMergeState(){this.gitDir.length!==0&&(this.merge=["MERGE_HEAD","MERGE_MODE","MERGE_MSG"].map(t=>{const r=X(this.gitDir,t);return se(r)?{body:Oe(r),existed:!0,name:t}:{body:null,existed:!1,name:t}}))}restoreMergeState(){if(!(this.gitDir.length===0||this.merge.length===0))for(const t of this.merge){const r=X(this.gitDir,t.name);try{t.existed&&t.body!==null?Pe(r,t.body):se(r)&&Re(r)}catch{}}}}var Et=Object.defineProperty,V=f((e,t)=>Et(e,"name",{value:t,configurable:!0}),"r");const Ce=V(e=>e.includes("/"),"isPathStyle"),U=V((e,t)=>t?e.toLowerCase():e,"normalizeForMatch"),At=V((e,t,r,n={})=>{const s=Ce(e),i=n.caseInsensitive===!0,o=U(e,i),a=[];for(const c of t){const l=s?D(r,c):ve(c);ke(o,U(l,i))&&a.push(c)}return a},"matchFiles"),Mt=V((e,t,r,n={})=>{if(!t||t.length===0)return[...e];const s=n.caseInsensitive===!0;return e.filter(i=>{for(const o of t){const a=Ce(o)?D(r,i):ve(i),c=U(o,s);if(ke(c,U(a,s)))return!1}return!0})},"applyIgnore");var jt=Object.defineProperty,H=f((e,t)=>jt(e,"name",{value:t,configurable:!0}),"g");const Ot=H(e=>{switch(e){case"failed":return"red";case"running":return"cyan";case"skipped":return"yellow";case"success":return"green";default:return"gray"}},"colorForStatus"),pe=H(e=>{if(e==="running")return b(Ge,{type:"dots"});const t=e==="failed"?be:e==="skipped"?B:e==="success"?Te:B;return b($,{color:Ot(e),children:t})},"iconForStatus"),ge=H(({state:e,tick:t,verbose:r})=>C(A,{flexDirection:"column",children:[[...e.patterns.values()].map(n=>C(A,{flexDirection:"column",children:[C(A,{children:[pe(n.status),C($,{children:[" ",n.title]})]}),[...n.commands.values()].map(s=>C(A,{flexDirection:"column",marginLeft:2,children:[C(A,{children:[pe(s.status),C($,{children:[" ",s.title," "]}),s.status!=="pending"&&s.status!=="running"?C($,{color:"gray",children:["(",s.durationMs,"ms)"]}):null]}),r&&s.output?b(A,{flexDirection:"column",marginLeft:2,children:s.output.split(/\r?\n/).slice(0,20).map((i,o)=>b($,{color:"gray",children:i},`${s.id}-line-${o}`))}):null,s.status==="failed"&&s.error?b(A,{marginLeft:2,children:b($,{color:"red",children:s.error.message})}):null]},s.id))]},n.id)),e.infoMessages.map((n,s)=>b($,{color:"gray",children:n},`info-${s}`)),e.warnMessages.map((n,s)=>b($,{color:"yellow",children:n},`warn-${s}`)),e.errorMessages.map(({message:n},s)=>b($,{color:"red",children:n},`err-${s}`))]}),"App"),Pt=H((e={})=>{const t=e.verbose===!0,r={errorMessages:[],infoMessages:[],patterns:new Map,started:!1,warnMessages:[]};let n=0;const s=_e(b(ge,{state:r,tick:n,verbose:t}),{exitOnCtrlC:!1,stdout:process.stderr}),i=H(()=>{n+=1,s.rerender(b(ge,{state:r,tick:n,verbose:t}))},"refresh");return{commandEnd({commandId:o,durationMs:a,error:c,output:l,patternId:u,status:d}){const p=r.patterns.get(u)?.commands.get(o);p&&(p.status=d,p.durationMs=a,p.output=l,p.error=c,i())},commandStart({commandId:o,patternId:a}){const c=r.patterns.get(a)?.commands.get(o);c&&(c.status="running",i())},error({error:o,message:a}){r.errorMessages.push({error:o,message:a}),i()},info({message:o}){r.infoMessages.push(o),i()},patternEnd({patternId:o,status:a}){const c=r.patterns.get(o);c&&(c.status=a,i())},patternStart({patternId:o}){const a=r.patterns.get(o);a&&(a.status="running",i())},start({patterns:o}){r.started=!0;for(const a of o){const c=new Map;for(const l of a.commands)c.set(l.id,{durationMs:0,id:l.id,status:"pending",title:l.title});r.patterns.set(a.id,{commands:c,id:a.id,status:"pending",title:a.title})}i()},async stop(){s.unmount(),await s.waitUntilExit()},warn({message:o}){r.warnMessages.push(o),i()}}},"createInkRenderer");var Rt=Object.defineProperty,J=f((e,t)=>Rt(e,"name",{value:t,configurable:!0}),"a$1");const me=J((e={})=>{const{quiet:t=!1,verbose:r=!1}=e,n=new Map,s=new Map,i=J(a=>{t||process.stderr.write(`${a}
+`)},"print"),o=J(a=>{switch(a){case"failed":return Y(be);case"running":return K(">");case"skipped":return ne(B);case"success":return De(Te);default:return I(B)}},"iconFor");return{commandEnd({commandId:a,durationMs:c,error:l,output:u,status:d}){const p=s.get(a)??a,v=I(`(${c}ms)`);if(i(`  ${o(d)} ${p} ${v}`),d==="failed"&&l&&i(I(l.message)),(d==="failed"||r)&&u&&u.trim().length>0)for(const h of u.split(/\r?\n/))i(`    ${I(h)}`)},commandStart({commandId:a}){if(!r)return;const c=s.get(a)??a;i(`  ${I("…")} ${c}`)},error({error:a,message:c}){t?process.stderr.write(`${Y(c)}
+`):i(Y(c)),a?.stack&&(r||!t)&&process.stderr.write(`${I(a.stack)}
+`)},info({message:a}){i(I(a))},patternEnd({patternId:a,status:c}){const l=n.get(a)??a;i(`${o(c)} ${l}`)},patternStart({patternId:a}){const c=n.get(a)??a;i(`${K(">")} ${c}`)},start({patterns:a}){if(a.length===0){i(I("No staged files matched any pattern."));return}const c=new Set(a.flatMap(l=>l.files)).size;i(`${K(">")} Running staged tasks on ${c} file${c===1?"":"s"} across ${a.length} pattern${a.length===1?"":"s"}`);for(const l of a){n.set(l.id,l.title);for(const u of l.commands)s.set(u.id,u.title)}},stop(){},warn({message:a}){i(ne(a))}}},"createPlainRenderer");var Ft=Object.defineProperty,Nt=f((e,t)=>Ft(e,"name",{value:t,configurable:!0}),"t");const Gt=Nt(async e=>{const{env:t}=process;if(e.debug===!0||e.quiet===!0||t.NODE_ENV==="test"||t.TERM==="dumb"||t.CI!==void 0||!process.stderr.isTTY)return me({quiet:e.quiet,verbose:e.verbose});try{return Pt({verbose:e.verbose})}catch{return me({quiet:e.quiet,verbose:e.verbose})}},"pickRenderer");var _t=Object.defineProperty,G=f((e,t)=>_t(e,"name",{value:t,configurable:!0}),"a");const Q=G(e=>typeof e=="object"&&e!==null&&typeof e.title=="string"&&typeof e.task=="function","isCustomTask"),Dt=G(async e=>{let t=0,r=0;const n=G(()=>(t+=1,`pattern-${t}`),"nextPatternId"),s=G(()=>(r+=1,`cmd-${r}`),"nextCommandId"),i=G(async(a,c,l)=>{if(typeof a=="string"){l.push({command:a,files:c,id:s(),source:"string",title:a});return}if(Array.isArray(a)){for(const u of a)await i(u,c,l);return}if(typeof a=="function"){const u=await a([...c]);if(typeof u=="string"){l.push({command:u,files:c,id:s(),source:"function",title:u});return}if(Array.isArray(u)){for(const d of u)if(typeof d=="string")l.push({command:d,files:c,id:s(),source:"function",title:d});else if(Q(d))l.push({files:c,id:s(),run:d.task,source:"custom",title:d.title});else throw new T("Task function returned an array with an unsupported entry — expected strings or { title, task }.");return}if(Q(u)){l.push({files:c,id:s(),run:u.task,source:"custom",title:u.title});return}throw new T("Task function returned an unsupported value — expected string, string[], or { title, task }.")}if(Q(a)){l.push({files:c,id:s(),run:a.task,source:"custom",title:a.title});return}throw new T("Unsupported task value — expected string, string[], function, or { title, task }.")},"expandTask"),o=[];for(const[a,c]of Object.entries(e.config)){const l=At(a,e.files,e.cwd,{caseInsensitive:e.caseInsensitive===!0});if(l.length===0)continue;const u=e.relative?l.map(p=>D(e.cwd,p)):l,d=[];await i(c,u,d),d.length!==0&&o.push({commands:d,files:u,id:n(),pattern:a,title:`${a} — ${l.length} file${l.length===1?"":"s"}`})}return o},"buildTaskGraph");var Ht=Object.defineProperty,z=f((e,t)=>Ht(e,"name",{value:t,configurable:!0}),"d$1");const Lt=z(e=>{const t=[];let r="",n=!1,s=!1;for(let i=0;i<e.length;i+=1){const o=e[i];if(o===void 0)break;if(o==="\\"&&!n&&i+1<e.length){const a=e[i+1];if(a!==void 0){s&&a!=='"'&&a!=="\\"&&(r+=o),r+=a,i+=1;continue}}if(o==='"'&&!n){s=!s;continue}if(o==="'"&&!s){n=!n;continue}if(!n&&!s&&/\s/.test(o)){r.length>0&&(t.push(r),r="");continue}r+=o}if(n||s)throw new T(`Unterminated ${n?"single":"double"} quote in command: ${e}`);return r.length>0&&t.push(r),t},"parseCommandString"),Ie=process.platform==="win32"?28e3:131072,Bt=z((e,t,r)=>{const n=[];let s=[],i=t;const o=r<=0?Ie:r;for(const a of e){const c=Buffer.byteLength(a)+1;s.length>0&&i+c>o&&(n.push(s),s=[],i=t),s.push(a),i+=c}return s.length>0&&n.push(s),n},"chunkFiles"),Ut=z(async(e,t,r)=>{const n=Lt(e);if(n.length===0)throw new M(e,"Empty command for staged task.");const[s,...i]=n;if(s===void 0)throw new M(e,"Empty command for staged task.");const o=Buffer.byteLength(s)+i.reduce((u,d)=>u+Buffer.byteLength(d)+1,0),a=Bt(t,o,r.maxArgLength??Ie),c=Date.now(),l=[];for(const u of a){if(r.signal?.aborted===!0)throw new M(e,"Task aborted by earlier failure.");const d=await ye(s,[...i,...u],{cancelSignal:r.signal,cwd:r.cwd,env:qt(r.env),killSignal:r.killSignal??"SIGTERM",reject:!1,stderr:"pipe",stdout:"pipe"}),p=typeof d.stdout=="string"?d.stdout:"",v=typeof d.stderr=="string"?d.stderr:"",h=[p,v].filter(m=>m.length>0).join(`
+`);if(h.length>0&&l.push(h),d.isCanceled||d.isTerminated||typeof d.exitCode!="number"){const m=d.isCanceled?"Task aborted by earlier failure.":d.isTerminated?`Task killed by signal ${d.signal??"(unknown)"}.`:h.trim()||"Task exited without a numeric status code.";throw new M(e,m)}if(d.exitCode!==0)throw new M(e,h.trim()||`Exit code ${d.exitCode} from ${s}`)}return{durationMs:Date.now()-c,output:l.join(`
+`)}},"execCommand"),qt=z(e=>{const t={...process.env};return process.stderr.isTTY&&t.FORCE_COLOR===void 0&&t.NO_COLOR===void 0&&(t.FORCE_COLOR="1"),e?{...t,...e}:t},"buildTaskEnv");var Vt=Object.defineProperty,j=f((e,t)=>Vt(e,"name",{value:t,configurable:!0}),"o");const zt=j(async(e,t,r)=>{const n=Kt(r.concurrent,e.length),s=[],i=new AbortController;let o=!1,a=0;const c=j(()=>{o||(o=!0,r.continueOnError||i.abort())},"cancel");r.externalSignal&&(r.externalSignal.aborted?c():r.externalSignal.addEventListener("abort",()=>{c()},{once:!0}));const l=j(h=>{for(const m of h.commands)t.commandEnd({commandId:m.id,durationMs:0,patternId:h.id,status:"skipped"})},"emitSkippedCommands"),u=j(async h=>{if(o){l(h),t.patternEnd({patternId:h.id,status:"skipped"});return}t.patternStart({patternId:h.id});let m="success";for(const y of h.commands){if(o){t.commandEnd({commandId:y.id,durationMs:0,patternId:h.id,status:"skipped"}),m=m==="success"?"skipped":m;continue}t.commandStart({commandId:y.id,patternId:h.id});const k=await Wt(y,r,i.signal),S=k.status==="failed"&&i.signal.aborted?{...k,status:"skipped"}:k;if(t.commandEnd({commandId:y.id,durationMs:S.durationMs,error:S.error,output:S.output,patternId:h.id,status:S.status}),S.status==="failed"){s.push(y.title),m="failed",c();break}if(S.status==="skipped"){m=m==="success"?"skipped":m;break}}t.patternEnd({patternId:h.id,status:m})},"runOne"),d=j(async()=>{for(;a<e.length;){const h=e[a];a+=1,h&&await u(h)}},"pickNext"),p=[];for(let h=0;h<Math.min(n,e.length);h+=1)p.push(d());await Promise.all(p);const v=r.externalSignal?.aborted===!0;return{failedCommands:s,success:s.length===0&&!v}},"runTasks"),Wt=j(async(e,t,r)=>{const n=Date.now();try{if(e.source==="custom"&&e.run)return await e.run([...e.files]),{durationMs:Date.now()-n,status:"success"};if(e.command){const s=await Ut(e.command,e.files,{cwd:t.cwd,killSignal:t.killSignal,maxArgLength:t.maxArgLength,signal:r});return{durationMs:s.durationMs,output:t.verbose?s.output:void 0,status:"success"}}return{durationMs:Date.now()-n,error:new M(e.title,"Command has no invocation target."),status:"failed"}}catch(s){const i=s instanceof Error?s:new Error(String(s));return{durationMs:Date.now()-n,error:i,output:i instanceof M?i.message:void 0,status:"failed"}}},"runCommand"),Kt=j((e,t)=>{if(e===!1)return 1;if(e===!0){const n=Math.max(1,typeof ae=="function"?ae():4);return Math.min(Math.max(1,t),n)}const r=Math.floor(e);return r>0?r:1},"concurrencyLimit");var Yt=Object.defineProperty,Z=f((e,t)=>Yt(e,"name",{value:t,configurable:!0}),"u");const Jt=!0,Qt=Z(e=>{try{return!je(e)}catch{return!1}},"detectCaseInsensitive"),Xt=Z(async(e={})=>{const t=e.cwd??process.cwd(),r=await Gt(e),n=await rt(e);typeof n!="function"&&ce(n);const s=new It({...e,cwd:t}),i=new AbortController;let o=!1;const a=Z(d=>{if(o){process.removeListener("SIGINT",a),process.removeListener("SIGTERM",a),process.kill(process.pid,d);return}o=!0,r.warn({message:`Received ${d} — cancelling staged tasks and restoring state. Press Ctrl+C again to abort.`}),i.abort()},"onInterrupt");process.on("SIGINT",a),process.on("SIGTERM",a);let c={failedCommands:[],ranTasks:!1,success:!0},l=!1,u=!1;try{await s.prepare(),l=!0;for(const k of s.warnings)r.warn({message:k});if(s.stagedFiles.length===0)return e.allowEmpty!==!0&&r.info({message:"No staged files found."}),u=!0,{failedCommands:[],ranTasks:!1,success:!0};const d=Qt(t),p=Mt(s.stagedFiles,e.ignore,t,{caseInsensitive:d});if(p.length===0&&s.stagedFiles.length>0)return r.info({message:"Every staged file was excluded by the `ignore` list."}),u=!0,{failedCommands:[],ranTasks:!1,success:!0};const v=typeof n=="function"?ce(await n([...p])):n,h=await Dt({caseInsensitive:d,config:v,cwd:t,files:p,relative:e.relative});if(r.start({patterns:h}),h.length===0)return r.info({message:"No staged files matched any pattern."}),u=!0,{failedCommands:[],ranTasks:!1,success:!0};const{failedCommands:m,success:y}=await zt(h,r,{concurrent:e.concurrent??Jt,continueOnError:e.continueOnError===!0,cwd:t,externalSignal:i.signal,killSignal:e.killSignal,maxArgLength:e.maxArgLength,verbose:e.verbose});if(c={failedCommands:m,ranTasks:!0,success:y},y){if(e.diff===void 0&&(await s.applyModifications({autoStage:e.autoStage===!0}),e.failOnChanges===!0&&s.indexTreeChanged()&&(r.warn({message:"Tasks modified staged content — failing because --fail-on-changes is set."}),c={failedCommands:[...m],ranTasks:!0,success:!1}),e.allowEmpty!==!0&&s.postTaskIndexMatchesHead()))throw new qe("All staged changes were reverted by tasks. Re-stage changes or rerun with --allow-empty.")}else if(e.revert===!0)r.info({message:"Reverting working tree from backup stash."}),await s.revert();else{const k=s.recoveryHint();k&&r.warn({message:k})}return await s.restoreUnstagedChanges(),u=c.success,c}catch(d){const p=d instanceof Error?d.message:String(d),v=d instanceof Error?d:new Error(p);if(r.error({error:v,message:p}),d instanceof O)return{failedCommands:c.failedCommands,ranTasks:c.ranTasks,success:!1};throw d}finally{if(process.removeListener("SIGINT",a),process.removeListener("SIGTERM",a),l)try{await s.cleanup(u)}catch(d){r.error({error:d,message:"Cleanup failed."})}await r.stop()}},"runStaged");var Zt=Object.defineProperty,er=f((e,t)=>Zt(e,"name",{value:t,configurable:!0}),"n");const tr="VIS_STAGED_CONCURRENT",we=er(e=>{const t=e.trim();if(t==="true"||t==="")return!0;if(t==="false")return!1;const r=Number(t);return Number.isNaN(r)?!0:r},"parseConcurrent");var rr=Object.defineProperty,L=f((e,t)=>rr(e,"name",{value:t,configurable:!0}),"d");const sr=L((e,t)=>{const r={};t!==void 0&&(r.config=t);const n=L(w=>e[w]===void 0?void 0:!!e[w],"readBool"),s=L(w=>{const W=e[w];return typeof W=="string"&&W.length>0?W:void 0},"readString"),i=n("allow-empty");i!==void 0&&(r.allowEmpty=i);const o=n("auto-stage");o!==void 0&&(r.autoStage=o);const a=n("continue-on-error");a!==void 0&&(r.continueOnError=a);const c=n("debug");c!==void 0&&(r.debug=c);const l=n("fail-on-changes");l!==void 0&&(r.failOnChanges=l);const u=n("hide-partially-staged");u!==void 0&&(r.hidePartiallyStaged=u);const d=n("hide-unstaged");d!==void 0&&(r.hideUnstaged=d);const p=n("quiet");p!==void 0&&(r.quiet=p);const v=n("relative");v!==void 0&&(r.relative=v);const h=n("revert");h!==void 0&&(r.revert=h);const m=n("stash");m!==void 0&&(r.stash=m);const y=n("verbose");y!==void 0&&(r.verbose=y);const k=s("cwd");k!==void 0&&(r.cwd=k);const S=s("diff");S!==void 0&&(r.diff=S);const re=s("diff-filter");if(re!==void 0&&(r.diffFilter=re),n("force-kill")===!0&&(r.killSignal="SIGKILL"),e.concurrent===void 0){const w=process.env[tr];w!==void 0&&(r.concurrent=we(w.trim()))}else{const{concurrent:w}=e;r.concurrent=we(typeof w=="string"?w:typeof w=="number"||typeof w=="boolean"?String(w):"")}return r},"buildRunOptions"),pr=L(async({options:e,visConfig:t})=>{const r=(t??{}).staged;if(!r)throw new Error(`No "staged" config found in vis.config.ts. Add one:
+
+  // vis.config.ts
+  import { defineConfig } from "@visulima/vis/config";
+
+  export default defineConfig({
+    staged: { '*': 'vis check --fix' },
   });
-};
-
-const colorForStatus = (status) => {
-  switch (status) {
-    case "failed": {
-      return "red";
-    }
-    case "running": {
-      return "cyan";
-    }
-    case "skipped": {
-      return "yellow";
-    }
-    case "success": {
-      return "green";
-    }
-    default: {
-      return "gray";
-    }
-  }
-};
-const iconForStatus = (status) => {
-  if (status === "running") {
-    return jsx(Spinner, { type: "dots" });
-  }
-  const glyph = status === "failed" ? CROSS : status === "skipped" ? DASH : status === "success" ? TICK : DASH;
-  return jsx(Text, { color: colorForStatus(status), children: glyph });
-};
-const App = ({ state, tick: _tick, verbose }) => jsxs(Box, { flexDirection: "column", children: [
-  [...state.patterns.values()].map((pattern) => jsxs(Box, { flexDirection: "column", children: [
-    jsxs(Box, { children: [
-      iconForStatus(pattern.status),
-      jsxs(Text, { children: [
-        " ",
-        pattern.title
-      ] })
-    ] }),
-    [...pattern.commands.values()].map((command) => jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [
-      jsxs(Box, { children: [
-        iconForStatus(command.status),
-        jsxs(Text, { children: [
-          " ",
-          command.title,
-          " "
-        ] }),
-        command.status !== "pending" && command.status !== "running" ? jsxs(Text, { color: "gray", children: [
-          "(",
-          command.durationMs,
-          "ms)"
-        ] }) : null
-      ] }),
-      verbose && command.output ? jsx(Box, { flexDirection: "column", marginLeft: 2, children: command.output.split(/\r?\n/).slice(0, 20).map((line, index) => jsx(Text, { color: "gray", children: line }, `${command.id}-line-${index}`)) }) : null,
-      command.status === "failed" && command.error ? jsx(Box, { marginLeft: 2, children: jsx(Text, { color: "red", children: command.error.message }) }) : null
-    ] }, command.id))
-  ] }, pattern.id)),
-  state.infoMessages.map((message, index) => jsx(Text, { color: "gray", children: message }, `info-${index}`)),
-  state.warnMessages.map((message, index) => jsx(Text, { color: "yellow", children: message }, `warn-${index}`)),
-  state.errorMessages.map(({ message }, index) => jsx(Text, { color: "red", children: message }, `err-${index}`))
-] });
-const createInkRenderer = (options = {}) => {
-  const verbose = options.verbose === true;
-  const state = {
-    errorMessages: [],
-    infoMessages: [],
-    patterns: /* @__PURE__ */ new Map(),
-    started: false,
-    warnMessages: []
-  };
-  let tick = 0;
-  const instance = render(jsx(App, { state, tick, verbose }), { exitOnCtrlC: false, stdout: process.stderr });
-  const refresh = () => {
-    tick += 1;
-    instance.rerender(jsx(App, { state, tick, verbose }));
-  };
-  return {
-    commandEnd({ commandId, durationMs, error, output, patternId, status }) {
-      const command = state.patterns.get(patternId)?.commands.get(commandId);
-      if (command) {
-        command.status = status;
-        command.durationMs = durationMs;
-        command.output = output;
-        command.error = error;
-        refresh();
-      }
-    },
-    commandStart({ commandId, patternId }) {
-      const command = state.patterns.get(patternId)?.commands.get(commandId);
-      if (command) {
-        command.status = "running";
-        refresh();
-      }
-    },
-    error({ error, message }) {
-      state.errorMessages.push({ error, message });
-      refresh();
-    },
-    info({ message }) {
-      state.infoMessages.push(message);
-      refresh();
-    },
-    patternEnd({ patternId, status }) {
-      const pattern = state.patterns.get(patternId);
-      if (pattern) {
-        pattern.status = status;
-        refresh();
-      }
-    },
-    patternStart({ patternId }) {
-      const pattern = state.patterns.get(patternId);
-      if (pattern) {
-        pattern.status = "running";
-        refresh();
-      }
-    },
-    start({ patterns }) {
-      state.started = true;
-      for (const pattern of patterns) {
-        const commandMap = /* @__PURE__ */ new Map();
-        for (const command of pattern.commands) {
-          commandMap.set(command.id, {
-            durationMs: 0,
-            id: command.id,
-            status: "pending",
-            title: command.title
-          });
-        }
-        state.patterns.set(pattern.id, {
-          commands: commandMap,
-          id: pattern.id,
-          status: "pending",
-          title: pattern.title
-        });
-      }
-      refresh();
-    },
-    async stop() {
-      instance.unmount();
-      await instance.waitUntilExit();
-    },
-    warn({ message }) {
-      state.warnMessages.push(message);
-      refresh();
-    }
-  };
-};
-
-const createPlainRenderer = (options = {}) => {
-  const { quiet = false, verbose = false } = options;
-  const patternTitles = /* @__PURE__ */ new Map();
-  const commandTitles = /* @__PURE__ */ new Map();
-  const print = (message) => {
-    if (!quiet) {
-      process.stderr.write(`${message}
-`);
-    }
-  };
-  const iconFor = (status) => {
-    switch (status) {
-      case "failed": {
-        return red(CROSS);
-      }
-      case "running": {
-        return cyan(">");
-      }
-      case "skipped": {
-        return yellow(DASH);
-      }
-      case "success": {
-        return green(TICK);
-      }
-      default: {
-        return dim(DASH);
-      }
-    }
-  };
-  return {
-    commandEnd({ commandId, durationMs, error, output, status }) {
-      const title = commandTitles.get(commandId) ?? commandId;
-      const duration = dim(`(${durationMs}ms)`);
-      print(`  ${iconFor(status)} ${title} ${duration}`);
-      if (status === "failed" && error) {
-        print(dim(error.message));
-      }
-      if ((status === "failed" || verbose) && output && output.trim().length > 0) {
-        for (const line of output.split(/\r?\n/)) {
-          print(`    ${dim(line)}`);
-        }
-      }
-    },
-    commandStart({ commandId }) {
-      if (!verbose) {
-        return;
-      }
-      const title = commandTitles.get(commandId) ?? commandId;
-      print(`  ${dim("…")} ${title}`);
-    },
-    error({ error, message }) {
-      if (quiet) {
-        process.stderr.write(`${red(message)}
-`);
-      } else {
-        print(red(message));
-      }
-      if (error?.stack && (verbose || !quiet)) {
-        process.stderr.write(`${dim(error.stack)}
-`);
-      }
-    },
-    info({ message }) {
-      print(dim(message));
-    },
-    patternEnd({ patternId, status }) {
-      const title = patternTitles.get(patternId) ?? patternId;
-      print(`${iconFor(status)} ${title}`);
-    },
-    patternStart({ patternId }) {
-      const title = patternTitles.get(patternId) ?? patternId;
-      print(`${cyan(">")} ${title}`);
-    },
-    start({ patterns }) {
-      if (patterns.length === 0) {
-        print(dim("No staged files matched any pattern."));
-        return;
-      }
-      const fileCount = new Set(patterns.flatMap((p) => p.files)).size;
-      print(
-        `${cyan(">")} Running staged tasks on ${fileCount} file${fileCount === 1 ? "" : "s"} across ${patterns.length} pattern${patterns.length === 1 ? "" : "s"}`
-      );
-      for (const pattern of patterns) {
-        patternTitles.set(pattern.id, pattern.title);
-        for (const cmd of pattern.commands) {
-          commandTitles.set(cmd.id, cmd.title);
-        }
-      }
-    },
-    stop() {
-    },
-    warn({ message }) {
-      print(yellow(message));
-    }
-  };
-};
-
-const pickRenderer = async (options) => {
-  const { env } = process;
-  const forcePlain = options.debug === true || options.quiet === true || env["NODE_ENV"] === "test" || env["TERM"] === "dumb" || env["CI"] !== void 0 || !process.stderr.isTTY;
-  if (forcePlain) {
-    return createPlainRenderer({ quiet: options.quiet, verbose: options.verbose });
-  }
-  try {
-    return createInkRenderer({ verbose: options.verbose });
-  } catch {
-    return createPlainRenderer({ quiet: options.quiet, verbose: options.verbose });
-  }
-};
-
-const isCustomTask = (value) => typeof value === "object" && value !== null && typeof value.title === "string" && typeof value.task === "function";
-const buildTaskGraph = async (options) => {
-  let patternCounter = 0;
-  let commandCounter = 0;
-  const nextPatternId = () => {
-    patternCounter += 1;
-    return `pattern-${patternCounter}`;
-  };
-  const nextCommandId = () => {
-    commandCounter += 1;
-    return `cmd-${commandCounter}`;
-  };
-  const expandTask = async (value, files, commands) => {
-    if (typeof value === "string") {
-      commands.push({
-        command: value,
-        files,
-        id: nextCommandId(),
-        source: "string",
-        title: value
-      });
-      return;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        await expandTask(item, files, commands);
-      }
-      return;
-    }
-    if (typeof value === "function") {
-      const generated = await value([...files]);
-      if (typeof generated === "string") {
-        commands.push({
-          command: generated,
-          files,
-          id: nextCommandId(),
-          source: "function",
-          title: generated
-        });
-        return;
-      }
-      if (Array.isArray(generated)) {
-        for (const item of generated) {
-          if (typeof item === "string") {
-            commands.push({
-              command: item,
-              files,
-              id: nextCommandId(),
-              source: "function",
-              title: item
-            });
-          } else if (isCustomTask(item)) {
-            commands.push({
-              files,
-              id: nextCommandId(),
-              run: item.task,
-              source: "custom",
-              title: item.title
-            });
-          } else {
-            throw new ConfigError("Task function returned an array with an unsupported entry — expected strings or { title, task }.");
-          }
-        }
-        return;
-      }
-      if (isCustomTask(generated)) {
-        commands.push({
-          files,
-          id: nextCommandId(),
-          run: generated.task,
-          source: "custom",
-          title: generated.title
-        });
-        return;
-      }
-      throw new ConfigError("Task function returned an unsupported value — expected string, string[], or { title, task }.");
-    }
-    if (isCustomTask(value)) {
-      commands.push({
-        files,
-        id: nextCommandId(),
-        run: value.task,
-        source: "custom",
-        title: value.title
-      });
-      return;
-    }
-    throw new ConfigError("Unsupported task value — expected string, string[], function, or { title, task }.");
-  };
-  const patterns = [];
-  for (const [pattern, value] of Object.entries(options.config)) {
-    const matched = matchFiles(pattern, options.files, options.cwd, { caseInsensitive: options.caseInsensitive === true });
-    if (matched.length === 0) {
-      continue;
-    }
-    const view = options.relative ? matched.map((file) => relative(options.cwd, file)) : matched;
-    const commands = [];
-    await expandTask(value, view, commands);
-    if (commands.length === 0) {
-      continue;
-    }
-    patterns.push({
-      commands,
-      files: view,
-      id: nextPatternId(),
-      pattern,
-      title: `${pattern} — ${matched.length} file${matched.length === 1 ? "" : "s"}`
-    });
-  }
-  return patterns;
-};
-
-const parseCommandString = (input) => {
-  const tokens = [];
-  let buffer = "";
-  let inSingle = false;
-  let inDouble = false;
-  for (let i = 0; i < input.length; i += 1) {
-    const character = input[i];
-    if (character === void 0) {
-      break;
-    }
-    if (character === "\\" && !inSingle && i + 1 < input.length) {
-      const next = input[i + 1];
-      if (next !== void 0) {
-        if (inDouble && next !== '"' && next !== "\\") {
-          buffer += character;
-          buffer += next;
-        } else {
-          buffer += next;
-        }
-        i += 1;
-        continue;
-      }
-    }
-    if (character === '"' && !inSingle) {
-      inDouble = !inDouble;
-      continue;
-    }
-    if (character === "'" && !inDouble) {
-      inSingle = !inSingle;
-      continue;
-    }
-    if (!inSingle && !inDouble && /\s/.test(character)) {
-      if (buffer.length > 0) {
-        tokens.push(buffer);
-        buffer = "";
-      }
-      continue;
-    }
-    buffer += character;
-  }
-  if (inSingle || inDouble) {
-    throw new ConfigError(`Unterminated ${inSingle ? "single" : "double"} quote in command: ${input}`);
-  }
-  if (buffer.length > 0) {
-    tokens.push(buffer);
-  }
-  return tokens;
-};
-const DEFAULT_MAX_ARG_LENGTH = process.platform === "win32" ? 28e3 : 131072;
-const chunkFiles = (files, fixedPrefixLength, maxArgLength) => {
-  const chunks = [];
-  let current = [];
-  let currentLength = fixedPrefixLength;
-  const limit = maxArgLength <= 0 ? DEFAULT_MAX_ARG_LENGTH : maxArgLength;
-  for (const file of files) {
-    const fileLength = Buffer.byteLength(file) + 1;
-    if (current.length > 0 && currentLength + fileLength > limit) {
-      chunks.push(current);
-      current = [];
-      currentLength = fixedPrefixLength;
-    }
-    current.push(file);
-    currentLength += fileLength;
-  }
-  if (current.length > 0) {
-    chunks.push(current);
-  }
-  return chunks;
-};
-const execCommand = async (command, files, options) => {
-  const argv = parseCommandString(command);
-  if (argv.length === 0) {
-    throw new TaskError(command, `Empty command for staged task.`);
-  }
-  const [program, ...baseArgs] = argv;
-  if (program === void 0) {
-    throw new TaskError(command, `Empty command for staged task.`);
-  }
-  const prefixLength = Buffer.byteLength(program) + baseArgs.reduce((total, argument) => total + Buffer.byteLength(argument) + 1, 0);
-  const chunks = chunkFiles(files, prefixLength, options.maxArgLength ?? DEFAULT_MAX_ARG_LENGTH);
-  const started = Date.now();
-  const outputs = [];
-  for (const chunk of chunks) {
-    if (options.signal?.aborted === true) {
-      throw new TaskError(command, "Task aborted by earlier failure.");
-    }
-    const result = await execa(program, [...baseArgs, ...chunk], {
-      cancelSignal: options.signal,
-      cwd: options.cwd,
-      // Pipe stdout/stderr so we can capture task output for the renderer, but forward `FORCE_COLOR=1`
-      // unless the user has already set it — tools like eslint / prettier check isTTY, which is false
-      // when piped, and drop ANSI styling without this hint. Matches lint-staged / nano-staged behavior.
-      env: buildTaskEnv(options.env),
-      // Signal delivered to the child when `cancelSignal` aborts. Defaults to SIGTERM for graceful
-      // shutdown; callers can set SIGKILL via `killSignal` for fast-fail runs.
-      killSignal: options.killSignal ?? "SIGTERM",
-      reject: false,
-      stderr: "pipe",
-      stdout: "pipe"
-    });
-    const stdout = typeof result.stdout === "string" ? result.stdout : "";
-    const stderr = typeof result.stderr === "string" ? result.stderr : "";
-    const merged = [stdout, stderr].filter((s) => s.length > 0).join("\n");
-    if (merged.length > 0) {
-      outputs.push(merged);
-    }
-    if (result.isCanceled || result.isTerminated || typeof result.exitCode !== "number") {
-      const reason = result.isCanceled ? "Task aborted by earlier failure." : result.isTerminated ? `Task killed by signal ${result.signal ?? "(unknown)"}.` : merged.trim() || `Task exited without a numeric status code.`;
-      throw new TaskError(command, reason);
-    }
-    if (result.exitCode !== 0) {
-      throw new TaskError(command, merged.trim() || `Exit code ${result.exitCode} from ${program}`);
-    }
-  }
-  return { durationMs: Date.now() - started, output: outputs.join("\n") };
-};
-const buildTaskEnv = (overrides) => {
-  const base = { ...process.env };
-  if (process.stderr.isTTY && base["FORCE_COLOR"] === void 0 && base["NO_COLOR"] === void 0) {
-    base["FORCE_COLOR"] = "1";
-  }
-  return overrides ? { ...base, ...overrides } : base;
-};
-
-const runTasks = async (patterns, renderer, options) => {
-  const limit = concurrencyLimit(options.concurrent, patterns.length);
-  const failedCommands = [];
-  const abortController = new AbortController();
-  let cancelled = false;
-  let index = 0;
-  const cancel = () => {
-    if (cancelled) {
-      return;
-    }
-    cancelled = true;
-    if (!options.continueOnError) {
-      abortController.abort();
-    }
-  };
-  if (options.externalSignal) {
-    if (options.externalSignal.aborted) {
-      cancel();
-    } else {
-      options.externalSignal.addEventListener(
-        "abort",
-        () => {
-          cancel();
-        },
-        { once: true }
-      );
-    }
-  }
-  const emitSkippedCommands = (pattern) => {
-    for (const command of pattern.commands) {
-      renderer.commandEnd({
-        commandId: command.id,
-        durationMs: 0,
-        patternId: pattern.id,
-        status: "skipped"
-      });
-    }
-  };
-  const runOne = async (pattern) => {
-    if (cancelled) {
-      emitSkippedCommands(pattern);
-      renderer.patternEnd({ patternId: pattern.id, status: "skipped" });
-      return;
-    }
-    renderer.patternStart({ patternId: pattern.id });
-    let patternStatus = "success";
-    for (const command of pattern.commands) {
-      if (cancelled) {
-        renderer.commandEnd({
-          commandId: command.id,
-          durationMs: 0,
-          patternId: pattern.id,
-          status: "skipped"
-        });
-        patternStatus = patternStatus === "success" ? "skipped" : patternStatus;
-        continue;
-      }
-      renderer.commandStart({ commandId: command.id, patternId: pattern.id });
-      const outcome = await runCommand(command, options, abortController.signal);
-      const classified = outcome.status === "failed" && abortController.signal.aborted ? { ...outcome, status: "skipped" } : outcome;
-      renderer.commandEnd({
-        commandId: command.id,
-        durationMs: classified.durationMs,
-        error: classified.error,
-        output: classified.output,
-        patternId: pattern.id,
-        status: classified.status
-      });
-      if (classified.status === "failed") {
-        failedCommands.push(command.title);
-        patternStatus = "failed";
-        cancel();
-        break;
-      }
-      if (classified.status === "skipped") {
-        patternStatus = patternStatus === "success" ? "skipped" : patternStatus;
-        break;
-      }
-    }
-    renderer.patternEnd({ patternId: pattern.id, status: patternStatus });
-  };
-  const pickNext = async () => {
-    while (index < patterns.length) {
-      const slot = patterns[index];
-      index += 1;
-      if (slot) {
-        await runOne(slot);
-      }
-    }
-  };
-  const workers = [];
-  for (let i = 0; i < Math.min(limit, patterns.length); i += 1) {
-    workers.push(pickNext());
-  }
-  await Promise.all(workers);
-  const externallyCancelled = options.externalSignal?.aborted === true;
-  return { failedCommands, success: failedCommands.length === 0 && !externallyCancelled };
-};
-const runCommand = async (command, options, signal) => {
-  const started = Date.now();
-  try {
-    if (command.source === "custom" && command.run) {
-      await command.run([...command.files]);
-      return { durationMs: Date.now() - started, status: "success" };
-    }
-    if (command.command) {
-      const result = await execCommand(command.command, command.files, {
-        cwd: options.cwd,
-        killSignal: options.killSignal,
-        maxArgLength: options.maxArgLength,
-        signal
-      });
-      return { durationMs: result.durationMs, output: options.verbose ? result.output : void 0, status: "success" };
-    }
-    return {
-      durationMs: Date.now() - started,
-      error: new TaskError(command.title, `Command has no invocation target.`),
-      status: "failed"
-    };
-  } catch (error_) {
-    const error = error_ instanceof Error ? error_ : new Error(String(error_));
-    return {
-      durationMs: Date.now() - started,
-      error,
-      output: error instanceof TaskError ? error.message : void 0,
-      status: "failed"
-    };
-  }
-};
-const concurrencyLimit = (concurrent, patternCount) => {
-  if (concurrent === false) {
-    return 1;
-  }
-  if (concurrent === true) {
-    const reasonable = Math.max(1, typeof availableParallelism === "function" ? availableParallelism() : 4);
-    return Math.min(Math.max(1, patternCount), reasonable);
-  }
-  const value = Math.floor(concurrent);
-  return value > 0 ? value : 1;
-};
-
-const DEFAULT_CONCURRENT = true;
-const detectCaseInsensitive = (cwd) => {
-  try {
-    return !isFsCaseSensitive(cwd);
-  } catch {
-    return false;
-  }
-};
-const runStaged = async (options = {}) => {
-  const cwd = options.cwd ?? process.cwd();
-  const renderer = await pickRenderer(options);
-  const resolvedConfig = await resolveConfig(options);
-  if (typeof resolvedConfig !== "function") {
-    validateConfig(resolvedConfig);
-  }
-  const workflow = new GitWorkflow({ ...options, cwd });
-  const externalAborter = new AbortController();
-  let interrupted = false;
-  const onInterrupt = (signal) => {
-    if (interrupted) {
-      process.removeListener("SIGINT", onInterrupt);
-      process.removeListener("SIGTERM", onInterrupt);
-      process.kill(process.pid, signal);
-      return;
-    }
-    interrupted = true;
-    renderer.warn({ message: `Received ${signal} — cancelling staged tasks and restoring state. Press Ctrl+C again to abort.` });
-    externalAborter.abort();
-  };
-  process.on("SIGINT", onInterrupt);
-  process.on("SIGTERM", onInterrupt);
-  let runResult = { failedCommands: [], ranTasks: false, success: true };
-  let workflowPrepared = false;
-  let finalSuccess = false;
-  try {
-    await workflow.prepare();
-    workflowPrepared = true;
-    for (const message of workflow.warnings) {
-      renderer.warn({ message });
-    }
-    if (workflow.stagedFiles.length === 0) {
-      if (options.allowEmpty !== true) {
-        renderer.info({ message: "No staged files found." });
-      }
-      finalSuccess = true;
-      return { failedCommands: [], ranTasks: false, success: true };
-    }
-    const caseInsensitive = detectCaseInsensitive(cwd);
-    const candidateFiles = applyIgnore(workflow.stagedFiles, options.ignore, cwd, { caseInsensitive });
-    if (candidateFiles.length === 0 && workflow.stagedFiles.length > 0) {
-      renderer.info({ message: "Every staged file was excluded by the `ignore` list." });
-      finalSuccess = true;
-      return { failedCommands: [], ranTasks: false, success: true };
-    }
-    const staticConfig = typeof resolvedConfig === "function" ? validateConfig(await resolvedConfig([...candidateFiles])) : resolvedConfig;
-    const patterns = await buildTaskGraph({
-      caseInsensitive,
-      config: staticConfig,
-      cwd,
-      files: candidateFiles,
-      relative: options.relative
-    });
-    renderer.start({ patterns });
-    if (patterns.length === 0) {
-      renderer.info({ message: "No staged files matched any pattern." });
-      finalSuccess = true;
-      return { failedCommands: [], ranTasks: false, success: true };
-    }
-    const { failedCommands, success } = await runTasks(patterns, renderer, {
-      concurrent: options.concurrent ?? DEFAULT_CONCURRENT,
-      continueOnError: options.continueOnError === true,
-      cwd,
-      externalSignal: externalAborter.signal,
-      killSignal: options.killSignal,
-      maxArgLength: options.maxArgLength,
-      verbose: options.verbose
-    });
-    runResult = { failedCommands, ranTasks: true, success };
-    if (success) {
-      if (options.diff === void 0) {
-        await workflow.applyModifications({ autoStage: options.autoStage === true });
-        if (options.failOnChanges === true && workflow.indexTreeChanged()) {
-          renderer.warn({ message: "Tasks modified staged content — failing because --fail-on-changes is set." });
-          runResult = { failedCommands: [...failedCommands], ranTasks: true, success: false };
-        }
-        if (options.allowEmpty !== true && workflow.postTaskIndexMatchesHead()) {
-          throw new ApplyEmptyCommitError("All staged changes were reverted by tasks. Re-stage changes or rerun with --allow-empty.");
-        }
-      }
-    } else if (options.revert === true) {
-      renderer.info({ message: "Reverting working tree from backup stash." });
-      await workflow.revert();
-    } else {
-      const hint = workflow.recoveryHint();
-      if (hint) {
-        renderer.warn({ message: hint });
-      }
-    }
-    await workflow.restoreUnstagedChanges();
-    finalSuccess = runResult.success;
-    return runResult;
-  } catch (error_) {
-    const message = error_ instanceof Error ? error_.message : String(error_);
-    const error = error_ instanceof Error ? error_ : new Error(message);
-    renderer.error({ error, message });
-    if (error_ instanceof StagedError) {
-      return { failedCommands: runResult.failedCommands, ranTasks: runResult.ranTasks, success: false };
-    }
-    throw error_;
-  } finally {
-    process.removeListener("SIGINT", onInterrupt);
-    process.removeListener("SIGTERM", onInterrupt);
-    if (workflowPrepared) {
-      try {
-        await workflow.cleanup(finalSuccess);
-      } catch (error) {
-        renderer.error({ error, message: "Cleanup failed." });
-      }
-    }
-    await renderer.stop();
-  }
-};
-
-const CONCURRENT_ENV_VAR = "VIS_STAGED_CONCURRENT";
-const parseConcurrent = (value) => {
-  const trimmed = value.trim();
-  if (trimmed === "true" || trimmed === "") {
-    return true;
-  }
-  if (trimmed === "false") {
-    return false;
-  }
-  const parsed = Number(trimmed);
-  return Number.isNaN(parsed) ? true : parsed;
-};
-
-const buildRunOptions = (raw, stagedConfig) => {
-  const options = {};
-  if (stagedConfig !== void 0) {
-    options.config = stagedConfig;
-  }
-  const readBool = (key) => raw[key] === void 0 ? void 0 : Boolean(raw[key]);
-  const readString = (key) => {
-    const value = raw[key];
-    return typeof value === "string" && value.length > 0 ? value : void 0;
-  };
-  const allowEmpty = readBool("allow-empty");
-  if (allowEmpty !== void 0) {
-    options.allowEmpty = allowEmpty;
-  }
-  const autoStage = readBool("auto-stage");
-  if (autoStage !== void 0) {
-    options.autoStage = autoStage;
-  }
-  const continueOnError = readBool("continue-on-error");
-  if (continueOnError !== void 0) {
-    options.continueOnError = continueOnError;
-  }
-  const debug = readBool("debug");
-  if (debug !== void 0) {
-    options.debug = debug;
-  }
-  const failOnChanges = readBool("fail-on-changes");
-  if (failOnChanges !== void 0) {
-    options.failOnChanges = failOnChanges;
-  }
-  const hidePartiallyStaged = readBool("hide-partially-staged");
-  if (hidePartiallyStaged !== void 0) {
-    options.hidePartiallyStaged = hidePartiallyStaged;
-  }
-  const hideUnstaged = readBool("hide-unstaged");
-  if (hideUnstaged !== void 0) {
-    options.hideUnstaged = hideUnstaged;
-  }
-  const quiet = readBool("quiet");
-  if (quiet !== void 0) {
-    options.quiet = quiet;
-  }
-  const relative = readBool("relative");
-  if (relative !== void 0) {
-    options.relative = relative;
-  }
-  const revert = readBool("revert");
-  if (revert !== void 0) {
-    options.revert = revert;
-  }
-  const stash = readBool("stash");
-  if (stash !== void 0) {
-    options.stash = stash;
-  }
-  const verbose = readBool("verbose");
-  if (verbose !== void 0) {
-    options.verbose = verbose;
-  }
-  const cwd = readString("cwd");
-  if (cwd !== void 0) {
-    options.cwd = cwd;
-  }
-  const diff = readString("diff");
-  if (diff !== void 0) {
-    options.diff = diff;
-  }
-  const diffFilter = readString("diff-filter");
-  if (diffFilter !== void 0) {
-    options.diffFilter = diffFilter;
-  }
-  const forceKill = readBool("force-kill");
-  if (forceKill === true) {
-    options.killSignal = "SIGKILL";
-  }
-  if (raw["concurrent"] === void 0) {
-    const envValue = process.env[CONCURRENT_ENV_VAR];
-    if (envValue !== void 0) {
-      options.concurrent = parseConcurrent(envValue.trim());
-    }
-  } else {
-    options.concurrent = parseConcurrent(String(raw["concurrent"]));
-  }
-  return options;
-};
-const execute = async ({ options, visConfig }) => {
-  const config = visConfig ?? {};
-  const stagedConfig = config["staged"];
-  if (!stagedConfig) {
-    throw new Error(
-      "No \"staged\" config found in vis.config.ts. Add one:\n\n  // vis.config.ts\n  import { defineConfig } from \"@visulima/vis/config\";\n\n  export default defineConfig({\n    staged: { '*': 'vis check --fix' },\n  });\n\nMigrating from lint-staged or nano-staged? Run `vis migrate lint-staged` (or `vis migrate nano-staged`) to move the config in and remove the legacy files."
-    );
-  }
-  const result = await runStaged(buildRunOptions(options, stagedConfig));
-  if (!result.success) {
-    process.exitCode = 1;
-  }
-};
 
-export { buildRunOptions, execute as default };
+Migrating from lint-staged or nano-staged? Run \`vis migrate lint-staged\` (or \`vis migrate nano-staged\`) to move the config in and remove the legacy files.`);(await Xt(sr(e,r))).success||(process.exitCode=1)},"execute");export{sr as buildRunOptions,pr as default};