@bitfun-vsl/plugin 0.0.0-stage → 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,4576 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// node_modules/cli-width/index.js
+var require_cli_width = __commonJS(function(exports, module) {
+  module.exports = cliWidth;
+  function normalizeOpts(options) {
+    const defaultOpts = {
+      defaultWidth: 0,
+      output: process.stdout,
+      tty: __require("tty")
+    };
+    if (!options) {
+      return defaultOpts;
+    }
+    Object.keys(defaultOpts).forEach(function(key) {
+      if (!options[key]) {
+        options[key] = defaultOpts[key];
+      }
+    });
+    return options;
+  }
+  function cliWidth(options) {
+    const opts = normalizeOpts(options);
+    if (opts.output.getWindowSize) {
+      return opts.output.getWindowSize()[0] || opts.defaultWidth;
+    }
+    if (opts.tty.getWindowSize) {
+      return opts.tty.getWindowSize()[1] || opts.defaultWidth;
+    }
+    if (opts.output.columns) {
+      return opts.output.columns;
+    }
+    if (process.env.CLI_WIDTH) {
+      const width = parseInt(process.env.CLI_WIDTH, 10);
+      if (!isNaN(width) && width !== 0) {
+        return width;
+      }
+    }
+    return opts.defaultWidth;
+  }
+});
+
+// node_modules/mute-stream/lib/index.js
+var require_lib = __commonJS(function(exports, module) {
+  var Stream = __require("stream");
+
+  class MuteStream extends Stream {
+    #isTTY = null;
+    constructor(opts = {}) {
+      super(opts);
+      this.writable = this.readable = true;
+      this.muted = false;
+      this.on("pipe", this._onpipe);
+      this.replace = opts.replace;
+      this._prompt = opts.prompt || null;
+      this._hadControl = false;
+    }
+    #destSrc(key, def) {
+      if (this._dest) {
+        return this._dest[key];
+      }
+      if (this._src) {
+        return this._src[key];
+      }
+      return def;
+    }
+    #proxy(method, ...args) {
+      if (typeof this._dest?.[method] === "function") {
+        this._dest[method](...args);
+      }
+      if (typeof this._src?.[method] === "function") {
+        this._src[method](...args);
+      }
+    }
+    get isTTY() {
+      if (this.#isTTY !== null) {
+        return this.#isTTY;
+      }
+      return this.#destSrc("isTTY", false);
+    }
+    set isTTY(val) {
+      this.#isTTY = val;
+    }
+    get rows() {
+      return this.#destSrc("rows");
+    }
+    get columns() {
+      return this.#destSrc("columns");
+    }
+    mute() {
+      this.muted = true;
+    }
+    unmute() {
+      this.muted = false;
+    }
+    _onpipe(src) {
+      this._src = src;
+    }
+    pipe(dest, options) {
+      this._dest = dest;
+      return super.pipe(dest, options);
+    }
+    pause() {
+      if (this._src) {
+        return this._src.pause();
+      }
+    }
+    resume() {
+      if (this._src) {
+        return this._src.resume();
+      }
+    }
+    write(c) {
+      if (this.muted) {
+        if (!this.replace) {
+          return true;
+        }
+        if (c.match(/^\u001b/)) {
+          if (c.indexOf(this._prompt) === 0) {
+            c = c.slice(this._prompt.length);
+            c = c.replace(/./g, this.replace);
+            c = this._prompt + c;
+          }
+          this._hadControl = true;
+          return this.emit("data", c);
+        } else {
+          if (this._prompt && this._hadControl && c.indexOf(this._prompt) === 0) {
+            this._hadControl = false;
+            this.emit("data", this._prompt);
+            c = c.slice(this._prompt.length);
+          }
+          c = c.toString().replace(/./g, this.replace);
+        }
+      }
+      this.emit("data", c);
+    }
+    end(c) {
+      if (this.muted) {
+        if (c && this.replace) {
+          c = c.toString().replace(/./g, this.replace);
+        } else {
+          c = null;
+        }
+      }
+      if (c) {
+        this.emit("data", c);
+      }
+      this.emit("end");
+    }
+    destroy(...args) {
+      return this.#proxy("destroy", ...args);
+    }
+    destroySoon(...args) {
+      return this.#proxy("destroySoon", ...args);
+    }
+    close(...args) {
+      return this.#proxy("close", ...args);
+    }
+  }
+  module.exports = MuteStream;
+});
+
+// src/plugin/modules/code-review/runtime.ts
+var exports_runtime = {};
+__export(exports_runtime, {
+  runCr: () => runCr,
+  reviewResult: () => reviewResult,
+  review: () => review,
+  resolveCr: () => resolveCr,
+  health: () => health
+});
+import { spawn } from "child_process";
+import { createWriteStream } from "fs";
+import { access, mkdir, readFile, realpath, stat } from "fs/promises";
+import { homedir } from "os";
+import { delimiter, isAbsolute, join as join2, resolve as resolve2 } from "path";
+import { pipeline } from "stream/promises";
+async function review(input, context, options) {
+  if (Boolean(input.from) !== Boolean(input.to))
+    throw new Error("from and to must be provided together");
+  if (input.commit && (input.from || input.to))
+    throw new Error("commit cannot be combined with from/to");
+  if (input.preview && input.resume)
+    throw new Error("preview cannot be combined with resume");
+  if (input.resume && !input.commit && !input.from)
+    throw new Error("resume requires commit or from/to; workspace resume is not supported");
+  const directory = await realpath(resolve2(context.directory, input.repo ?? "."));
+  const args = ["review", "--repo", directory, "--audience", "agent", "--format", "json"];
+  const flags = {
+    commit: "commit",
+    from: "from",
+    to: "to",
+    resume: "resume",
+    background: "background",
+    backgroundFile: "background-file",
+    rule: "rule",
+    provider: "provider",
+    model: "model",
+    effort: "effort",
+    concurrency: "concurrency",
+    taskTimeoutMinutes: "timeout",
+    maxTokensBudget: "max-tokens-budget"
+  };
+  Object.entries(flags).forEach(([key, flag]) => {
+    const value = input[key];
+    if (value !== undefined)
+      args.push(`--${flag}`, String(value));
+  });
+  if (input.preview)
+    args.push("--preview");
+  if (input.exclude?.length)
+    args.push("--exclude", input.exclude.join(","));
+  context.report(input.preview ? "Previewing CR review scope" : "Running CR review");
+  const result = await runCr(await resolveCr(options.binary), args, {
+    directory,
+    signal: context.signal,
+    timeoutMs: (input.overallTimeoutMinutes ?? 60) * 60000,
+    cacheDirectory: options.cacheDirectory
+  });
+  return reviewResult(result, directory, input.preview);
+}
+async function reviewResult(result, directory, preview = false) {
+  const text = await readFile(result.resultFile, "utf8");
+  const parsed = await Promise.resolve().then(() => JSON.parse(text)).catch(() => {
+    return;
+  });
+  const payload = record(parsed);
+  const manifest = record(payload?.manifest);
+  const coverage = record(manifest?.coverage);
+  const terminal = manifest?.terminal_state;
+  const knownState = typeof terminal === "string" && ["complete", "partial", "failed", "skipped"].includes(terminal);
+  const validCoverage = ["selected", "completed", "reused", "failed", "waived"].every((key) => Array.isArray(coverage?.[key]));
+  const validReview = knownState && manifest?.schema_version === "cr.run-manifest/v1" && validCoverage && Array.isArray(payload?.comments);
+  const noFiles = !manifest && payload?.status === "skipped" && Array.isArray(payload.comments) && payload.comments.length === 0 && typeof payload.message === "string";
+  const validPreview = preview && typeof payload?.total_files === "number" && typeof payload.reviewable_count === "number" && Array.isArray(payload.files);
+  const diagnostic = (await readFile(result.stderrFile, "utf8")).slice(-4000);
+  const error = result.error || (result.exitCode !== 0 ? `CR exited with code ${result.exitCode}` : undefined) || (!(preview ? validPreview : validReview || noFiles) ? "CR returned empty, invalid, or incompatible JSON; review completion is unknown" : undefined);
+  const comments = Array.isArray(payload?.comments) ? payload.comments : [];
+  const metadata = {
+    repository: directory,
+    executable: result.executable,
+    exitCode: result.exitCode,
+    state: validReview ? terminal : !error && validPreview ? "preview" : !error && noFiles ? "skipped" : "error",
+    terminalState: knownState ? terminal : undefined,
+    message: typeof payload?.message === "string" ? payload.message.slice(0, 1000) : undefined,
+    sessionId: payload?.session_id,
+    resultFile: result.resultFile,
+    stderrFile: result.stderrFile
+  };
+  const output = JSON.stringify({
+    ...metadata,
+    error,
+    ...error ? { diagnostic } : {},
+    manifest,
+    summary: payload?.summary,
+    warnings: payload?.warnings,
+    resume: payload?.resume,
+    ...preview ? { preview: payload } : {
+      findingsCount: comments.length,
+      comments: text.length > 48000 ? [] : comments.slice(0, 30),
+      findingsTruncated: comments.length > 30 || text.length > 48000
+    }
+  });
+  return {
+    title: error ? "CR execution failed" : preview ? "CR preview ready" : `CR review: ${metadata.state}`,
+    isError: Boolean(error || terminal === "failed"),
+    metadata,
+    output: output.length <= 64000 ? output : JSON.stringify({
+      ...metadata,
+      error,
+      diagnostic: error ? diagnostic : undefined,
+      findingsCount: comments.length,
+      coverageCounts: Object.fromEntries(Object.entries(coverage ?? {}).filter(([, value]) => Array.isArray(value)).map(([key, value]) => [key, value.length])),
+      detailsTruncated: true,
+      findingsTruncated: !preview,
+      instruction: "Read resultFile in bounded batches for the complete review/preview, findings, warnings and coverage."
+    })
+  };
+}
+async function health(input, context, options) {
+  const executable = await resolveCr(options.binary);
+  const version = await runCr(executable, ["version"], { directory: context.directory, signal: context.signal, timeoutMs: 30000, cacheDirectory: options.cacheDirectory });
+  const help = await runCr(executable, ["review", "--help"], { directory: context.directory, signal: context.signal, timeoutMs: 30000, cacheDirectory: options.cacheDirectory });
+  const helpText = await readFile(help.resultFile, "utf8");
+  const compatible = ["--format", "--audience", "--preview", "--resume", "--max-tokens-budget"].every((flag) => helpText.includes(flag));
+  const connection = input.checkConnection ? await runCr(executable, ["llm", "test"], {
+    directory: context.directory,
+    signal: context.signal,
+    timeoutMs: 120000,
+    cacheDirectory: options.cacheDirectory
+  }) : undefined;
+  const isError = !compatible || [version, help, ...connection ? [connection] : []].some((item) => item.error || item.exitCode !== 0);
+  return {
+    title: isError ? "CR health check failed" : "CR is available",
+    isError,
+    output: JSON.stringify({
+      executable,
+      version: (await readFile(version.resultFile, "utf8")).trim(),
+      cliFlagsCompatible: compatible,
+      manifestCompatibility: "Validated against cr.run-manifest/v1 when an actual review runs",
+      modelConnection: connection ? { exitCode: connection.exitCode, error: connection.error, output: (await readFile(connection.resultFile, "utf8")).trim(), stderrFile: connection.stderrFile } : "not checked",
+      diagnostics: [version, help]
+    })
+  };
+}
+async function resolveCr(binary = process.env.VSL_CR_BIN) {
+  if (binary) {
+    if (!isAbsolute(binary))
+      throw new Error("VSL_CR_BIN must be an absolute path to the native CR executable");
+    if (/\.(cmd|bat|ps1|js)$/i.test(binary))
+      throw new Error("VSL_CR_BIN must point to the native executable, not a shell or npm shim");
+    await access(binary);
+    return realpath(binary);
+  }
+  const names = process.platform === "win32" ? ["cr.exe"] : ["cr"];
+  const candidates = (process.env.PATH ?? "").split(delimiter).filter(Boolean).flatMap((directory) => names.map((name) => join2(directory, name)));
+  const found = await Promise.all(candidates.map(async (path2) => await access(path2).then(() => path2, () => {
+    return;
+  })));
+  const executable = found.find((path2) => path2 !== undefined);
+  if (!executable)
+    throw new Error("CR native executable not found. Install/build the review CLI and set VSL_CR_BIN to its absolute executable path.");
+  return realpath(executable);
+}
+async function runCr(executable, args, options) {
+  options.signal.throwIfAborted();
+  const directory = join2(options.cacheDirectory ?? process.env.VSL_CR_CACHE_DIR ?? join2(process.env.LOCALAPPDATA ?? process.env.XDG_CACHE_HOME ?? join2(homedir(), ".cache"), "vsl", "cr"), crypto.randomUUID());
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const resultFile = join2(directory, "result.json");
+  const stderrFile = join2(directory, "stderr.log");
+  const child = spawn(executable, args, {
+    cwd: options.directory,
+    env: { ...process.env, CR_NO_UPDATE: "1" },
+    shell: false,
+    detached: process.platform !== "win32",
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let error;
+  let closed = false;
+  let forceTimer;
+  const kill = () => {
+    if (closed || !child.pid)
+      return;
+    if (process.platform === "win32") {
+      spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" }).on("error", () => child.kill("SIGKILL"));
+      return;
+    }
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {
+      child.kill("SIGTERM");
+    }
+    forceTimer = setTimeout(() => {
+      if (!closed && child.pid) {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+          child.kill("SIGKILL");
+        }
+      }
+    }, 3000);
+  };
+  const stop = (message) => {
+    if (error)
+      return;
+    error = message;
+    kill();
+  };
+  const abort = () => stop("CR execution cancelled");
+  const timer = setTimeout(() => stop("CR overall execution deadline exceeded"), options.timeoutMs);
+  options.signal.addEventListener("abort", abort, { once: true });
+  if (options.signal.aborted)
+    abort();
+  child.on("error", (cause) => {
+    error ??= `Cannot start CR: ${cause.message}`;
+  });
+  const streams = Promise.all([
+    pipeline(child.stdout, createWriteStream(resultFile, { mode: 384 })),
+    pipeline(child.stderr, createWriteStream(stderrFile, { mode: 384 }))
+  ]).catch((cause) => stop(`Cannot save CR output: ${cause instanceof Error ? cause.message : String(cause)}`));
+  let outputBytes = 0;
+  [child.stdout, child.stderr].forEach((stream) => stream.on("data", (chunk) => {
+    outputBytes += chunk.length;
+    if (outputBytes > 32 * 1024 * 1024)
+      stop("CR output exceeds 32 MiB; partial evidence retained on disk");
+  }));
+  const exitCode = await new Promise((done) => child.once("close", (code) => {
+    closed = true;
+    clearTimeout(timer);
+    clearTimeout(forceTimer);
+    options.signal.removeEventListener("abort", abort);
+    done(code);
+  }));
+  await streams;
+  const size = (await stat(resultFile)).size;
+  if (size > 32 * 1024 * 1024)
+    throw new Error(`CR JSON exceeds the 32 MiB parsing limit; full output: ${resultFile}; stderr: ${stderrFile}`);
+  return { executable, exitCode, resultFile, stderrFile, error };
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+var init_runtime = () => {};
+
+// node_modules/@inquirer/core/dist/lib/key.js
+var keybindings = ["emacs", "vim"];
+var keybindingLookup = new Set(keybindings);
+function isKeybinding(value) {
+  return keybindingLookup.has(value);
+}
+function getDefaultKeybindings() {
+  const env = process.env["INQUIRER_KEYBINDINGS"];
+  if (!env)
+    return [];
+  return Array.from(new Set(env.toLowerCase().split(/[\s,]+/).filter(isKeybinding)));
+}
+var isUpKey = (key, keybindings2 = []) => key.name === "up" || keybindings2.includes("vim") && key.name === "k" || keybindings2.includes("emacs") && key.ctrl && key.name === "p";
+var isDownKey = (key, keybindings2 = []) => key.name === "down" || keybindings2.includes("vim") && key.name === "j" || keybindings2.includes("emacs") && key.ctrl && key.name === "n";
+var isSpaceKey = (key) => key.name === "space";
+var isTabKey = (key) => key.name === "tab";
+var isNumberKey = (key) => "1234567890".includes(key.name);
+var isEnterKey = (key) => key.name === "enter" || key.name === "return";
+// node_modules/@inquirer/core/dist/lib/errors.js
+class AbortPromptError extends Error {
+  name = "AbortPromptError";
+  message = "Prompt was aborted";
+  constructor(options) {
+    super();
+    this.cause = options?.cause;
+  }
+}
+
+class CancelPromptError extends Error {
+  name = "CancelPromptError";
+  message = "Prompt was canceled";
+}
+
+class ExitPromptError extends Error {
+  name = "ExitPromptError";
+}
+
+class HookError extends Error {
+  name = "HookError";
+}
+
+class ValidationError extends Error {
+  name = "ValidationError";
+}
+// node_modules/@inquirer/core/dist/lib/use-state.js
+import { AsyncResource as AsyncResource2 } from "async_hooks";
+
+// node_modules/@inquirer/core/dist/lib/hook-engine.js
+import { AsyncLocalStorage, AsyncResource } from "async_hooks";
+var hookStorage = new AsyncLocalStorage;
+function createStore(rl) {
+  const store = {
+    rl,
+    hooks: [],
+    hooksCleanup: [],
+    hooksEffect: [],
+    index: 0,
+    handleChange() {}
+  };
+  return store;
+}
+function withHooks(rl, cb) {
+  const store = createStore(rl);
+  function cycle(render) {
+    store.handleChange = () => {
+      store.index = 0;
+      render();
+    };
+    store.handleChange();
+  }
+  return hookStorage.run(store, () => cb(cycle));
+}
+function getStore() {
+  const store = hookStorage.getStore();
+  if (!store) {
+    throw new HookError("[Inquirer] Hook functions can only be called from within a prompt");
+  }
+  return store;
+}
+function readline() {
+  return getStore().rl;
+}
+function withUpdates(fn) {
+  const wrapped = (...args) => {
+    const store = getStore();
+    let shouldUpdate = false;
+    const oldHandleChange = store.handleChange;
+    store.handleChange = () => {
+      shouldUpdate = true;
+    };
+    const returnValue = fn(...args);
+    if (shouldUpdate) {
+      oldHandleChange();
+    }
+    store.handleChange = oldHandleChange;
+    return returnValue;
+  };
+  return AsyncResource.bind(wrapped);
+}
+function withPointer(cb) {
+  const store = getStore();
+  const { index } = store;
+  const pointer = {
+    get() {
+      return store.hooks[index];
+    },
+    set(value) {
+      store.hooks[index] = value;
+    },
+    initialized: index in store.hooks
+  };
+  const returnValue = cb(pointer);
+  store.index++;
+  return returnValue;
+}
+function handleChange() {
+  getStore().handleChange();
+}
+var effectScheduler = {
+  queue(cb) {
+    const store = getStore();
+    const { index } = store;
+    store.hooksEffect.push(() => {
+      store.hooksCleanup[index]?.();
+      const cleanFn = cb(readline());
+      if (cleanFn != null && typeof cleanFn !== "function") {
+        throw new ValidationError("useEffect return value must be a cleanup function or nothing.");
+      }
+      store.hooksCleanup[index] = cleanFn;
+    });
+  },
+  run() {
+    const store = getStore();
+    withUpdates(() => {
+      store.hooksEffect.forEach((effect) => {
+        effect();
+      });
+      store.hooksEffect.length = 0;
+    })();
+  },
+  clearAll() {
+    const store = getStore();
+    store.hooksCleanup.forEach((cleanFn) => {
+      cleanFn?.();
+    });
+    store.hooksEffect.length = 0;
+    store.hooksCleanup.length = 0;
+  }
+};
+
+// node_modules/@inquirer/core/dist/lib/use-state.js
+function isFactory(value) {
+  return typeof value === "function";
+}
+function isReducer(value) {
+  return typeof value === "function";
+}
+function useState(defaultValue) {
+  return withPointer((pointer) => {
+    const setState = AsyncResource2.bind(function setState2(newValue) {
+      const currentValue = pointer.get();
+      const nextValue = isReducer(newValue) ? newValue(currentValue) : newValue;
+      if (!Object.is(currentValue, nextValue)) {
+        pointer.set(nextValue);
+        handleChange();
+      }
+    });
+    if (pointer.initialized) {
+      return [pointer.get(), setState];
+    }
+    const value = isFactory(defaultValue) ? defaultValue() : defaultValue;
+    pointer.set(value);
+    return [value, setState];
+  });
+}
+
+// node_modules/@inquirer/core/dist/lib/use-effect.js
+function useEffect(cb, depArray) {
+  withPointer((pointer) => {
+    const oldDeps = pointer.get();
+    const hasChanged = !Array.isArray(oldDeps) || depArray.some((dep, i) => !Object.is(dep, oldDeps[i]));
+    if (hasChanged) {
+      effectScheduler.queue(cb);
+    }
+    pointer.set(depArray);
+  });
+}
+
+// node_modules/@inquirer/core/dist/lib/theme.js
+import { styleText } from "util";
+
+// node_modules/@inquirer/figures/dist/index.js
+import process2 from "process";
+function isUnicodeSupported() {
+  if (!process2.platform.startsWith("win")) {
+    return process2.env["TERM"] !== "linux";
+  }
+  return Boolean(process2.env["CI"]) || Boolean(process2.env["WT_SESSION"]) || Boolean(process2.env["TERMINUS_SUBLIME"]) || process2.env["ConEmuTask"] === "{cmd::Cmder}" || process2.env["TERM_PROGRAM"] === "Terminus-Sublime" || process2.env["TERM_PROGRAM"] === "vscode" || process2.env["TERM"] === "xterm-256color" || process2.env["TERM"] === "alacritty" || process2.env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
+}
+var common = {
+  circleQuestionMark: "(?)",
+  questionMarkPrefix: "(?)",
+  square: "\u2588",
+  squareDarkShade: "\u2593",
+  squareMediumShade: "\u2592",
+  squareLightShade: "\u2591",
+  squareTop: "\u2580",
+  squareBottom: "\u2584",
+  squareLeft: "\u258C",
+  squareRight: "\u2590",
+  squareCenter: "\u25A0",
+  bullet: "\u25CF",
+  dot: "\u2024",
+  ellipsis: "\u2026",
+  pointerSmall: "\u203A",
+  triangleUp: "\u25B2",
+  triangleUpSmall: "\u25B4",
+  triangleDown: "\u25BC",
+  triangleDownSmall: "\u25BE",
+  triangleLeftSmall: "\u25C2",
+  triangleRightSmall: "\u25B8",
+  home: "\u2302",
+  heart: "\u2665",
+  musicNote: "\u266A",
+  musicNoteBeamed: "\u266B",
+  arrowUp: "\u2191",
+  arrowDown: "\u2193",
+  arrowLeft: "\u2190",
+  arrowRight: "\u2192",
+  arrowLeftRight: "\u2194",
+  arrowUpDown: "\u2195",
+  almostEqual: "\u2248",
+  notEqual: "\u2260",
+  lessOrEqual: "\u2264",
+  greaterOrEqual: "\u2265",
+  identical: "\u2261",
+  infinity: "\u221E",
+  subscriptZero: "\u2080",
+  subscriptOne: "\u2081",
+  subscriptTwo: "\u2082",
+  subscriptThree: "\u2083",
+  subscriptFour: "\u2084",
+  subscriptFive: "\u2085",
+  subscriptSix: "\u2086",
+  subscriptSeven: "\u2087",
+  subscriptEight: "\u2088",
+  subscriptNine: "\u2089",
+  oneHalf: "\xBD",
+  oneThird: "\u2153",
+  oneQuarter: "\xBC",
+  oneFifth: "\u2155",
+  oneSixth: "\u2159",
+  oneEighth: "\u215B",
+  twoThirds: "\u2154",
+  twoFifths: "\u2156",
+  threeQuarters: "\xBE",
+  threeFifths: "\u2157",
+  threeEighths: "\u215C",
+  fourFifths: "\u2158",
+  fiveSixths: "\u215A",
+  fiveEighths: "\u215D",
+  sevenEighths: "\u215E",
+  line: "\u2500",
+  lineBold: "\u2501",
+  lineDouble: "\u2550",
+  lineDashed0: "\u2504",
+  lineDashed1: "\u2505",
+  lineDashed2: "\u2508",
+  lineDashed3: "\u2509",
+  lineDashed4: "\u254C",
+  lineDashed5: "\u254D",
+  lineDashed6: "\u2574",
+  lineDashed7: "\u2576",
+  lineDashed8: "\u2578",
+  lineDashed9: "\u257A",
+  lineDashed10: "\u257C",
+  lineDashed11: "\u257E",
+  lineDashed12: "\u2212",
+  lineDashed13: "\u2013",
+  lineDashed14: "\u2010",
+  lineDashed15: "\u2043",
+  lineVertical: "\u2502",
+  lineVerticalBold: "\u2503",
+  lineVerticalDouble: "\u2551",
+  lineVerticalDashed0: "\u2506",
+  lineVerticalDashed1: "\u2507",
+  lineVerticalDashed2: "\u250A",
+  lineVerticalDashed3: "\u250B",
+  lineVerticalDashed4: "\u254E",
+  lineVerticalDashed5: "\u254F",
+  lineVerticalDashed6: "\u2575",
+  lineVerticalDashed7: "\u2577",
+  lineVerticalDashed8: "\u2579",
+  lineVerticalDashed9: "\u257B",
+  lineVerticalDashed10: "\u257D",
+  lineVerticalDashed11: "\u257F",
+  lineDownLeft: "\u2510",
+  lineDownLeftArc: "\u256E",
+  lineDownBoldLeftBold: "\u2513",
+  lineDownBoldLeft: "\u2512",
+  lineDownLeftBold: "\u2511",
+  lineDownDoubleLeftDouble: "\u2557",
+  lineDownDoubleLeft: "\u2556",
+  lineDownLeftDouble: "\u2555",
+  lineDownRight: "\u250C",
+  lineDownRightArc: "\u256D",
+  lineDownBoldRightBold: "\u250F",
+  lineDownBoldRight: "\u250E",
+  lineDownRightBold: "\u250D",
+  lineDownDoubleRightDouble: "\u2554",
+  lineDownDoubleRight: "\u2553",
+  lineDownRightDouble: "\u2552",
+  lineUpLeft: "\u2518",
+  lineUpLeftArc: "\u256F",
+  lineUpBoldLeftBold: "\u251B",
+  lineUpBoldLeft: "\u251A",
+  lineUpLeftBold: "\u2519",
+  lineUpDoubleLeftDouble: "\u255D",
+  lineUpDoubleLeft: "\u255C",
+  lineUpLeftDouble: "\u255B",
+  lineUpRight: "\u2514",
+  lineUpRightArc: "\u2570",
+  lineUpBoldRightBold: "\u2517",
+  lineUpBoldRight: "\u2516",
+  lineUpRightBold: "\u2515",
+  lineUpDoubleRightDouble: "\u255A",
+  lineUpDoubleRight: "\u2559",
+  lineUpRightDouble: "\u2558",
+  lineUpDownLeft: "\u2524",
+  lineUpBoldDownBoldLeftBold: "\u252B",
+  lineUpBoldDownBoldLeft: "\u2528",
+  lineUpDownLeftBold: "\u2525",
+  lineUpBoldDownLeftBold: "\u2529",
+  lineUpDownBoldLeftBold: "\u252A",
+  lineUpDownBoldLeft: "\u2527",
+  lineUpBoldDownLeft: "\u2526",
+  lineUpDoubleDownDoubleLeftDouble: "\u2563",
+  lineUpDoubleDownDoubleLeft: "\u2562",
+  lineUpDownLeftDouble: "\u2561",
+  lineUpDownRight: "\u251C",
+  lineUpBoldDownBoldRightBold: "\u2523",
+  lineUpBoldDownBoldRight: "\u2520",
+  lineUpDownRightBold: "\u251D",
+  lineUpBoldDownRightBold: "\u2521",
+  lineUpDownBoldRightBold: "\u2522",
+  lineUpDownBoldRight: "\u251F",
+  lineUpBoldDownRight: "\u251E",
+  lineUpDoubleDownDoubleRightDouble: "\u2560",
+  lineUpDoubleDownDoubleRight: "\u255F",
+  lineUpDownRightDouble: "\u255E",
+  lineDownLeftRight: "\u252C",
+  lineDownBoldLeftBoldRightBold: "\u2533",
+  lineDownLeftBoldRightBold: "\u252F",
+  lineDownBoldLeftRight: "\u2530",
+  lineDownBoldLeftBoldRight: "\u2531",
+  lineDownBoldLeftRightBold: "\u2532",
+  lineDownLeftRightBold: "\u252E",
+  lineDownLeftBoldRight: "\u252D",
+  lineDownDoubleLeftDoubleRightDouble: "\u2566",
+  lineDownDoubleLeftRight: "\u2565",
+  lineDownLeftDoubleRightDouble: "\u2564",
+  lineUpLeftRight: "\u2534",
+  lineUpBoldLeftBoldRightBold: "\u253B",
+  lineUpLeftBoldRightBold: "\u2537",
+  lineUpBoldLeftRight: "\u2538",
+  lineUpBoldLeftBoldRight: "\u2539",
+  lineUpBoldLeftRightBold: "\u253A",
+  lineUpLeftRightBold: "\u2536",
+  lineUpLeftBoldRight: "\u2535",
+  lineUpDoubleLeftDoubleRightDouble: "\u2569",
+  lineUpDoubleLeftRight: "\u2568",
+  lineUpLeftDoubleRightDouble: "\u2567",
+  lineUpDownLeftRight: "\u253C",
+  lineUpBoldDownBoldLeftBoldRightBold: "\u254B",
+  lineUpDownBoldLeftBoldRightBold: "\u2548",
+  lineUpBoldDownLeftBoldRightBold: "\u2547",
+  lineUpBoldDownBoldLeftRightBold: "\u254A",
+  lineUpBoldDownBoldLeftBoldRight: "\u2549",
+  lineUpBoldDownLeftRight: "\u2540",
+  lineUpDownBoldLeftRight: "\u2541",
+  lineUpDownLeftBoldRight: "\u253D",
+  lineUpDownLeftRightBold: "\u253E",
+  lineUpBoldDownBoldLeftRight: "\u2542",
+  lineUpDownLeftBoldRightBold: "\u253F",
+  lineUpBoldDownLeftBoldRight: "\u2543",
+  lineUpBoldDownLeftRightBold: "\u2544",
+  lineUpDownBoldLeftBoldRight: "\u2545",
+  lineUpDownBoldLeftRightBold: "\u2546",
+  lineUpDoubleDownDoubleLeftDoubleRightDouble: "\u256C",
+  lineUpDoubleDownDoubleLeftRight: "\u256B",
+  lineUpDownLeftDoubleRightDouble: "\u256A",
+  lineCross: "\u2573",
+  lineBackslash: "\u2572",
+  lineSlash: "\u2571"
+};
+var specialMainSymbols = {
+  tick: "\u2714",
+  info: "\u2139",
+  warning: "\u26A0",
+  cross: "\u2718",
+  squareSmall: "\u25FB",
+  squareSmallFilled: "\u25FC",
+  circle: "\u25EF",
+  circleFilled: "\u25C9",
+  circleDotted: "\u25CC",
+  circleDouble: "\u25CE",
+  circleCircle: "\u24DE",
+  circleCross: "\u24E7",
+  circlePipe: "\u24BE",
+  radioOn: "\u25C9",
+  radioOff: "\u25EF",
+  checkboxOn: "\u2612",
+  checkboxOff: "\u2610",
+  checkboxCircleOn: "\u24E7",
+  checkboxCircleOff: "\u24BE",
+  pointer: "\u276F",
+  triangleUpOutline: "\u25B3",
+  triangleLeft: "\u25C0",
+  triangleRight: "\u25B6",
+  lozenge: "\u25C6",
+  lozengeOutline: "\u25C7",
+  hamburger: "\u2630",
+  smiley: "\u32E1",
+  mustache: "\u0DF4",
+  star: "\u2605",
+  play: "\u25B6",
+  nodejs: "\u2B22",
+  oneSeventh: "\u2150",
+  oneNinth: "\u2151",
+  oneTenth: "\u2152"
+};
+var specialFallbackSymbols = {
+  tick: "\u221A",
+  info: "i",
+  warning: "\u203C",
+  cross: "\xD7",
+  squareSmall: "\u25A1",
+  squareSmallFilled: "\u25A0",
+  circle: "( )",
+  circleFilled: "(*)",
+  circleDotted: "( )",
+  circleDouble: "( )",
+  circleCircle: "(\u25CB)",
+  circleCross: "(\xD7)",
+  circlePipe: "(\u2502)",
+  radioOn: "(*)",
+  radioOff: "( )",
+  checkboxOn: "[\xD7]",
+  checkboxOff: "[ ]",
+  checkboxCircleOn: "(\xD7)",
+  checkboxCircleOff: "( )",
+  pointer: ">",
+  triangleUpOutline: "\u2206",
+  triangleLeft: "\u25C4",
+  triangleRight: "\u25BA",
+  lozenge: "\u2666",
+  lozengeOutline: "\u25CA",
+  hamburger: "\u2261",
+  smiley: "\u263A",
+  mustache: "\u250C\u2500\u2510",
+  star: "\u2736",
+  play: "\u25BA",
+  nodejs: "\u2666",
+  oneSeventh: "1/7",
+  oneNinth: "1/9",
+  oneTenth: "1/10"
+};
+var mainSymbols = {
+  ...common,
+  ...specialMainSymbols
+};
+var fallbackSymbols = {
+  ...common,
+  ...specialFallbackSymbols
+};
+var shouldUseMain = isUnicodeSupported();
+var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
+var dist_default = figures;
+var replacements = Object.entries(specialMainSymbols);
+
+// node_modules/@inquirer/core/dist/lib/theme.js
+var defaultTheme = {
+  prefix: {
+    idle: styleText("blue", "?"),
+    done: styleText("green", dist_default.tick)
+  },
+  spinner: {
+    interval: 80,
+    frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"].map((frame) => styleText("yellow", frame))
+  },
+  keybindings: [],
+  style: {
+    answer: (text) => styleText("cyan", text),
+    message: (text) => styleText("bold", text),
+    error: (text) => styleText("red", `> ${text}`),
+    defaultAnswer: (text) => styleText("dim", `(${text})`),
+    help: (text) => styleText("dim", text),
+    highlight: (text) => styleText("cyan", text),
+    key: (text) => styleText("cyan", styleText("bold", `<${text}>`))
+  }
+};
+function getDefaultTheme() {
+  return {
+    ...defaultTheme,
+    keybindings: getDefaultKeybindings()
+  };
+}
+
+// node_modules/@inquirer/core/dist/lib/make-theme.js
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  let proto = value;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value) === proto;
+}
+function deepMerge(...objects) {
+  const output = {};
+  for (const obj of objects) {
+    for (const [key, value] of Object.entries(obj)) {
+      const prevValue = output[key];
+      output[key] = isPlainObject(prevValue) && isPlainObject(value) ? deepMerge(prevValue, value) : value;
+    }
+  }
+  return output;
+}
+function makeTheme(...themes) {
+  const themesToMerge = [
+    getDefaultTheme(),
+    ...themes.filter((theme) => theme != null)
+  ];
+  return deepMerge(...themesToMerge);
+}
+
+// node_modules/@inquirer/core/dist/lib/use-prefix.js
+function usePrefix({ status = "idle", theme }) {
+  const [showLoader, setShowLoader] = useState(false);
+  const [tick, setTick] = useState(0);
+  const { prefix, spinner } = makeTheme(theme);
+  useEffect(() => {
+    if (status === "loading") {
+      let tickInterval;
+      let inc = -1;
+      const delayTimeout = setTimeout(() => {
+        setShowLoader(true);
+        tickInterval = setInterval(() => {
+          inc = inc + 1;
+          setTick(inc % spinner.frames.length);
+        }, spinner.interval);
+      }, 300);
+      return () => {
+        clearTimeout(delayTimeout);
+        clearInterval(tickInterval);
+      };
+    } else {
+      setShowLoader(false);
+    }
+  }, [status]);
+  if (showLoader) {
+    return spinner.frames[tick];
+  }
+  const iconName = status === "loading" ? "idle" : status;
+  return typeof prefix === "string" ? prefix : prefix[iconName] ?? prefix["idle"];
+}
+// node_modules/@inquirer/core/dist/lib/use-memo.js
+function useMemo(fn, dependencies) {
+  return withPointer((pointer) => {
+    const prev = pointer.get();
+    if (!pointer.initialized || prev.dependencies.length !== dependencies.length || prev.dependencies.some((dep, i) => dep !== dependencies[i])) {
+      const value = fn();
+      pointer.set({ value, dependencies });
+      return value;
+    }
+    return prev.value;
+  });
+}
+// node_modules/@inquirer/core/dist/lib/use-ref.js
+function useRef(val) {
+  return useState({ current: val })[0];
+}
+
+// node_modules/@inquirer/core/dist/lib/use-keypress.js
+function useKeypress(userHandler) {
+  const signal = useRef(userHandler);
+  signal.current = userHandler;
+  useEffect((rl) => {
+    let ignore = false;
+    const handler = withUpdates((_input, event) => {
+      if (ignore)
+        return;
+      signal.current(event, rl);
+    });
+    rl.input.on("keypress", handler);
+    return () => {
+      ignore = true;
+      rl.input.removeListener("keypress", handler);
+    };
+  }, []);
+}
+// node_modules/@inquirer/core/dist/lib/utils.js
+var import_cli_width = __toESM(require_cli_width(), 1);
+
+// node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer:
+    while (true) {
+      if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+        const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+        lengthExtra = 0;
+        for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+          const codePoint = char.codePointAt(0) || 0;
+          if (isFullWidth(codePoint)) {
+            widthExtra = FULL_WIDTH_WIDTH;
+          } else if (isWideNotCJKTNotEmoji(codePoint)) {
+            widthExtra = WIDE_WIDTH;
+          } else {
+            widthExtra = REGULAR_WIDTH;
+          }
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          lengthExtra += char.length;
+          width += widthExtra;
+        }
+        unmatchedStart = unmatchedEnd = 0;
+      }
+      if (index >= length) {
+        break outer;
+      }
+      for (let i = 0, l = PARSE_BLOCKS.length;i < l; i++) {
+        const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+        BLOCK_RE.lastIndex = index;
+        if (BLOCK_RE.test(input)) {
+          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+          widthExtra = lengthExtra * BLOCK_WIDTH;
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          width += widthExtra;
+          unmatchedStart = indexPrev;
+          unmatchedEnd = index;
+          index = indexPrev = BLOCK_RE.lastIndex;
+          continue outer;
+        }
+      }
+      index += 1;
+    }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default2 = getStringTruncatedWidth;
+
+// node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default2(input, NO_TRUNCATION2, options).width;
+};
+var dist_default3 = fastStringWidth;
+
+// node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === undefined ? 0 : dist_default3(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default3(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default3(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0;index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default3(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default3(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default3(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join(`
+`);
+  let inSurrogate = false;
+  for (let i = 0;i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== undefined) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? undefined : code;
+      } else if (groups?.uri !== undefined) {
+        escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+      }
+    }
+    if (preString[i + 1] === `
+`) {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === `
+`) {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join(`
+`);
+}
+
+// node_modules/@inquirer/core/dist/lib/utils.js
+function breakLines(content, width) {
+  return content.split(`
+`).flatMap((line) => wrapAnsi(line, width, { trim: false, wordWrap: false }).split(`
+`).map((str) => str.trimEnd())).join(`
+`);
+}
+function readlineWidth() {
+  return import_cli_width.default({ defaultWidth: 80, output: readline().output });
+}
+
+// node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js
+function usePointerPosition({ active, renderedItems, pageSize, loop }) {
+  const state = useRef({
+    lastPointer: active,
+    lastActive: undefined
+  });
+  const { lastPointer, lastActive } = state.current;
+  const middle = Math.floor(pageSize / 2);
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const defaultPointerPosition = renderedItems.slice(0, active).reduce((acc, item) => acc + item.length, 0);
+  let pointer = defaultPointerPosition;
+  if (renderedLength > pageSize) {
+    if (loop) {
+      pointer = lastPointer;
+      if (lastActive != null && lastActive < active && active - lastActive < pageSize) {
+        pointer = Math.min(middle, Math.abs(active - lastActive) === 1 ? Math.min(lastPointer + (renderedItems[lastActive]?.length ?? 0), Math.max(defaultPointerPosition, lastPointer)) : lastPointer + active - lastActive);
+      }
+    } else {
+      const spaceUnderActive = renderedItems.slice(active).reduce((acc, item) => acc + item.length, 0);
+      pointer = spaceUnderActive < pageSize - middle ? pageSize - spaceUnderActive : Math.min(defaultPointerPosition, middle);
+    }
+  }
+  state.current.lastPointer = pointer;
+  state.current.lastActive = active;
+  return pointer;
+}
+function usePagination({ items, active, renderItem, pageSize, loop = true }) {
+  const width = readlineWidth();
+  const bound = (num) => (num % items.length + items.length) % items.length;
+  const renderedItems = items.map((item, index) => {
+    if (item == null)
+      return [];
+    return breakLines(renderItem({ item, index, isActive: index === active }), width).split(`
+`);
+  });
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const renderItemAtIndex = (index) => renderedItems[index] ?? [];
+  const pointer = usePointerPosition({ active, renderedItems, pageSize, loop });
+  const activeItem = renderItemAtIndex(active).slice(0, pageSize);
+  const activeItemPosition = pointer + activeItem.length <= pageSize ? pointer : pageSize - activeItem.length;
+  const pageBuffer = Array.from({ length: pageSize });
+  pageBuffer.splice(activeItemPosition, activeItem.length, ...activeItem);
+  const itemVisited = new Set([active]);
+  let bufferPointer = activeItemPosition + activeItem.length;
+  let itemPointer = bound(active + 1);
+  while (bufferPointer < pageSize && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer > active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(0, pageSize - bufferPointer);
+    pageBuffer.splice(bufferPointer, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer += linesToAdd.length;
+    itemPointer = bound(itemPointer + 1);
+  }
+  bufferPointer = activeItemPosition - 1;
+  itemPointer = bound(active - 1);
+  while (bufferPointer >= 0 && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer < active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(Math.max(0, lines.length - bufferPointer - 1));
+    pageBuffer.splice(bufferPointer - linesToAdd.length + 1, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer -= linesToAdd.length;
+    itemPointer = bound(itemPointer - 1);
+  }
+  return pageBuffer.filter((line) => typeof line === "string").join(`
+`);
+}
+// node_modules/@inquirer/core/dist/lib/create-prompt.js
+import * as readline2 from "readline";
+import { AsyncResource as AsyncResource3 } from "async_hooks";
+
+// node_modules/@inquirer/type/dist/utils.js
+function withResolver() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+// node_modules/@inquirer/core/dist/lib/create-prompt.js
+var import_mute_stream = __toESM(require_lib(), 1);
+
+// node_modules/signal-exit/dist/mjs/signals.js
+var signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+  signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+}
+if (process.platform === "linux") {
+  signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+
+// node_modules/signal-exit/dist/mjs/index.js
+var processOk = (process3) => !!process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+var kExitEmitter = Symbol.for("signal-exit emitter");
+var global = globalThis;
+var ObjectDefineProperty = Object.defineProperty.bind(Object);
+
+class Emitter {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
+    }
+    ObjectDefineProperty(global, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
+    }
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+}
+
+class SignalExitBase {
+}
+var signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+};
+
+class SignalExitFallback extends SignalExitBase {
+  onExit() {
+    return () => {};
+  }
+  load() {}
+  unload() {}
+}
+
+class SignalExit extends SignalExitBase {
+  #hupSig = process3.platform === "win32" ? "SIGINT" : "SIGHUP";
+  #emitter = new Emitter;
+  #process;
+  #originalProcessEmit;
+  #originalProcessReallyExit;
+  #sigListeners = {};
+  #loaded = false;
+  constructor(process3) {
+    super();
+    this.#process = process3;
+    this.#sigListeners = {};
+    for (const sig of signals) {
+      this.#sigListeners[sig] = () => {
+        const listeners = this.#process.listeners(sig);
+        let { count } = this.#emitter;
+        const p = process3;
+        if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+          count += p.__signal_exit_emitter__.count;
+        }
+        if (listeners.length === count) {
+          this.unload();
+          const ret = this.#emitter.emit("exit", null, sig);
+          const s = sig === "SIGHUP" ? this.#hupSig : sig;
+          if (!ret)
+            process3.kill(process3.pid, s);
+        }
+      };
+    }
+    this.#originalProcessReallyExit = process3.reallyExit;
+    this.#originalProcessEmit = process3.emit;
+  }
+  onExit(cb, opts) {
+    if (!processOk(this.#process)) {
+      return () => {};
+    }
+    if (this.#loaded === false) {
+      this.load();
+    }
+    const ev = opts?.alwaysLast ? "afterExit" : "exit";
+    this.#emitter.on(ev, cb);
+    return () => {
+      this.#emitter.removeListener(ev, cb);
+      if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+        this.unload();
+      }
+    };
+  }
+  load() {
+    if (this.#loaded) {
+      return;
+    }
+    this.#loaded = true;
+    this.#emitter.count += 1;
+    for (const sig of signals) {
+      try {
+        const fn = this.#sigListeners[sig];
+        if (fn)
+          this.#process.on(sig, fn);
+      } catch (_) {}
+    }
+    this.#process.emit = (ev, ...a) => {
+      return this.#processEmit(ev, ...a);
+    };
+    this.#process.reallyExit = (code) => {
+      return this.#processReallyExit(code);
+    };
+  }
+  unload() {
+    if (!this.#loaded) {
+      return;
+    }
+    this.#loaded = false;
+    signals.forEach((sig) => {
+      const listener = this.#sigListeners[sig];
+      if (!listener) {
+        throw new Error("Listener not defined for signal: " + sig);
+      }
+      try {
+        this.#process.removeListener(sig, listener);
+      } catch (_) {}
+    });
+    this.#process.emit = this.#originalProcessEmit;
+    this.#process.reallyExit = this.#originalProcessReallyExit;
+    this.#emitter.count -= 1;
+  }
+  #processReallyExit(code) {
+    if (!processOk(this.#process)) {
+      return 0;
+    }
+    this.#process.exitCode = code || 0;
+    this.#emitter.emit("exit", this.#process.exitCode, null);
+    return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+  }
+  #processEmit(ev, ...args) {
+    const og = this.#originalProcessEmit;
+    if (ev === "exit" && processOk(this.#process)) {
+      if (typeof args[0] === "number") {
+        this.#process.exitCode = args[0];
+      }
+      const ret = og.call(this.#process, ev, ...args);
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return ret;
+    } else {
+      return og.call(this.#process, ev, ...args);
+    }
+  }
+}
+var process3 = globalThis.process;
+var {
+  onExit,
+  load,
+  unload
+} = signalExitWrap(processOk(process3) ? new SignalExit(process3) : new SignalExitFallback);
+
+// node_modules/@inquirer/core/dist/lib/screen-manager.js
+import { stripVTControlCharacters } from "util";
+
+// node_modules/@inquirer/ansi/dist/index.js
+var ESC2 = "\x1B[";
+var cursorLeft = ESC2 + "G";
+var cursorHide = ESC2 + "?25l";
+var cursorShow = ESC2 + "?25h";
+var cursorUp = (rows = 1) => rows > 0 ? `${ESC2}${rows}A` : "";
+var cursorDown = (rows = 1) => rows > 0 ? `${ESC2}${rows}B` : "";
+var cursorTo = (x, y) => {
+  if (typeof y === "number" && !Number.isNaN(y)) {
+    return `${ESC2}${y + 1};${x + 1}H`;
+  }
+  return `${ESC2}${x + 1}G`;
+};
+var eraseLine = ESC2 + "2K";
+var eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : "";
+
+// node_modules/@inquirer/core/dist/lib/screen-manager.js
+var height = (content) => content.split(`
+`).length;
+var lastLine = (content) => content.split(`
+`).pop() ?? "";
+
+class ScreenManager {
+  height = 0;
+  extraLinesUnderPrompt = 0;
+  cursorPos;
+  rl;
+  constructor(rl) {
+    this.rl = rl;
+    this.cursorPos = rl.getCursorPos();
+  }
+  write(content) {
+    this.rl.output.unmute();
+    this.rl.output.write(content);
+    this.rl.output.mute();
+  }
+  render(content, bottomContent = "") {
+    const promptLine = lastLine(content);
+    const rawPromptLine = stripVTControlCharacters(promptLine);
+    let prompt = rawPromptLine;
+    if (this.rl.line.length > 0) {
+      prompt = prompt.slice(0, -this.rl.line.length);
+    }
+    this.rl.setPrompt(prompt);
+    this.cursorPos = this.rl.getCursorPos();
+    const width = readlineWidth();
+    content = breakLines(content, width);
+    bottomContent = breakLines(bottomContent, width);
+    if (rawPromptLine.length % width === 0) {
+      content += `
+`;
+    }
+    let output = content + (bottomContent ? `
+` + bottomContent : "");
+    const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+    const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+    if (bottomContentHeight > 0)
+      output += cursorUp(bottomContentHeight);
+    output += cursorTo(this.cursorPos.cols);
+    this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
+    this.extraLinesUnderPrompt = bottomContentHeight;
+    this.height = height(output);
+  }
+  checkCursorPos() {
+    const cursorPos = this.rl.getCursorPos();
+    if (cursorPos.cols !== this.cursorPos.cols) {
+      this.write(cursorTo(cursorPos.cols));
+      this.cursorPos = cursorPos;
+    }
+  }
+  done({ clearContent }) {
+    this.rl.setPrompt("");
+    let output = cursorDown(this.extraLinesUnderPrompt);
+    output += clearContent ? eraseLines(this.height) : `
+`;
+    output += cursorLeft;
+    output += cursorShow;
+    this.write(output);
+    this.rl.close();
+  }
+}
+
+// node_modules/@inquirer/core/dist/lib/create-prompt.js
+import path from "path";
+var nativeSetImmediate = globalThis.setImmediate;
+var nativeClearImmediate = globalThis.clearImmediate;
+function listenTo(target, event, listener) {
+  if ("on" in target) {
+    target.on(event, listener);
+    return () => target.removeListener(event, listener);
+  }
+  target.addEventListener(event, listener);
+  return () => target.removeEventListener(event, listener);
+}
+function getCallSites() {
+  const savedPrepareStackTrace = Error.prepareStackTrace;
+  let result = [];
+  try {
+    Error.prepareStackTrace = (_, callSites) => {
+      const callSitesWithoutCurrent = callSites.slice(1);
+      result = callSitesWithoutCurrent;
+      return callSitesWithoutCurrent;
+    };
+    new Error().stack;
+  } catch {
+    return result;
+  }
+  Error.prepareStackTrace = savedPrepareStackTrace;
+  return result;
+}
+function createPrompt(view) {
+  const callSites = getCallSites();
+  const prompt = (config, context = {}) => {
+    const { input = process.stdin, signal } = context;
+    const cleanups = new Set;
+    const output = new import_mute_stream.default;
+    output.pipe(context.output ?? process.stdout);
+    const rl = readline2.createInterface({
+      terminal: true,
+      input,
+      output
+    });
+    output.mute();
+    const screen = new ScreenManager(rl);
+    const { promise, resolve, reject } = withResolver();
+    return withHooks(rl, (cycle) => {
+      const clearEffects = AsyncResource3.bind(() => effectScheduler.clearAll());
+      const settlePrompt = (settle) => {
+        try {
+          clearEffects();
+          settle();
+        } catch (error) {
+          reject(error);
+        }
+      };
+      const resolvePrompt = (value) => settlePrompt(() => resolve(value));
+      const rejectPrompt = (error) => settlePrompt(() => reject(error));
+      const promptPromise = Object.assign(promise.finally(() => {
+        cleanups.forEach((cleanup) => cleanup());
+        screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
+        output.end();
+      }).then(() => promise), { cancel: () => rejectPrompt(new CancelPromptError) });
+      if (signal) {
+        const abort = () => rejectPrompt(new AbortPromptError({ cause: signal.reason }));
+        if (signal.aborted) {
+          abort();
+          return promptPromise;
+        }
+        cleanups.add(listenTo(signal, "abort", abort));
+      }
+      cleanups.add(onExit((code, signal2) => {
+        rejectPrompt(new ExitPromptError(`User force closed the prompt with ${code} ${signal2}`));
+      }));
+      cleanups.add(listenTo(rl, "SIGINT", () => rejectPrompt(new ExitPromptError(`User force closed the prompt with SIGINT`))));
+      cleanups.add(listenTo(rl, "close", clearEffects));
+      const startCycle = () => {
+        cleanups.add(listenTo(rl.input, "keypress", () => screen.checkCursorPos()));
+        let pendingDone = null;
+        cycle(() => {
+          let effectsSettled = false;
+          try {
+            const nextView = view(config, (value) => {
+              if (effectsSettled) {
+                resolvePrompt(value);
+              } else {
+                pendingDone = { value };
+              }
+            });
+            if (nextView === undefined) {
+              let callerFilename = callSites[1]?.getFileName();
+              if (callerFilename && !callerFilename.startsWith("file://")) {
+                callerFilename = path.resolve(callerFilename);
+              }
+              throw new Error(`Prompt functions must return a string.
+    at ${callerFilename}`);
+            }
+            const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
+            screen.render(content, bottomContent);
+            effectScheduler.run();
+          } catch (error) {
+            rejectPrompt(error);
+          }
+          effectsSettled = true;
+          if (pendingDone !== null) {
+            const { value } = pendingDone;
+            pendingDone = null;
+            resolvePrompt(value);
+          }
+        });
+      };
+      if ("readableFlowing" in input && input.isTTY) {
+        const immediate = nativeSetImmediate(startCycle);
+        cleanups.add(() => nativeClearImmediate(immediate));
+      } else {
+        startCycle();
+      }
+      return promptPromise;
+    });
+  };
+  return prompt;
+}
+// node_modules/@inquirer/core/dist/lib/Separator.js
+import { styleText as styleText2 } from "util";
+class Separator {
+  separator = styleText2("dim", Array.from({ length: 15 }).join(dist_default.line));
+  type = "separator";
+  constructor(separator) {
+    if (separator) {
+      this.separator = separator;
+    }
+  }
+  static isSeparator(choice) {
+    return Boolean(choice && typeof choice === "object" && "type" in choice && choice.type === "separator");
+  }
+}
+// node_modules/@inquirer/checkbox/dist/index.js
+import { styleText as styleText3 } from "util";
+var checkboxTheme = {
+  icon: {
+    checked: styleText3("green", dist_default.circleFilled),
+    unchecked: dist_default.circle,
+    cursor: dist_default.pointer,
+    disabledChecked: styleText3("green", dist_default.circleDouble),
+    disabledUnchecked: "-"
+  },
+  style: {
+    disabled: (text) => styleText3("dim", text),
+    renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
+    description: (text) => styleText3("cyan", text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${styleText3("bold", key)} ${styleText3("dim", action)}`).join(styleText3("dim", " \u2022 "))
+  },
+  i18n: { disabledError: "This option is disabled and cannot be toggled." }
+};
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+function isNavigable(item) {
+  return !Separator.isSeparator(item);
+}
+function isChecked(item) {
+  return !Separator.isSeparator(item) && item.checked;
+}
+function toggle(item) {
+  return isSelectable(item) ? { ...item, checked: !item.checked } : item;
+}
+function check(checked) {
+  return function(item) {
+    return isSelectable(item) ? { ...item, checked } : item;
+  };
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice))
+      return choice;
+    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+      const name2 = String(choice);
+      return {
+        value: choice,
+        name: name2,
+        short: name2,
+        checkedName: name2,
+        disabled: false,
+        checked: false
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      checkedName: choice.checkedName ?? name,
+      disabled: choice.disabled ?? false,
+      checked: choice.checked ?? false
+    };
+    if (choice.description) {
+      normalizedChoice.description = choice.description;
+    }
+    return normalizedChoice;
+  });
+}
+var dist_default4 = createPrompt((config, done) => {
+  const { pageSize = 7, loop = true, required, validate = () => true } = config;
+  const shortcuts = { all: "a", invert: "i", ...config.shortcuts };
+  const theme = makeTheme(checkboxTheme, config.theme);
+  const { keybindings: keybindings2 } = theme;
+  const [status, setStatus] = useState("idle");
+  const prefix = usePrefix({ status, theme });
+  const [items, setItems] = useState(normalizeChoices(config.choices));
+  const bounds = useMemo(() => {
+    const first = items.findIndex(isNavigable);
+    const last = items.findLastIndex(isNavigable);
+    if (first === -1) {
+      throw new ValidationError("[checkbox prompt] No selectable choices. All choices are disabled.");
+    }
+    return { first, last };
+  }, [items]);
+  const [active, setActive] = useState(bounds.first);
+  const [errorMsg, setError] = useState();
+  useKeypress(async (key) => {
+    if (status !== "idle")
+      return;
+    if (isEnterKey(key)) {
+      setStatus("loading");
+      const selection = items.filter(isChecked);
+      const isValid = await validate([...selection]);
+      setStatus("idle");
+      if (required && !selection.length) {
+        setError("At least one choice must be selected");
+      } else if (isValid === true) {
+        setStatus("done");
+        done(selection.map((choice) => choice.value));
+      } else {
+        setError(isValid || "You must select a valid value");
+      }
+    } else if (isUpKey(key, keybindings2) || isDownKey(key, keybindings2)) {
+      if (errorMsg) {
+        setError(undefined);
+      }
+      if (loop || isUpKey(key, keybindings2) && active !== bounds.first || isDownKey(key, keybindings2) && active !== bounds.last) {
+        const offset = isUpKey(key, keybindings2) ? -1 : 1;
+        let next = active;
+        do {
+          next = (next + offset + items.length) % items.length;
+        } while (!isNavigable(items[next]));
+        setActive(next);
+      }
+    } else if (isSpaceKey(key)) {
+      const activeItem = items[active];
+      if (activeItem && !Separator.isSeparator(activeItem)) {
+        if (activeItem.disabled) {
+          setError(theme.i18n.disabledError);
+        } else {
+          setError(undefined);
+          setItems(items.map((choice, i) => i === active ? toggle(choice) : choice));
+        }
+      }
+    } else if (key.name === shortcuts.all) {
+      const selectAll = items.some((choice) => isSelectable(choice) && !choice.checked);
+      setItems(items.map(check(selectAll)));
+    } else if (key.name === shortcuts.invert) {
+      setItems(items.map(toggle));
+    } else if (isNumberKey(key)) {
+      const selectedIndex = Number(key.name) - 1;
+      let selectableIndex = -1;
+      const position = items.findIndex((item) => {
+        if (Separator.isSeparator(item))
+          return false;
+        selectableIndex++;
+        return selectableIndex === selectedIndex;
+      });
+      const selectedItem = items[position];
+      if (selectedItem && isSelectable(selectedItem)) {
+        setActive(position);
+        setItems(items.map((choice, i) => i === position ? toggle(choice) : choice));
+      }
+    }
+  });
+  const message = theme.style.message(config.message, status);
+  let description;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive }) {
+      if (Separator.isSeparator(item)) {
+        return ` ${item.separator}`;
+      }
+      const cursor = isActive ? theme.icon.cursor : " ";
+      if (item.disabled) {
+        const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+        const checkbox2 = item.checked ? theme.icon.disabledChecked : theme.icon.disabledUnchecked;
+        return theme.style.disabled(`${cursor}${checkbox2} ${item.name} ${disabledLabel}`);
+      }
+      if (isActive) {
+        description = item.description;
+      }
+      const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
+      const name = item.checked ? item.checkedName : item.name;
+      const color = isActive ? theme.style.highlight : (x) => x;
+      return color(`${cursor}${checkbox} ${name}`);
+    },
+    pageSize,
+    loop
+  });
+  if (status === "done") {
+    const selection = items.filter(isChecked);
+    const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
+    return [prefix, message, answer].filter(Boolean).join(" ");
+  }
+  const keys = [
+    ["\u2191\u2193", "navigate"],
+    ["space", "select"]
+  ];
+  if (shortcuts.all)
+    keys.push([shortcuts.all, "all"]);
+  if (shortcuts.invert)
+    keys.push([shortcuts.invert, "invert"]);
+  keys.push(["\u23CE", "submit"]);
+  const helpLine = theme.style.keysHelpTip(keys);
+  const lines = [
+    [prefix, message].filter(Boolean).join(" "),
+    page,
+    " ",
+    description ? theme.style.description(description) : "",
+    errorMsg ? theme.style.error(errorMsg) : "",
+    helpLine
+  ].filter(Boolean).join(`
+`).trimEnd();
+  return `${lines}${cursorHide}`;
+});
+// node_modules/@inquirer/confirm/dist/index.js
+import { styleText as styleText4 } from "util";
+var confirmTheme = {
+  keywords: {
+    yes: "Yes",
+    no: "No",
+    error: ({ yes, no }) => `You must answer with "${yes}" or "${no}"`
+  },
+  style: {
+    confirmDefault: (text) => {
+      const first = text[0] ?? "";
+      if (first.toLowerCase() === first.toUpperCase()) {
+        return styleText4("cyan", text);
+      }
+      return first.toUpperCase() + text.slice(1);
+    }
+  }
+};
+var dist_default5 = createPrompt((config, done) => {
+  const [status, setStatus] = useState("idle");
+  const [value, setValue] = useState("");
+  const [errorMsg, setError] = useState();
+  const theme = makeTheme(confirmTheme, config.theme);
+  const prefix = usePrefix({ status, theme });
+  const { yes, no } = theme.keywords;
+  const yesHint = (yes[0] ?? "").toLowerCase();
+  const noHint = (no[0] ?? "").toLowerCase();
+  const hint = config.default === false ? `${yesHint}/${theme.style.confirmDefault(noHint)}` : `${theme.style.confirmDefault(yesHint)}/${noHint}`;
+  function boolToString(value2) {
+    return value2 ? yes : no;
+  }
+  const { transformer = boolToString } = config;
+  function getBooleanValue(value2) {
+    const v = value2.trim().toLowerCase();
+    if (v === "")
+      return config.default !== false;
+    if (yes.toLowerCase().startsWith(v))
+      return true;
+    if (no.toLowerCase().startsWith(v))
+      return false;
+    if ("yes".startsWith(v))
+      return true;
+    if ("no".startsWith(v))
+      return false;
+    return;
+  }
+  useKeypress((key, rl) => {
+    if (status !== "idle")
+      return;
+    if (isEnterKey(key)) {
+      const answer = getBooleanValue(value);
+      if (answer === undefined) {
+        rl.write(value);
+        setError(theme.keywords.error({ yes, no }));
+        return;
+      }
+      setValue(transformer(answer));
+      setStatus("done");
+      done(answer);
+    } else if (isTabKey(key)) {
+      const answer = boolToString(!(getBooleanValue(value) ?? config.default !== false));
+      rl.clearLine(0);
+      rl.write(answer);
+      setValue(answer);
+    } else {
+      setValue(rl.line);
+      setError(undefined);
+    }
+  });
+  let formattedValue = value;
+  let defaultValue = "";
+  if (status === "done") {
+    formattedValue = theme.style.answer(value);
+  } else {
+    defaultValue = ` ${theme.style.defaultAnswer(hint)}`;
+  }
+  const message = theme.style.message(config.message, status);
+  let error = "";
+  if (errorMsg) {
+    error = theme.style.error(errorMsg);
+  }
+  return [`${prefix} ${message}${defaultValue} ${formattedValue}`, error];
+});
+// src/install/index.ts
+import { mkdir as mkdir3, rm, rename, lstat, open } from "fs/promises";
+import { dirname as dirname3, join as join5, resolve as resolve5, isAbsolute as isAbsolute3 } from "path";
+import { pathToFileURL } from "url";
+
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+var supportedEols = [`
+`, "\r", `\r
+`];
+
+// node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+      formatTextStart--;
+    }
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+      endOffset++;
+    }
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options, documentText);
+  const eolFastPathSupported = supportedEols.includes(eol);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options.insertSpaces) {
+    indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+  } else {
+    indentValue = "\t";
+  }
+  const indentType = indentValue === "\t" ? "\t" : " ";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) {
+      return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+    if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+      return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    if (amountOfSpaces <= 0) {
+      return eol;
+    }
+    return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+  }
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options.keepLines) {
+        numberLineBreaks += 1;
+      } else if (token === 14) {
+        numberLineBreaks = 1;
+      }
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  const editOperations = [];
+  function addEdit(text, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) {
+      editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+    }
+  }
+  let firstToken = scanNext();
+  if (options.keepLines && numberLineBreaks > 0) {
+    addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  }
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    let initialIndent = indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
+    addEdit(initialIndent, formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 5:
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 6:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 10:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (secondToken === 6 && !needsLineBreak) {
+            replaceContent = "";
+          }
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) {
+              replaceContent = cachedSpaces[1];
+            } else if (secondToken !== 5 && secondToken !== 17) {
+              hasError = true;
+            }
+          }
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) {
+        replaceContent = newLinesAndIndent();
+      }
+    }
+    if (secondToken === 17) {
+      if (options.keepLines && numberLineBreaks > 0) {
+        replaceContent = newLinesAndIndent();
+      } else {
+        replaceContent = options.insertFinalNewline ? eol : "";
+      }
+    }
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+function repeat(s, count) {
+  let result = "";
+  for (let i = 0;i < count; i++) {
+    result += s;
+  }
+  return result;
+}
+function computeIndentLevel(content, options) {
+  let i = 0;
+  let nChars = 0;
+  const tabSize = options.tabSize || 4;
+  while (i < content.length) {
+    let ch = content.charAt(i);
+    if (ch === cachedSpaces[1]) {
+      nChars++;
+    } else if (ch === "\t") {
+      nChars += tabSize;
+    } else {
+      break;
+    }
+    i++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+  for (let i = 0;i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (ch === "\r") {
+      if (i + 1 < text.length && text.charAt(i + 1) === `
+`) {
+        return `\r
+`;
+      }
+      return "\r";
+    } else if (ch === `
+`) {
+      return `
+`;
+    }
+  }
+  return options && options.eol || `
+`;
+}
+function isEOL(text, offset) {
+  return `\r
+`.indexOf(text.charAt(offset)) !== -1;
+}
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors2 = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors2.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function parseTree(text, errors2 = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: undefined };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors2.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path2) {
+  if (!root) {
+    return;
+  }
+  let node = root;
+  for (let segment of path2) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+
+// node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+  const path2 = originalPath.slice();
+  const errors2 = [];
+  const root = parseTree(text, errors2);
+  let parent = undefined;
+  let lastSegment = undefined;
+  while (path2.length > 0) {
+    lastSegment = path2.pop();
+    parent = findNodeAtLocation(root, path2);
+    if (parent === undefined && value !== undefined) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === undefined) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== undefined) {
+      if (value === undefined) {
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
+      } else {
+        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+      }
+    } else {
+      if (value === undefined) {
+        return [];
+      }
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
+      }
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value === undefined && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value !== undefined) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else {
+      throw new Error(`Can not ${value === undefined ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+  }
+}
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) {
+    return [edit];
+  }
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
+  }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+  for (let i = edits.length - 1;i >= 0; i--) {
+    const edit2 = edits[i];
+    newText = applyEdit(newText, edit2);
+    begin = Math.min(begin, edit2.offset);
+    end = Math.max(end, edit2.offset + edit2.length);
+    end += edit2.content.length - edit2.length;
+  }
+  const editLength = text.length - (newText.length - end) - begin;
+  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text, edit) {
+  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function modify(text, path2, value, options) {
+  return setProperty(text, path2, value, options);
+}
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) {
+      return a.length - b.length;
+    }
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1;i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) {
+      text = applyEdit(text, e);
+    } else {
+      throw new Error("Overlapping edit");
+    }
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
+
+// src/runtime.ts
+import { readFileSync, existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+// assets/build.json
+var build_default = {
+  version: "0.0.1",
+  buildId: "bbceff2246e5fb0e4b93bb05081457dbc113400b937c6148764573618d8534b5"
+};
+
+// src/runtime.ts
+function packageRoot(url) {
+  const visit2 = (directory) => {
+    if (existsSync(join(directory, ".vsl-runtime.json")))
+      return directory;
+    const manifest = join(directory, "package.json");
+    if (existsSync(manifest) && JSON.parse(readFileSync(manifest, "utf8")).name === "@bitfun-vsl/plugin")
+      return directory;
+    if (dirname(directory) === directory)
+      throw new Error(`Cannot locate VSL package from ${url}`);
+    return visit2(dirname(directory));
+  };
+  return visit2(dirname(fileURLToPath(url)));
+}
+
+// src/install/config.ts
+import { homedir as homedir2 } from "os";
+import { join as join4, resolve as resolve4 } from "path";
+
+// src/install/resources.ts
+import { join as join3, resolve as resolve3, relative, isAbsolute as isAbsolute2, dirname as dirname2 } from "path";
+import { mkdir as mkdir2, readdir } from "fs/promises";
+
+// src/plugin/modules/trajectory-analysis.ts
+var inputSchema = {
+  type: "object",
+  properties: {
+    source: { type: "string", description: "\u8F68\u8FF9\u6587\u4EF6\u6216\u76EE\u5F55\uFF1Bmock \u6A21\u5F0F\u53EA\u7528\u4E8E\u6807\u8BC6\u8F93\u5165" }
+  },
+  required: ["source"],
+  additionalProperties: false
+};
+var sourceOf = (input) => {
+  if (!input || typeof input !== "object" || typeof input.source !== "string")
+    throw new Error("source must be a string");
+  return input.source;
+};
+var mockRead = async (input, context) => {
+  const source = sourceOf(input);
+  context.report("\u8BFB\u53D6\u8F68\u8FF9\uFF08mock\uFF09");
+  return {
+    title: "Trajectory loaded",
+    output: JSON.stringify({ source, events: 12, durationMs: 4800, mock: true }),
+    metadata: { source, mock: true }
+  };
+};
+var mockAnalyze = async (input, context) => {
+  const source = sourceOf(input);
+  context.report("\u5206\u6790\u8F68\u8FF9\uFF08mock\uFF09");
+  return {
+    title: "Trajectory analyzed",
+    output: JSON.stringify({ source, eventCount: 12, phases: 3, anomalies: 1, score: 0.92, mock: true }),
+    metadata: { source, eventCount: 12, phases: 3, anomalies: 1, score: 0.92, mock: true }
+  };
+};
+var mockReport = async (input, context) => {
+  const source = sourceOf(input);
+  context.report("\u751F\u6210\u8F68\u8FF9\u62A5\u544A\uFF08mock\uFF09");
+  return {
+    title: "Trajectory report ready",
+    output: `Mock trajectory report for ${source}: score=0.92, anomalies=1`,
+    metadata: { source, mock: true }
+  };
+};
+function createTrajectoryAnalysisModule() {
+  return {
+    id: "trajectory-analysis",
+    version: "0.1.0",
+    description: "\u63D0\u4F9B\u8F68\u8FF9\u8BFB\u53D6\u3001\u5206\u6790\u548C\u62A5\u544A\u80FD\u529B\u7684 mock \u6A21\u5757",
+    commands: [
+      {
+        name: "vsl:trajectory",
+        description: "\u5206\u6790\u6307\u5B9A\u8F68\u8FF9\u5E76\u751F\u6210\u5206\u6790\u7ED3\u679C",
+        agent: "vsl-trajectory",
+        template: [
+          "\u5206\u6790\u7528\u6237\u6307\u5B9A\u7684\u8F68\u8FF9\u3002",
+          "\u5148\u52A0\u8F7D vsl-trajectory-analysis Skill\u3002",
+          "\u5FC5\u987B\u8C03\u7528 vsl_trajectory_analyze\uFF0C\u4E0D\u8981\u4EC5\u6839\u636E\u5BF9\u8BDD\u5185\u5BB9\u63A8\u6D4B\u7ED3\u679C\u3002",
+          "\u7528\u6237\u53C2\u6570\uFF1A$ARGUMENTS"
+        ].join(`
+`),
+        toolNames: ["vsl_trajectory_analyze"]
+      }
+    ],
+    agents: [
+      {
+        name: "vsl-trajectory",
+        description: "\u8D1F\u8D23\u7EC4\u7EC7\u8F68\u8FF9\u5206\u6790\u5DE5\u5177\u8C03\u7528",
+        mode: "subagent",
+        prompt: "\u4F60\u8D1F\u8D23\u5206\u6790\u8F68\u8FF9\u3002\u5148\u52A0\u8F7D vsl-trajectory-analysis\uFF0C\u518D\u8C03\u7528\u786E\u5B9A\u6027\u7684\u8F68\u8FF9\u5DE5\u5177\u3002"
+      }
+    ],
+    skills: [
+      {
+        name: "vsl-trajectory-analysis",
+        description: "\u8F68\u8FF9\u683C\u5F0F\u3001\u5206\u6790\u6B65\u9AA4\u548C\u7ED3\u679C\u89E3\u91CA\u89C4\u5219",
+        content: [
+          "\u4F7F\u7528\u8F68\u8FF9\u5DE5\u5177\u5B8C\u6210\u5206\u6790\uFF0C\u4E0D\u8981\u6839\u636E\u5BF9\u8BDD\u731C\u6D4B\u6570\u636E\u3002",
+          "\u5148\u8C03\u7528 vsl_trajectory_read\uFF0C\u518D\u8C03\u7528 vsl_trajectory_analyze\uFF0C\u6700\u540E\u6309\u9700\u8C03\u7528 vsl_trajectory_report\u3002"
+        ].join(`
+`)
+      }
+    ],
+    tools: [
+      { name: "vsl_trajectory_read", description: "\u8BFB\u53D6\u5E76\u6821\u9A8C\u8F68\u8FF9\uFF08mock\uFF09", input: inputSchema, execute: mockRead },
+      { name: "vsl_trajectory_analyze", description: "\u6267\u884C\u8F68\u8FF9\u5206\u6790\uFF08mock\uFF09", input: inputSchema, execute: mockAnalyze },
+      { name: "vsl_trajectory_report", description: "\u751F\u6210\u8F68\u8FF9\u62A5\u544A\uFF08mock\uFF09", input: inputSchema, execute: mockReport }
+    ]
+  };
+}
+
+// src/plugin/schema.ts
+function validateInput(schema, input, path2 = "input") {
+  if (schema.type === "object") {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+      throw new Error(`${path2} must be an object`);
+    const values = input;
+    schema.required?.forEach((key) => {
+      if (values[key] === undefined)
+        throw new Error(`${path2}.${key} is required`);
+    });
+    Object.entries(values).forEach(([key, value]) => {
+      const property = schema.properties?.[key];
+      if (!property && schema.additionalProperties === false)
+        throw new Error(`${path2}.${key} is not supported`);
+      if (property)
+        validateInput(property, value, `${path2}.${key}`);
+    });
+    return;
+  }
+  if (schema.type === "array") {
+    if (!Array.isArray(input))
+      throw new Error(`${path2} must be an array`);
+    if (schema.items)
+      input.forEach((value, index) => validateInput(schema.items, value, `${path2}[${index}]`));
+    return;
+  }
+  if (schema.type === "integer" || schema.type === "number") {
+    if (typeof input !== "number" || !Number.isFinite(input) || schema.type === "integer" && !Number.isInteger(input))
+      throw new Error(`${path2} must be a finite ${schema.type}`);
+    if (schema.minimum !== undefined && input < schema.minimum)
+      throw new Error(`${path2} must be >= ${schema.minimum}`);
+    if (schema.maximum !== undefined && input > schema.maximum)
+      throw new Error(`${path2} must be <= ${schema.maximum}`);
+    return;
+  }
+  if (typeof input !== schema.type)
+    throw new Error(`${path2} must be a ${schema.type}`);
+  if (schema.enum && !schema.enum.includes(String(input)))
+    throw new Error(`${path2} must be one of ${schema.enum.join(", ")}`);
+}
+
+// src/plugin/modules/code-review/index.ts
+init_runtime();
+var reviewSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    repo: { type: "string", description: "Repository path; defaults to the host project. In Claude pass the current project explicitly if MCP cwd differs." },
+    commit: { type: "string", description: "Single commit; mutually exclusive with from/to" },
+    from: { type: "string", description: "Base ref; requires to" },
+    to: { type: "string", description: "Target ref; requires from" },
+    preview: { type: "boolean", description: "Preview scope without calling the CR model" },
+    resume: { type: "string", description: "CR session ID; requires original commit or from/to; incompatible with preview" },
+    background: { type: "string" },
+    backgroundFile: { type: "string" },
+    rule: { type: "string" },
+    exclude: { type: "array", items: { type: "string" } },
+    provider: { type: "string" },
+    model: { type: "string" },
+    effort: { type: "string", enum: ["low", "medium", "high"] },
+    concurrency: { type: "integer", minimum: 1 },
+    taskTimeoutMinutes: { type: "integer", minimum: 1 },
+    maxTokensBudget: { type: "integer", minimum: 0 },
+    overallTimeoutMinutes: { type: "number", minimum: 0.001, maximum: 1440, description: "Whole process deadline, default 60 minutes; independent of CR per-task timeout" }
+  }
+};
+var healthSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: { checkConnection: { type: "boolean", description: "Explicitly test CR's configured model connection; default false" } }
+};
+function createCodeReviewModule(options = {}) {
+  return {
+    id: "code-review",
+    version: "0.1.0",
+    description: "Run the complete review engine through its native CLI",
+    commands: [
+      {
+        name: "vsl:review",
+        description: "Run a complete CR review of workspace, commit, or branch changes",
+        toolNames: ["vsl_cr_review"],
+        template: "Use vsl_cr_review to run the complete CR engine. Convert the user's scope to structured arguments; pass the current repository. Default to workspace review. CR uses its own model configuration. Report manifest terminal state and coverage; partial/skipped/failed are not complete. Preserve CR findings and severity; do not substitute your own review. If findingsTruncated or detailsTruncated is true, read resultFile in bounded batches before reporting results. Preview is scope only. Resume requires the original commit or from/to. Do not modify code or publish comments unless requested. User request: $ARGUMENTS"
+      },
+      {
+        name: "vsl:cr-health",
+        description: "Check CR executable, CLI compatibility, and optionally its model connection",
+        toolNames: ["vsl_cr_health"],
+        template: "Use vsl_cr_health. Only set checkConnection=true when the user asks to test the model connection. Report executable path, version, compatibility and diagnostics. User request: $ARGUMENTS"
+      }
+    ],
+    tools: [
+      {
+        name: "vsl_cr_review",
+        description: "Run the complete CR review engine with its own configured model. Read manifest coverage and terminal state; zero findings or exit 0 alone do not prove completion. Full raw output is retained in resultFile. Read that file if findingsTruncated. No code is changed by VSL.",
+        input: reviewSchema,
+        async execute(input, context) {
+          validateInput(reviewSchema, input);
+          return review(input, context, options);
+        }
+      },
+      {
+        name: "vsl_cr_health",
+        description: "Locate the native CR executable and check version/required CLI flags. Model connectivity is only tested when checkConnection=true.",
+        input: healthSchema,
+        async execute(input, context) {
+          validateInput(healthSchema, input);
+          return health(input, context, options);
+        }
+      }
+    ]
+  };
+}
+
+// src/plugin/registry.ts
+var assertUnique = (kind, names) => {
+  const seen = new Set;
+  const duplicate = names.find((name) => {
+    if (seen.has(name))
+      return true;
+    seen.add(name);
+    return false;
+  });
+  if (duplicate)
+    throw new Error(`${kind} conflict: ${duplicate}`);
+};
+function createModuleRegistry(input = {}) {
+  const modules = (input.modules ?? []).filter((module) => input.enabled?.[module.id] !== false);
+  if (new Set(modules.map((module) => module.id)).size !== modules.length)
+    throw new Error("module conflict");
+  const resources = {
+    modules,
+    commands: modules.flatMap((module) => module.commands ?? []),
+    agents: modules.flatMap((module) => module.agents ?? []),
+    skills: modules.flatMap((module) => module.skills ?? []),
+    tools: modules.flatMap((module) => module.tools ?? [])
+  };
+  assertUnique("command", resources.commands.map((item) => item.name));
+  assertUnique("agent", resources.agents.map((item) => item.name));
+  assertUnique("skill", resources.skills.map((item) => item.name));
+  assertUnique("tool", resources.tools.map((item) => item.name));
+  const agents = new Set(resources.agents.map((item) => item.name));
+  const tools = new Set(resources.tools.map((item) => item.name));
+  resources.commands.forEach((command) => {
+    if (command.agent && !agents.has(command.agent))
+      throw new Error(`command ${command.name} references missing agent ${command.agent}`);
+    command.toolNames?.forEach((tool) => {
+      if (!tools.has(tool))
+        throw new Error(`command ${command.name} references missing tool ${tool}`);
+    });
+  });
+  return {
+    enabled: () => resources,
+    command: (name) => resources.commands.find((item) => item.name === name),
+    tool: (name) => resources.tools.find((item) => item.name === name)
+  };
+}
+
+// src/plugin/index.ts
+function createRegistry(input = {}) {
+  return createModuleRegistry({ modules: input.modules ?? [createTrajectoryAnalysisModule(), createCodeReviewModule({ binary: input.crBinary })], enabled: input.enabled });
+}
+
+// src/hosts/bitfun-kernel/commands.ts
+if (false) {}
+
+// src/install/resources.ts
+var digest = (content) => new Bun.CryptoHasher("sha256").update(content).digest("hex");
+function inside(root, path2) {
+  const target = resolve3(root, path2);
+  const part = relative(resolve3(root), target);
+  if (part === ".." || part.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute2(part))
+    throw new Error(`Path escapes VSL root: ${path2}`);
+  return target;
+}
+async function filesUnder(root) {
+  return (await Promise.all((await readdir(root, { withFileTypes: true })).map(async (entry) => {
+    if (entry.isSymbolicLink())
+      throw new Error(`Symlink not allowed in managed resources: ${join3(root, entry.name)}`);
+    if (entry.isDirectory())
+      return (await filesUnder(join3(root, entry.name))).map((file) => `${entry.name}/${file}`);
+    return entry.isFile() ? [entry.name] : [];
+  }))).flat().sort();
+}
+function selectResources(names) {
+  const all = createRegistry().enabled();
+  const unknown = names?.find((name) => !all.modules.some((module) => module.id === name));
+  if (unknown)
+    throw new Error(`Unknown VSL module: ${unknown}`);
+  if (names && new Set(names).size !== names.length)
+    throw new Error("Duplicate VSL module selection");
+  return createRegistry({ modules: all.modules.filter((module) => !names || names.includes(module.id)) }).enabled();
+}
+async function writeResources(root, resources) {
+  await Promise.all(Object.entries(resources).map(async ([path2, content]) => {
+    const target = inside(root, path2);
+    await mkdir2(dirname2(target), { recursive: true });
+    await Bun.write(target, content);
+  }));
+}
+
+// src/install/config.ts
+function installationPaths(options) {
+  const home = options.home ?? homedir2();
+  const bitfunUserRoot = process.env.BITFUN_USER_ROOT || process.env.BITFUN_E2E_USER_ROOT || (process.platform === "win32" ? join4(process.env.APPDATA ?? join4(home, "AppData", "Roaming"), "bitfun") : process.platform === "darwin" ? join4(home, "Library", "Application Support", "bitfun") : join4(process.env.XDG_CONFIG_HOME ?? join4(home, ".config"), "bitfun"));
+  const configDirectory = resolve4(options.configDirectory ?? (options.host === "deveco" ? process.env.DEVECO_CONFIG_DIR ?? join4(process.env.XDG_CONFIG_HOME ?? join4(home, ".config"), "deveco") : options.host === "bitfun" ? join4(bitfunUserRoot, "config") : process.env.CLAUDE_CONFIG_DIR ?? join4(home, ".claude")));
+  const stateDirectory = resolve4(options.stateDirectory ?? join4(home, ".vsl"));
+  const installationId = digest(`${options.host}:${process.platform === "win32" ? configDirectory.toLowerCase() : configDirectory}`).slice(0, 16);
+  const instance = join4(stateDirectory, "installations", installationId);
+  const commandDirectory = resolve4(options.commandDirectory ?? process.env.OPENCODE_CONFIG_DIR ?? join4(process.env.XDG_CONFIG_HOME ?? join4(home, ".config"), "opencode"));
+  return { commandDirectory, configDirectory, stateDirectory, installationId, instance, receiptPath: join4(instance, "receipt.json"), journalPath: join4(instance, "transaction.json"), lockPath: join4(instance, "install.lock") };
+}
+
+// src/install/index.ts
+async function planInstallation(options) {
+  const paths = installationPaths(options);
+  const previous = await readReceipt(paths.receiptPath);
+  const modules = options.modules ?? previous?.modules ?? selectResources().modules.map((module) => module.id);
+  selectResources(modules);
+  if (!modules.length)
+    throw new Error("Select at least one module");
+  if (previous?.commandDirectory && paths.commandDirectory !== previous.commandDirectory)
+    throw new Error("BitFun command directory changed; use the original --command-dir or uninstall first");
+  if (options.crBinary && !isAbsolute3(options.crBinary))
+    throw new Error("CR binary must be an absolute native executable path");
+  const source = options.source ? resolve5(options.source) : packageRoot(import.meta.url);
+  if (!await Bun.file(source).exists() && !await lstat(source).then((value) => value.isDirectory()).catch(() => false))
+    throw new Error(`Package source not found: ${source}`);
+  const configPath = options.host === "deveco" ? await devecoConfigPath(paths.configDirectory) : join5(paths.configDirectory, options.host === "bitfun" ? "app.json" : "settings.json");
+  if (options.host !== "claude-code")
+    validatePluginConfig(await readObject(configPath), previous);
+  const sourceIdentity = await Bun.file(source).exists() ? { sha256: digest(await Bun.file(source).bytes()) } : await verifyPackage(source).then((manifest) => ({ version: manifest.version, buildId: manifest.buildId }));
+  return {
+    action: previous ? "update" : "install",
+    host: options.host,
+    source,
+    modules,
+    configDirectory: paths.configDirectory,
+    sourceIdentity,
+    commandDirectory: options.host === "bitfun" ? paths.commandDirectory : undefined,
+    configPath,
+    installationId: paths.installationId,
+    receiptPath: paths.receiptPath,
+    previousVersion: previous?.version,
+    operations: options.host !== "claude-code" ? ["validate package manifest", "install actual host npm dependency", "register one native plugin", ...options.host === "bitfun" ? ["install selected BitFun command files"] : [], "verify package resources"] : ["validate package manifest", "materialize selected native plugin resources", "register local marketplace through Claude CLI", "verify installed plugin cache"],
+    restartRequired: true,
+    loaded: "not checked",
+    verified: false
+  };
+}
+async function install(options) {
+  const plan = await planInstallation(options);
+  const paths = installationPaths(options);
+  await mkdir3(paths.instance, { recursive: true });
+  const lock = await acquireLock(paths.lockPath);
+  try {
+    if (await Bun.file(paths.journalPath).exists())
+      throw new Error(`Unfinished installation: inspect ${paths.journalPath}; run vsl recover for this host`);
+    const previous = await readReceipt(paths.receiptPath);
+    if (previous)
+      await assertOwnedFiles(previous);
+    if (previous && !(await doctor(options)).configured)
+      throw new Error("Managed host registration changed; resolve doctor diagnostics before update");
+    const packageJsonPath = join5(paths.configDirectory, "package.json");
+    const configBefore = await textOrUndefined(plan.configPath);
+    const packageBefore = await textOrUndefined(packageJsonPath);
+    const dependencyBefore = dependencyOf(await readObject(packageJsonPath));
+    const originalEntries = options.host !== "claude-code" ? validatePluginConfig(await readObject(plan.configPath), previous) : [];
+    const currentRoot = join5(paths.configDirectory, "node_modules/@bitfun-vsl/plugin");
+    if (!previous && options.host !== "claude-code" && await Bun.file(join5(currentRoot, "package.json")).exists()) {
+      if (!await Bun.file(join5(currentRoot, "assets/install-manifest.json")).exists())
+        throw new Error("Existing host VSL package has no ownership manifest. Back up and remove the legacy installation before init can take ownership.");
+      await verifyPackage(currentRoot);
+      const existing = await inventory(currentRoot);
+      const manifest2 = await Bun.file(join5(currentRoot, "assets/install-manifest.json")).json();
+      const pkg = await Bun.file(join5(currentRoot, "package.json")).json();
+      const unowned = Object.keys(existing).filter((path2) => !["package.json", "README.md", "LICENSE", "assets/install-manifest.json", "assets/runtime.json"].includes(path2) && !(path2 in manifest2.files) && !(pkg.files ?? []).some((file) => file.startsWith("docs/") && path2 === file));
+      if (unowned.length)
+        throw new Error(`Unowned files in existing VSL package: ${unowned.join(", ")}`);
+    }
+    const originalRuntime = options.host !== "claude-code" ? await textOrUndefined(join5(currentRoot, "assets/runtime.json")) : undefined;
+    const releaseRoot = join5(paths.instance, "releases", crypto.randomUUID());
+    const marketplaceBefore = await textOrUndefined(join5(paths.instance, "marketplace/.claude-plugin/marketplace.json"));
+    const state = {
+      phase: "staging",
+      host: options.host,
+      configDirectory: paths.configDirectory,
+      releaseRoot,
+      marketplaceBefore,
+      configPath: plan.configPath,
+      configBefore,
+      packageBefore,
+      previous,
+      dependencyBefore,
+      originalEntries,
+      originalRuntime
+    };
+    await writeJson(paths.journalPath, state);
+    await mkdir3(releaseRoot, { recursive: true });
+    await command(["npm", "install", "--prefix", releaseRoot, "--ignore-scripts", "--install-links", "--no-audit", "--no-fund", plan.source]);
+    const stagedRoot = join5(releaseRoot, "node_modules/@bitfun-vsl/plugin");
+    const manifest = await verifyPackage(stagedRoot);
+    if (plan.modules.some((name) => !manifest.modules.some((module) => module.id === name)))
+      throw new Error("Selected module is absent from source package");
+    const { resolveCr: resolveCr2 } = await Promise.resolve().then(() => (init_runtime(), exports_runtime));
+    const requestedCr = options.crBinary ?? previous?.crBinary ?? process.env.VSL_CR_BIN;
+    const crBinary = requestedCr ? await resolveCr2(requestedCr) : plan.modules.includes("code-review") ? await resolveCr2().catch(() => {
+      return;
+    }) : undefined;
+    const runtime = { schemaVersion: 1, host: options.host, modules: plan.modules, crBinary, installationId: paths.installationId };
+    if (previous && previous.buildId === manifest.buildId && JSON.stringify(previous.modules) === JSON.stringify(plan.modules) && previous.crBinary === runtime.crBinary) {
+      const report2 = await doctor(options);
+      if (report2.configured) {
+        await safeRemove(paths.instance, releaseRoot);
+        await rm(paths.journalPath);
+        return { ...report2, recoveryRequired: false, unchanged: true };
+      }
+    }
+    await writeJson(join5(stagedRoot, "assets/runtime.json"), runtime);
+    const marketplace = `vsl-${paths.installationId}`;
+    const marketplacePath = join5(paths.instance, "marketplace");
+    const pluginVersion = `${manifest.version}+vsl.${manifest.buildId.slice(0, 8)}.${digest(JSON.stringify(runtime)).slice(0, 8)}.${crypto.randomUUID().slice(0, 8)}`;
+    const pluginRoot = join5(marketplacePath, "releases", pluginVersion, "plugin");
+    if (options.host === "claude-code") {
+      const existing = await command(["claude", "plugin", "list", "--json"], claudeEnvironment(paths.configDirectory));
+      const plugins = JSON.parse(existing);
+      if (!Array.isArray(plugins))
+        throw new Error("Invalid Claude plugin inventory");
+      if (plugins.some((item) => item && typeof item === "object" && ("id" in item) && typeof item.id === "string" && (item.id === "vsl" || item.id.startsWith("vsl@")) && item.id !== `vsl@${marketplace}`))
+        throw new Error("Another VSL Claude plugin is registered; resolve it before adopting this installation");
+      const existingPlugin = await Bun.file(join5(pluginRoot, ".claude-plugin/plugin.json")).exists();
+      if (existingPlugin)
+        throw new Error(`Unowned Claude release already exists: ${pluginRoot}`);
+      const renderer2 = await import(pathToFileURL(join5(stagedRoot, "dist/install/resources.js")).href);
+      await writeResources(pluginRoot, Object.fromEntries(Object.entries(renderer2.renderResources(renderer2.selectResources(plan.modules), pluginVersion)).filter(([path2]) => path2.startsWith("claude-code/")).map(([path2, content]) => [path2.slice("claude-code/".length), content])));
+      await writeJson(join5(pluginRoot, ".vsl-runtime.json"), runtime);
+      await mkdir3(join5(pluginRoot, "scripts"), { recursive: true });
+      await Bun.write(join5(pluginRoot, "scripts/mcp-server.js"), Bun.file(join5(stagedRoot, "assets/claude-code/scripts/mcp-server.js")));
+      await command(["claude", "plugin", "validate", pluginRoot], claudeEnvironment(paths.configDirectory));
+    }
+    const renderer = options.host === "bitfun" ? await import(pathToFileURL(join5(stagedRoot, "dist/install/resources.js")).href) : undefined;
+    const selectedCommandFiles = renderer ? Object.fromEntries(Object.entries(renderer.renderResources(renderer.selectResources(plan.modules), manifest.version)).filter(([path2]) => path2.startsWith("bitfun/command/")).map(([path2, content]) => [path2.slice("bitfun/".length), String(content)])) : undefined;
+    const commandFilesBefore = selectedCommandFiles ? Object.fromEntries(await Promise.all([...new Set([
+      ...Object.keys(previous?.commandFiles ?? {}),
+      ...Object.keys(selectedCommandFiles)
+    ])].map(async (path2) => [path2, await textOrUndefined(inside(paths.commandDirectory, path2)) ?? null]))) : undefined;
+    if (selectedCommandFiles && commandFilesBefore) {
+      for (const [path2, before] of Object.entries(commandFilesBefore)) {
+        if (before !== null && !(path2 in (previous?.commandFiles ?? {})) && before !== selectedCommandFiles[path2])
+          throw new Error(`Unmanaged BitFun command would be overwritten: ${path2}`);
+      }
+    }
+    if (await textOrUndefined(plan.configPath) !== configBefore || await textOrUndefined(packageJsonPath) !== packageBefore)
+      throw new Error("Host configuration changed during planning; retry installation");
+    await writeJson(paths.journalPath, { ...state, phase: "registering", marketplace, marketplacePath, pluginRoot, commandFilesBefore, commandDirectory: paths.commandDirectory });
+    if (options.host !== "claude-code") {
+      await mkdir3(paths.configDirectory, { recursive: true });
+      await command(["npm", "install", "--prefix", paths.configDirectory, "--ignore-scripts", "--install-links", "--no-audit", "--no-fund", stagedRoot]);
+      await verifyPackage(currentRoot);
+      if (await textOrUndefined(plan.configPath) !== configBefore)
+        throw new Error("Host configuration changed during dependency installation");
+      const parsed = await readObject(plan.configPath);
+      const entries = Array.isArray(parsed.plugin) ? parsed.plugin : [];
+      const entry = pathToFileURL(join5(currentRoot, hostEntry(options.host))).href;
+      await patchJson(plan.configPath, ["plugin"], [...entries.filter((item) => !isVslEntry(entrySpec(item))), entry]);
+    }
+    if (options.host === "claude-code") {
+      await writeJson(join5(marketplacePath, ".claude-plugin/marketplace.json"), {
+        name: marketplace,
+        owner: { name: "VSL" },
+        plugins: [{
+          name: "vsl",
+          version: pluginVersion,
+          source: `./releases/${pluginVersion}/plugin`,
+          description: "VSL shared modules and tools"
+        }]
+      });
+      if (previous) {
+        await command(["claude", "plugin", "marketplace", "update", marketplace], claudeEnvironment(paths.configDirectory));
+        await command(["claude", "plugin", "update", `vsl@${marketplace}`, "--scope", "user"], claudeEnvironment(paths.configDirectory));
+      }
+      if (!previous) {
+        await command(["claude", "plugin", "marketplace", "add", marketplacePath, "--scope", "user"], claudeEnvironment(paths.configDirectory));
+        await command(["claude", "plugin", "install", `vsl@${marketplace}`, "--scope", "user"], claudeEnvironment(paths.configDirectory));
+      }
+    }
+    if (selectedCommandFiles && commandFilesBefore) {
+      for (const [path2, before] of Object.entries(commandFilesBefore)) {
+        if ((await textOrUndefined(inside(paths.commandDirectory, path2)) ?? null) !== before)
+          throw new Error(`BitFun command changed during installation: ${path2}`);
+      }
+      await restoreCommands(paths.commandDirectory, Object.fromEntries(Object.keys(commandFilesBefore).map((path2) => [path2, selectedCommandFiles[path2] ?? previous?.originalCommandFiles?.[path2] ?? null])));
+    }
+    const installedRoot = options.host !== "claude-code" ? currentRoot : await claudeInstalledRoot(paths.configDirectory, `vsl@${marketplace}`, pluginVersion);
+    const receipt = {
+      schemaVersion: 1,
+      installationId: paths.installationId,
+      host: options.host,
+      configDirectory: paths.configDirectory,
+      packageRoot: installedRoot,
+      releaseRoot,
+      version: manifest.version,
+      buildId: manifest.buildId,
+      modules: plan.modules,
+      crBinary: runtime.crBinary,
+      files: await inventory(installedRoot),
+      configPath: plan.configPath,
+      entry: options.host !== "claude-code" ? pathToFileURL(join5(currentRoot, hostEntry(options.host))).href : `vsl@${marketplace}`,
+      marketplace: options.host === "claude-code" ? marketplace : undefined,
+      marketplacePath: options.host === "claude-code" ? marketplacePath : undefined,
+      sourceFiles: await inventory(stagedRoot),
+      dependency: options.host !== "claude-code" ? dependencyOf(await readObject(packageJsonPath)) : undefined,
+      pluginVersion: options.host === "claude-code" ? pluginVersion : undefined,
+      commandDirectory: options.host === "bitfun" ? paths.commandDirectory : undefined,
+      commandFiles: selectedCommandFiles ? Object.fromEntries(Object.entries(selectedCommandFiles).map(([path2, content]) => [path2, digest(content)])) : undefined,
+      originalCommandFiles: commandFilesBefore ? { ...commandFilesBefore, ...previous?.originalCommandFiles } : undefined,
+      originalPluginEntries: previous?.originalPluginEntries ?? originalEntries,
+      originalDependency: previous ? previous.originalDependency : dependencyBefore,
+      originalRuntime: previous ? previous.originalRuntime : originalRuntime,
+      installedAt: new Date().toISOString(),
+      status: "configured",
+      restartRequired: true
+    };
+    await writeJson(paths.receiptPath, receipt);
+    const report = await doctor(options);
+    if (!report.configured)
+      throw new Error("Installed host registration failed verification");
+    await rm(paths.journalPath);
+    return { ...report, recoveryRequired: false };
+  } finally {
+    await lock.close();
+    await rm(paths.lockPath);
+  }
+}
+async function doctor(options) {
+  const paths = installationPaths(options);
+  const receipt = await readReceipt(paths.receiptPath);
+  if (!receipt)
+    return {
+      installed: false,
+      configured: false,
+      loaded: "not checked",
+      verified: false,
+      configDirectory: paths.configDirectory,
+      recoveryRequired: await Bun.file(paths.journalPath).exists()
+    };
+  const changed = await changedFiles(receipt);
+  const config = await readObject(receipt.configPath);
+  const dependency = options.host !== "claude-code" ? dependencyOf(await readObject(join5(paths.configDirectory, "package.json"))) : undefined;
+  const commandChanges = receipt.commandDirectory ? (await Promise.all(Object.entries(receipt.commandFiles ?? {}).map(async ([path2, hash]) => digest(await textOrUndefined(inside(receipt.commandDirectory, path2)) ?? "") === hash ? undefined : `commands/${path2}`))).filter((path2) => !!path2) : [];
+  changed.push(...commandChanges);
+  const registration = options.host !== "claude-code" ? Array.isArray(config.plugin) && config.plugin.filter((item) => isVslEntry(entrySpec(item))).length === 1 && config.plugin.includes(receipt.entry) && dependency === receipt.dependency : await claudeInstalledRoot(paths.configDirectory, receipt.entry, receipt.pluginVersion).then((root) => root === receipt.packageRoot).catch(() => false);
+  return {
+    host: receipt.host,
+    version: receipt.version,
+    buildId: receipt.buildId,
+    modules: receipt.modules,
+    installationId: receipt.installationId,
+    crBinary: receipt.crBinary,
+    packageRoot: receipt.packageRoot,
+    configDirectory: receipt.configDirectory,
+    changedFiles: changed,
+    installed: changed.length === 0,
+    configured: changed.length === 0 && registration,
+    recoveryRequired: await Bun.file(paths.journalPath).exists(),
+    restartRequired: true,
+    loaded: "not checked",
+    verified: false,
+    runtimeProof: "After restarting the host, call vsl_runtime_info there and compare buildId, installationId and modules with this report."
+  };
+}
+async function uninstall(options, dryRun = false) {
+  const paths = installationPaths(options);
+  const receipt = await readReceipt(paths.receiptPath);
+  if (!receipt)
+    return { removed: false, reason: "No managed installation" };
+  await assertOwnedFiles(receipt);
+  const report = await doctor(options);
+  if (!report.configured)
+    throw new Error("Host registration changed; resolve doctor diagnostics before uninstalling");
+  if (dryRun)
+    return {
+      host: receipt.host,
+      action: "uninstall",
+      entry: receipt.entry,
+      restoreDependency: receipt.originalDependency,
+      preserve: ["user files", "external tools", "historical release evidence"],
+      dryRun: true
+    };
+  const lock = await acquireLock(paths.lockPath);
+  try {
+    if (await Bun.file(paths.journalPath).exists())
+      throw new Error("Recover the unfinished installation before uninstalling");
+    await assertOwnedFiles(receipt);
+    if (!(await doctor(options)).configured)
+      throw new Error("Registration changed during uninstall planning");
+    await writeJson(paths.journalPath, {
+      phase: "uninstalling",
+      previous: receipt,
+      configPath: receipt.configPath,
+      commandDirectory: receipt.commandDirectory,
+      commandFilesBefore: receipt.commandDirectory ? Object.fromEntries(await Promise.all(Object.keys(receipt.commandFiles ?? {}).map(async (path2) => [path2, await textOrUndefined(inside(receipt.commandDirectory, path2)) ?? null]))) : undefined,
+      marketplaceBefore: receipt.marketplacePath ? await textOrUndefined(join5(receipt.marketplacePath, ".claude-plugin/marketplace.json")) : undefined
+    });
+    if (receipt.host !== "claude-code") {
+      const config = await readObject(receipt.configPath);
+      await patchJson(receipt.configPath, ["plugin"], [...config.plugin.filter((entry) => entry !== receipt.entry), ...receipt.originalPluginEntries]);
+      if (receipt.originalDependency) {
+        await command([
+          "npm",
+          "install",
+          "--prefix",
+          receipt.configDirectory,
+          "--ignore-scripts",
+          "--install-links",
+          "--no-audit",
+          "--no-fund",
+          receipt.originalDependency.startsWith("file:") ? resolve5(receipt.configDirectory, receipt.originalDependency.slice(5)) : `@bitfun-vsl/plugin@${receipt.originalDependency}`
+        ]);
+        await patchJson(join5(receipt.configDirectory, "package.json"), ["dependencies", "@bitfun-vsl/plugin"], receipt.originalDependency);
+        if (receipt.originalRuntime)
+          await Bun.write(join5(receipt.packageRoot, "assets/runtime.json"), receipt.originalRuntime);
+      }
+      if (!receipt.originalDependency)
+        await command(["npm", "uninstall", "--prefix", receipt.configDirectory, "--ignore-scripts", "--no-audit", "--no-fund", "@bitfun-vsl/plugin"]);
+    }
+    if (receipt.host === "claude-code") {
+      await command(["claude", "plugin", "uninstall", receipt.entry, "--scope", "user", "--keep-data"], claudeEnvironment(receipt.configDirectory));
+      await command(["claude", "plugin", "marketplace", "remove", receipt.marketplace, "--scope", "user"], claudeEnvironment(receipt.configDirectory));
+    }
+    if (receipt.commandDirectory)
+      await restoreCommands(receipt.commandDirectory, Object.fromEntries(Object.keys(receipt.commandFiles ?? {}).map((path2) => [path2, receipt.originalCommandFiles?.[path2] ?? null])));
+    await rename(paths.receiptPath, join5(paths.instance, `uninstalled-${Date.now()}.json`));
+    await rm(paths.journalPath);
+    return { removed: true, host: receipt.host, restartRequired: true };
+  } finally {
+    await lock.close();
+    await rm(paths.lockPath);
+  }
+}
+async function recover(options) {
+  const paths = installationPaths(options);
+  const journal = await readObject(paths.journalPath);
+  if (!Object.keys(journal).length)
+    return { recovered: false, reason: "No unfinished transaction" };
+  const lock = await acquireLock(paths.lockPath);
+  try {
+    if (journal.phase !== "staging") {
+      const previous = journal.previous;
+      if (options.host !== "claude-code") {
+        const configPath = String(journal.configPath);
+        const current = await readObject(configPath);
+        const entries = current.plugin ?? [];
+        if (!Array.isArray(entries))
+          throw new Error("Invalid host plugin configuration; manual recovery required");
+        const restoredEntries = previous ? [previous.entry] : Array.isArray(journal.originalEntries) ? journal.originalEntries : [];
+        const foreign = entries.filter((entry) => isVslEntry(entrySpec(entry)) && !restoredEntries.includes(entry) && entry !== pathToFileURL(join5(paths.configDirectory, "node_modules/@bitfun-vsl/plugin", hostEntry(options.host))).href);
+        if (foreign.length)
+          throw new Error("VSL registration changed externally; preserving recovery evidence");
+        const dependency = previous?.dependency ?? (typeof journal.dependencyBefore === "string" ? journal.dependencyBefore : undefined);
+        if (dependency) {
+          await command(["npm", "install", "--prefix", paths.configDirectory, "--ignore-scripts", "--install-links", "--no-audit", "--no-fund", dependency.startsWith("file:") ? resolve5(paths.configDirectory, dependency.slice(5)) : `@bitfun-vsl/plugin@${dependency}`]);
+          await patchJson(join5(paths.configDirectory, "package.json"), ["dependencies", "@bitfun-vsl/plugin"], dependency);
+          if (!previous && typeof journal.originalRuntime === "string")
+            await Bun.write(join5(paths.configDirectory, "node_modules/@bitfun-vsl/plugin/assets/runtime.json"), journal.originalRuntime);
+        }
+        if (!dependency)
+          await command(["npm", "uninstall", "--prefix", paths.configDirectory, "--ignore-scripts", "--no-audit", "--no-fund", "@bitfun-vsl/plugin"]);
+        await patchJson(configPath, ["plugin"], [...entries.filter((entry) => !isVslEntry(entrySpec(entry))), ...restoredEntries]);
+      }
+      if (options.host === "claude-code") {
+        const marketplace = typeof journal.marketplace === "string" ? journal.marketplace : previous?.marketplace;
+        if (!marketplace)
+          throw new Error("Missing marketplace recovery identity");
+        const entry = `vsl@${marketplace}`;
+        if (typeof journal.marketplaceBefore === "string") {
+          await Bun.write(join5(paths.instance, "marketplace/.claude-plugin/marketplace.json"), journal.marketplaceBefore);
+          if (journal.phase === "uninstalling")
+            await command(["claude", "plugin", "marketplace", "add", join5(paths.instance, "marketplace"), "--scope", "user"], claudeEnvironment(paths.configDirectory));
+          await command(["claude", "plugin", "marketplace", "update", marketplace], claudeEnvironment(paths.configDirectory));
+          await command(["claude", "plugin", journal.phase === "uninstalling" ? "install" : "update", entry, "--scope", "user"], claudeEnvironment(paths.configDirectory));
+        }
+        if (!previous) {
+          const inventory = JSON.parse(await command(["claude", "plugin", "list", "--json"], claudeEnvironment(paths.configDirectory)));
+          if (Array.isArray(inventory) && inventory.some((item) => item?.id === entry))
+            await command(["claude", "plugin", "uninstall", entry, "--scope", "user", "--keep-data"], claudeEnvironment(paths.configDirectory));
+          await command(["claude", "plugin", "marketplace", "remove", marketplace, "--scope", "user"], claudeEnvironment(paths.configDirectory));
+        }
+      }
+      if (options.host === "bitfun" && journal.commandFilesBefore && typeof journal.commandDirectory === "string")
+        await restoreCommands(journal.commandDirectory, journal.commandFilesBefore);
+      if (previous)
+        await writeJson(paths.receiptPath, previous);
+      if (!previous)
+        await rm(paths.receiptPath, { force: true });
+    }
+    await rm(paths.journalPath);
+    return { recovered: true, retainedRelease: journal.releaseRoot };
+  } finally {
+    await lock.close();
+    await rm(paths.lockPath);
+  }
+}
+async function verifyPackage(root) {
+  const manifest = await Bun.file(join5(root, "assets/install-manifest.json")).json();
+  if (manifest.schemaVersion !== 1 || !manifest.buildId || !manifest.files || !Array.isArray(manifest.modules))
+    throw new Error("Invalid VSL install manifest");
+  const pkg = await Bun.file(join5(root, "package.json")).json();
+  if (pkg.name !== "@bitfun-vsl/plugin" || pkg.version !== manifest.version)
+    throw new Error("VSL package identity differs from install manifest");
+  for (const required of ["dist/hosts/deveco/plugin.js", "dist/hosts/bitfun-kernel/plugin.js", "dist/index.js", "dist/install/resources.js", "assets/claude-code/scripts/mcp-server.js", "assets/claude-code/.mcp.json", "assets/build.json"]) {
+    if (!(required in manifest.files))
+      throw new Error(`Missing required manifest entry: ${required}`);
+  }
+  const invalid = (await Promise.all(Object.entries(manifest.files).map(async ([path2, hash]) => await Bun.file(inside(root, path2)).bytes().then((content) => digest(content) === hash ? undefined : path2).catch(() => path2)))).filter(Boolean);
+  if (invalid.length)
+    throw new Error(`Package files failed verification: ${invalid.join(", ")}`);
+  return manifest;
+}
+async function command(args, env = process.env) {
+  const executable = Bun.which(args[0], { PATH: env.PATH });
+  if (!executable)
+    throw new Error(`Required command not found: ${args[0]}`);
+  const nativeClaude = join5(dirname3(executable), "node_modules/@anthropic-ai/claude-code/bin/claude.exe");
+  const npmCli = join5(dirname3(executable), "node_modules/npm/bin/npm-cli.js");
+  const invocation = process.platform === "win32" && /\.(cmd|bat)$/i.test(executable) ? args[0] === "npm" && await Bun.file(npmCli).exists() ? [Bun.which("node") ?? process.execPath, npmCli] : args[0] === "claude" && await Bun.file(nativeClaude).exists() ? [nativeClaude] : undefined : [executable];
+  if (!invocation)
+    throw new Error(`Cannot safely resolve command shim: ${executable}; use a native CLI installation`);
+  const child = Bun.spawn([...invocation, ...args.slice(1)], { env, stdout: "pipe", stderr: "pipe", stdin: "ignore", timeout: 180000 });
+  const [stdout, stderr, code] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+  if (code !== 0)
+    throw new Error(`${args.slice(0, 3).join(" ")} failed (${code}): ${stderr || stdout}`);
+  return stdout;
+}
+async function readObject(path2) {
+  const text = await textOrUndefined(path2);
+  if (text === undefined)
+    return {};
+  const errors2 = [];
+  const value = parse2(text, errors2, { allowTrailingComma: true });
+  if (errors2.length || !value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`Invalid JSON/JSONC: ${path2}`);
+  return value;
+}
+async function readReceipt(path2) {
+  const value = await readObject(path2);
+  if (!Object.keys(value).length)
+    return;
+  if (value.schemaVersion !== 1 || !value.files || typeof value.packageRoot !== "string")
+    throw new Error(`Invalid installation receipt: ${path2}`);
+  return value;
+}
+async function devecoConfigPath(root) {
+  const candidates = await Promise.all(["deveco.jsonc", "deveco.json"].map(async (name) => await Bun.file(join5(root, name)).exists() ? join5(root, name) : undefined));
+  const found = candidates.filter((path2) => !!path2);
+  if (found.length > 1)
+    throw new Error("Both deveco.json and deveco.jsonc exist; choose one effective configuration before installing");
+  return found[0] ?? join5(root, "deveco.jsonc");
+}
+function isVslEntry(value) {
+  return value === "@bitfun-vsl/plugin" || value.startsWith("@bitfun-vsl/plugin/") || value.startsWith("@bitfun-vsl/plugin@") || value.startsWith("file:") && /\/@bitfun-vsl\/plugin\/dist\/(?:index\.js|hosts\/(?:deveco|bitfun-kernel)\/plugin\.js)$/.test(decodeURI(value).replaceAll("\\", "/"));
+}
+function entrySpec(value) {
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value) && typeof value[0] === "string")
+    return value[0];
+  if (value && typeof value === "object" && "spec" in value && typeof value.spec === "string")
+    return value.spec;
+  throw new Error("Invalid host plugin declaration");
+}
+function hostEntry(host) {
+  return `dist/hosts/${host === "bitfun" ? "bitfun-kernel" : "deveco"}/plugin.js`;
+}
+function validatePluginConfig(config, previous) {
+  if (config.plugin !== undefined && !Array.isArray(config.plugin))
+    throw new Error("Host plugin configuration must be an array");
+  const entries = config.plugin ?? [];
+  const own = entries.filter((entry) => isVslEntry(entrySpec(entry)));
+  if (own.some((entry) => entrySpec(entry).startsWith("file:") && entrySpec(entry) !== previous?.entry))
+    throw new Error("Unmanaged VSL file URL requires explicit removal before installation");
+  return own;
+}
+async function restoreCommands(root, files) {
+  for (const [path2, content] of Object.entries(files)) {
+    const target = inside(root, path2);
+    if (content === null) {
+      await rm(target, { force: true });
+      continue;
+    }
+    await mkdir3(dirname3(target), { recursive: true });
+    await Bun.write(target, content);
+  }
+}
+function dependencyOf(config) {
+  const deps = config.dependencies;
+  if (deps === undefined)
+    return;
+  if (!deps || typeof deps !== "object" || Array.isArray(deps))
+    throw new Error("Invalid host dependencies");
+  const value = deps["@bitfun-vsl/plugin"];
+  if (value !== undefined && typeof value !== "string")
+    throw new Error("Invalid VSL dependency");
+  return value;
+}
+async function inventory(root) {
+  return Object.fromEntries(await Promise.all((await filesUnder(root)).map(async (path2) => [path2, digest(await Bun.file(join5(root, path2)).bytes())])));
+}
+async function changedFiles(receipt) {
+  const current = await inventory(receipt.packageRoot).catch(() => ({}));
+  return [...new Set([...Object.keys(receipt.files), ...Object.keys(current)])].filter((path2) => current[path2] !== receipt.files[path2]);
+}
+async function assertOwnedFiles(receipt) {
+  const changed = await changedFiles(receipt);
+  if (changed.length)
+    throw new Error(`Managed files were modified; preserving them: ${changed.join(", ")}`);
+  if (receipt.commandDirectory) {
+    for (const [path2, hash] of Object.entries(receipt.commandFiles ?? {})) {
+      if (digest(await textOrUndefined(inside(receipt.commandDirectory, path2)) ?? "") !== hash)
+        throw new Error(`Managed files were modified; preserving them: ${path2}`);
+    }
+  }
+  const sourceRoot = join5(receipt.releaseRoot, "node_modules/@bitfun-vsl/plugin");
+  const current = await inventory(sourceRoot);
+  if (JSON.stringify(current) !== JSON.stringify(receipt.sourceFiles))
+    throw new Error("Staged release was modified; preserving installation");
+}
+async function claudeInstalledRoot(configDirectory, entry, version) {
+  const plugins = JSON.parse(await command(["claude", "plugin", "list", "--json"], claudeEnvironment(configDirectory)));
+  if (!Array.isArray(plugins))
+    throw new Error("Invalid Claude inventory");
+  const item = plugins.find((item2) => item2 && typeof item2 === "object" && item2.id === entry && item2.scope === "user");
+  if (!item || typeof item !== "object" || !("installPath" in item) || typeof item.installPath !== "string" || !("version" in item) || item.version !== version || !("enabled" in item) || item.enabled !== true)
+    throw new Error("Claude did not activate the expected plugin version");
+  return item.installPath;
+}
+function claudeEnvironment(configDirectory) {
+  return { ...process.env, CLAUDE_CONFIG_DIR: configDirectory };
+}
+async function textOrUndefined(path2) {
+  return await Bun.file(path2).exists() ? Bun.file(path2).text() : undefined;
+}
+async function writeJson(path2, value) {
+  await mkdir3(dirname3(path2), { recursive: true });
+  const temporary = `${path2}.${crypto.randomUUID()}.tmp`;
+  await Bun.write(temporary, `${JSON.stringify(value, null, 2)}
+`);
+  await rename(temporary, path2);
+}
+async function patchJson(path2, keys, value) {
+  const raw = await textOrUndefined(path2) ?? `{}
+`;
+  await readObject(path2);
+  await mkdir3(dirname3(path2), { recursive: true });
+  await Bun.write(path2, applyEdits(raw, modify(raw, keys, value, { formattingOptions: { insertSpaces: true, tabSize: 2 } })));
+}
+async function acquireLock(path2) {
+  if (await Bun.file(path2).exists()) {
+    const value = await Bun.file(path2).json();
+    if (!value || typeof value !== "object" || !("pid" in value) || typeof value.pid !== "number" || !Number.isInteger(value.pid) || value.pid <= 0)
+      throw new Error(`Invalid installation lock: ${path2}`);
+    const owner = value.pid;
+    const exited = await Promise.resolve().then(() => {
+      process.kill(owner, 0);
+      return false;
+    }).catch((error) => error instanceof Error && ("code" in error) && error.code === "ESRCH");
+    if (!exited)
+      throw new Error(`Another installer owns ${path2} (PID ${owner})`);
+    await rm(path2);
+  }
+  const handle = await open(path2, "wx").catch(() => {
+    throw new Error(`Installation is locked: ${path2}`);
+  });
+  await handle.writeFile(JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }));
+  return handle;
+}
+async function safeRemove(root, target) {
+  const checked = inside(root, target);
+  if (checked === resolve5(root))
+    throw new Error("Refusing to remove installation root");
+  await rm(checked, { recursive: true, force: true });
+}
+
+// src/cli/index.ts
+var hostChoices = [
+  { name: "DevEco Code", value: "deveco" },
+  { name: "Claude Code", value: "claude-code" },
+  { name: "BitFun", value: "bitfun" }
+];
+var moduleChoices = () => selectResources().modules.map((module) => ({
+  name: `${module.id} \u2014 ${module.description}`,
+  value: module.id,
+  checked: true
+}));
+async function main(args = process.argv.slice(2)) {
+  if (args.includes("--version")) {
+    console.log(build_default.version);
+    return;
+  }
+  if (!args.length || args.includes("--help")) {
+    console.log(`vsl <init|update|doctor|uninstall|recover> [--host deveco|claude-code|bitfun] [--modules id,id] [--package path] [--config-dir path] [--command-dir path] [--state-dir path] [--cr-bin path] [--dry-run] [--yes] [--json]
+
+vsl init: \u9009\u62E9\u5BBF\u4E3B \u2192 \u9009\u62E9\u6A21\u5757\uFF08\u9ED8\u8BA4\u5168\u9009\uFF09\u2192 \u786E\u8BA4\u5B89\u88C5\u3002
+\u5BBF\u4E3B\u652F\u6301\u591A\u9009\uFF0C\u4E5F\u53EF\u91CD\u590D\u4F20\u5165 --host\u3002\u9700\u8981 Bun\u3001npm\uFF1BClaude \u5B89\u88C5\u8FD8\u9700\u8981 Claude CLI\u3002`);
+    return;
+  }
+  const action = args[0];
+  if (!["init", "update", "doctor", "uninstall", "recover"].includes(action))
+    throw new Error(`Unknown command: ${action}`);
+  const values = new Map;
+  const flags = new Set;
+  const parseArgs = (index) => {
+    if (index >= args.length)
+      return;
+    const key = args[index];
+    if (["--dry-run", "--yes", "--json"].includes(key)) {
+      flags.add(key);
+      return parseArgs(index + 1);
+    }
+    if (!["--host", "--modules", "--package", "--config-dir", "--command-dir", "--state-dir", "--cr-bin", "--scope"].includes(key))
+      throw new Error(`Unknown option: ${key}`);
+    const value = args[index + 1];
+    if (!value || value.startsWith("--"))
+      throw new Error(`Missing value: ${key}`);
+    values.set(key, [...values.get(key) ?? [], value]);
+    parseArgs(index + 2);
+  };
+  parseArgs(1);
+  const repeated = [...values].find(([key, items]) => key !== "--host" && items.length > 1);
+  if (repeated)
+    throw new Error(`Option cannot be repeated: ${repeated[0]}`);
+  if (values.has("--scope") && values.get("--scope")?.[0] !== "user")
+    throw new Error("Only user scope is supported");
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY && !flags.has("--yes") && !flags.has("--json"));
+  const installing = action === "init" || action === "update";
+  if (interactive && installing)
+    console.log(`
+VSL v${build_default.version} \u5B89\u88C5\u5411\u5BFC
+`);
+  const hosts = values.get("--host")?.flatMap((value) => value.split(",")) ?? (interactive ? await dist_default4({ message: "\u7B2C\u4E00\u6B65\uFF1A\u9009\u62E9\u5BBF\u4E3B\uFF08\u7A7A\u683C\u52FE\u9009\uFF0C\u56DE\u8F66\u7EE7\u7EED\uFF09", choices: hostChoices, required: true }) : []);
+  if (!hosts.length || hosts.some((host) => !hostChoices.some((choice) => choice.value === host)))
+    throw new Error("Specify --host deveco, --host claude-code or --host bitfun");
+  if (new Set(hosts).size !== hosts.length)
+    throw new Error("Duplicate host selection");
+  if (hosts.length > 1 && values.has("--config-dir"))
+    throw new Error("--config-dir requires exactly one host");
+  if (values.has("--command-dir") && !hosts.includes("bitfun"))
+    throw new Error("--command-dir requires the BitFun host");
+  const modules = values.get("--modules")?.[0]?.split(",") ?? (installing && interactive ? await dist_default4({ message: "\u7B2C\u4E8C\u6B65\uFF1A\u9009\u62E9\u6A21\u5757\uFF08\u9ED8\u8BA4\u5168\u9009\uFF0C\u7A7A\u683C\u5207\u6362\uFF0C\u56DE\u8F66\u7EE7\u7EED\uFF09", choices: moduleChoices(), required: true }) : undefined);
+  if (modules?.some((name) => !name.trim()) || modules?.length === 0)
+    throw new Error("Select at least one module");
+  selectResources(modules);
+  const options = hosts.map((host) => ({
+    host,
+    configDirectory: values.get("--config-dir")?.[0],
+    commandDirectory: values.get("--command-dir")?.[0],
+    stateDirectory: values.get("--state-dir")?.[0],
+    source: values.get("--package")?.[0],
+    modules,
+    crBinary: values.get("--cr-bin")?.[0]
+  }));
+  const plans = await Promise.all(options.map((option) => action === "uninstall" ? uninstall(option, true) : installing ? planInstallation(option) : Promise.resolve(undefined)));
+  if (flags.has("--dry-run")) {
+    console.log(JSON.stringify(plans, null, 2));
+    return;
+  }
+  if (installing || action === "uninstall" || action === "recover") {
+    if (interactive) {
+      console.log(`
+\u5BBF\u4E3B\uFF1A${hosts.map((host) => hostChoices.find((choice) => choice.value === host).name).join("\u3001")}`);
+      if (installing)
+        console.log(`\u6A21\u5757\uFF1A${(modules ?? selectResources().modules.map((module) => module.id)).join("\u3001")}
+\u5B89\u88C5\u6765\u6E90\uFF1A${values.get("--package")?.[0] ?? "\u5F53\u524D VSL \u5305"}`);
+    }
+    if (!flags.has("--yes") && !interactive)
+      throw new Error("Non-interactive changes require --yes");
+    if (!flags.has("--yes") && !await dist_default5({ message: installing ? "\u662F\u5426\u6267\u884C\u5B89\u88C5\uFF1F" : action === "uninstall" ? "\u662F\u5426\u6267\u884C\u5378\u8F7D\uFF1F" : "\u662F\u5426\u6062\u590D\u5B89\u88C5\uFF1F", default: true })) {
+      console.log("\u5DF2\u53D6\u6D88\uFF0C\u672A\u4FEE\u6539\u5BBF\u4E3B\u914D\u7F6E\u3002");
+      return;
+    }
+  }
+  const results = [];
+  for (const option of options) {
+    try {
+      if (!flags.has("--json"))
+        console.log(`
+\u6B63\u5728\u5904\u7406 ${hostChoices.find((choice) => choice.value === option.host).name}\u2026`);
+      const result = action === "doctor" ? await doctor(option) : action === "recover" ? await recover(option) : action === "uninstall" ? await uninstall(option) : await install(option);
+      results.push(result);
+      if ("configured" in result && !result.configured || "recoveryRequired" in result && result.recoveryRequired)
+        process.exitCode = 1;
+      if (!flags.has("--json")) {
+        console.log("configured" in result ? result.configured ? "\u5B89\u88C5\u914D\u7F6E\u68C0\u67E5\u901A\u8FC7\u3002" : "\u5C1A\u672A\u6B63\u786E\u914D\u7F6E\uFF0C\u8BF7\u68C0\u67E5\u5B89\u88C5\u72B6\u6001\u3002" : JSON.stringify(result));
+        if ("packageRoot" in result)
+          console.log(`\u63D2\u4EF6\u4F4D\u7F6E\uFF1A${result.packageRoot}`);
+        if ("buildId" in result)
+          console.log(`\u7248\u672C\uFF1A${result.version}
+\u6784\u5EFA\uFF1A${result.buildId}`);
+        if ("modules" in result && result.modules?.includes("code-review"))
+          console.log(result.crBinary ? `CR \u7A0B\u5E8F\uFF1A${result.crBinary}` : "\u672A\u68C0\u6D4B\u5230 CR \u539F\u751F\u7A0B\u5E8F\uFF1B\u8BF7\u5B89\u88C5\u540E\u91CD\u65B0\u8FD0\u884C init\uFF0C\u6216\u4F7F\u7528 --cr-bin \u6307\u5B9A\u5176\u7EDD\u5BF9\u8DEF\u5F84\u3002");
+        if ("configured" in result && result.configured)
+          console.log("\u8BF7\u91CD\u542F\u5BBF\u4E3B\uFF0C\u5728\u5BBF\u4E3B\u4E2D\u8C03\u7528 vsl_runtime_info \u6838\u5BF9\u6784\u5EFA\u4E0E\u6A21\u5757\uFF0C\u518D\u89E6\u53D1\u5BF9\u5E94 command\u3002");
+        if (option.host === "bitfun" && "configured" in result && result.configured)
+          console.log("BitFun \u8FD8\u9700\u542F\u7528 OpenCode \u517C\u5BB9\uFF1Abitfun config external set-enabled true --scope global\uFF1Bbitfun config external set-mode recommended --ecosystem opencode --scope global\u3002\u5728\u4F1A\u8BDD\u4E2D\u7528 /extensions \u68C0\u67E5\u6765\u6E90\u72B6\u6001\u3002");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({ host: option.host, failed: true, error: message });
+      process.exitCode = 1;
+      if (!flags.has("--json"))
+        console.error(`${option.host} \u5931\u8D25\uFF1A${message}`);
+    }
+  }
+  if (flags.has("--json"))
+    console.log(JSON.stringify(results, null, 2));
+}
+if (import.meta.main)
+  await main().catch((error) => {
+    if (error instanceof Error && error.name === "ExitPromptError") {
+      console.error("\u5DF2\u53D6\u6D88\u3002");
+      process.exitCode = 130;
+      return;
+    }
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+export {
+  moduleChoices,
+  main,
+  hostChoices
+};