@vsceasy/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,3169 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/lib/config.ts
+function configPath(projectRoot) {
+  for (const f of CONFIG_FILES) {
+    const p = path.join(projectRoot, f);
+    if (fs.existsSync(p))
+      return p;
+  }
+  return null;
+}
+function readConfig(projectRoot) {
+  const p = configPath(projectRoot);
+  if (!p)
+    return {};
+  try {
+    if (p.endsWith(".json")) {
+      return JSON.parse(fs.readFileSync(p, "utf8"));
+    }
+    const src = fs.readFileSync(p, "utf8");
+    return parseExportDefault(src);
+  } catch {
+    return {};
+  }
+}
+function parseExportDefault(src) {
+  let literal = extractBracedLiteral(src, /export\s+default\s*\{/);
+  if (!literal) {
+    literal = extractBracedLiteral(src, /(?:const|let|var)\s+[A-Za-z_$][\w$]*\s*(?::\s*[^=]+)?=\s*\{/);
+  }
+  if (!literal)
+    return {};
+  try {
+    const jsonish = literal.replace(/\/\/.*$/gm, "").replace(/,\s*([}\]])/g, "$1").replace(/([{,]\s*)([A-Za-z_][\w]*)\s*:/g, '$1"$2":').replace(/'/g, '"');
+    return JSON.parse(jsonish);
+  } catch {
+    return {};
+  }
+}
+function extractBracedLiteral(src, head) {
+  const m = head.exec(src);
+  if (!m)
+    return null;
+  const openIdx = m.index + m[0].length - 1;
+  let depth = 0;
+  for (let i = openIdx;i < src.length; i++) {
+    const c = src[i];
+    if (c === "{")
+      depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0)
+        return src.slice(openIdx, i + 1);
+    }
+  }
+  return null;
+}
+function writeConfig(projectRoot, cfg) {
+  const target = path.join(projectRoot, "vsceasy.config.ts");
+  const body = `import type { VsceasyConfig } from 'vsceasy';
+
+const config: VsceasyConfig = ${stringify(cfg)};
+
+export default config;
+`;
+  fs.writeFileSync(target, body);
+  return target;
+}
+function stringify(obj) {
+  const entries = Object.entries(obj).filter(([, v]) => v !== undefined);
+  if (entries.length === 0)
+    return "{}";
+  const lines = entries.map(([k, v]) => `  ${k}: ${JSON.stringify(v)},`);
+  return `{
+${lines.join(`
+`)}
+}`;
+}
+var fs, path, CONFIG_FILES;
+var init_config = __esm(() => {
+  fs = __toESM(require("fs"));
+  path = __toESM(require("path"));
+  CONFIG_FILES = ["vsceasy.config.ts", "vsceasy.config.js", "vsceasy.config.json"];
+});
+
+// src/lib/scaffold.ts
+async function scaffold(opts) {
+  const src = path2.join(opts.templatesRoot, opts.ui);
+  if (!fs2.existsSync(src)) {
+    throw new Error(`Template not found: ${src}`);
+  }
+  if (fs2.existsSync(opts.targetDir) && fs2.readdirSync(opts.targetDir).length > 0) {
+    throw new Error(`Target directory not empty: ${opts.targetDir}`);
+  }
+  fs2.mkdirSync(opts.targetDir, { recursive: true });
+  const vars = buildVars(opts);
+  await copyTree(src, opts.targetDir, vars);
+  applyPreset(opts.targetDir, opts.preset ?? "full");
+  writeConfig(opts.targetDir, {
+    publisher: opts.publisher,
+    commandPrefix: vars.commandPrefix,
+    ui: opts.ui
+  });
+}
+function applyPreset(targetDir, preset) {
+  if (preset === "full")
+    return;
+  const removals = [
+    "src/panels/dashboard.ts",
+    "src/webview/panels/dashboard"
+  ];
+  for (const rel of removals) {
+    const abs = path2.join(targetDir, rel);
+    if (fs2.existsSync(abs))
+      fs2.rmSync(abs, { recursive: true, force: true });
+  }
+  const apiPath = path2.join(targetDir, "src", "shared", "api.ts");
+  if (fs2.existsSync(apiPath)) {
+    fs2.writeFileSync(apiPath, `// RPC contracts go here. One interface per panel/subpanel.
+// Example:
+// export interface DashboardApi {
+//   ping(): Promise<string>;
+// }
+`);
+  }
+}
+function buildVars(opts) {
+  const simpleName = opts.name.replace(/^@[^/]+\//, "");
+  const commandPrefix = simpleName.replace(/[^a-zA-Z0-9]+/g, "");
+  return {
+    name: opts.name,
+    displayName: opts.displayName,
+    description: opts.description,
+    publisher: opts.publisher,
+    commandPrefix
+  };
+}
+async function copyTree(srcDir, destDir, vars) {
+  for (const entry of fs2.readdirSync(srcDir, { withFileTypes: true })) {
+    if (SKIP_NAMES.has(entry.name))
+      continue;
+    const srcPath = path2.join(srcDir, entry.name);
+    const destPath = path2.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      fs2.mkdirSync(destPath, { recursive: true });
+      await copyTree(srcPath, destPath, vars);
+    } else if (entry.isFile()) {
+      const ext = path2.extname(entry.name);
+      if (PLACEHOLDER_EXTS.has(ext) || entry.name.startsWith(".")) {
+        const content = fs2.readFileSync(srcPath, "utf8");
+        fs2.writeFileSync(destPath, substitute(content, vars));
+      } else {
+        fs2.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}
+function substitute(input, vars) {
+  return input.replace(/\{\{(\w+)\}\}/g, (_m, key) => vars[key] ?? `{{${key}}}`);
+}
+var fs2, path2, PLACEHOLDER_EXTS, SKIP_NAMES;
+var init_scaffold = __esm(() => {
+  init_config();
+  fs2 = __toESM(require("fs"));
+  path2 = __toESM(require("path"));
+  PLACEHOLDER_EXTS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".json",
+    ".md",
+    ".html",
+    ".css",
+    ".cjs",
+    ".mjs",
+    ".yml",
+    ".yaml"
+  ]);
+  SKIP_NAMES = new Set(["node_modules", "dist", ".DS_Store"]);
+});
+
+// src/lib/validate.ts
+function assertId(field, value) {
+  const trimmed = (value ?? "").trim();
+  if (!trimmed)
+    throw new Error(`${field} is required.`);
+  if (!ID_RE.test(trimmed)) {
+    throw new Error(`Invalid ${field}: "${trimmed}". Use camelCase starting with a lowercase letter (e.g. \`myPanel\`, \`doStuff\`).`);
+  }
+  return trimmed;
+}
+function assertNoOverwrite(projectRoot, target, kind) {
+  if (fs3.existsSync(target)) {
+    throw new Error(`${kind} already exists at \`${path3.relative(projectRoot, target)}\`. Pick a different name or delete the file first.`);
+  }
+}
+function assertSiblingExists(projectRoot, kind, id) {
+  const dir = `${kind}s`;
+  const dirPath = path3.join(projectRoot, "src", dir);
+  const candidates = [
+    path3.join(dirPath, `${id}.ts`),
+    path3.join(dirPath, `${id}.tsx`)
+  ];
+  for (const p of candidates)
+    if (fs3.existsSync(p))
+      return p;
+  const existing = listSiblings(dirPath);
+  const hint = existing.length ? ` Available ${kind}s: ${existing.map((n) => `"${n}"`).join(", ")}.` : ` No ${kind}s exist yet — run \`vsceasy ${kind} add --name <id>\` first.`;
+  throw new Error(`${kind} "${id}" not found at \`src/${dir}/${id}.ts\`.${hint}`);
+}
+function listSiblings(dirPath) {
+  if (!fs3.existsSync(dirPath))
+    return [];
+  return fs3.readdirSync(dirPath, { withFileTypes: true }).filter((e) => e.isFile() && /\.(ts|tsx)$/.test(e.name) && !e.name.startsWith("_")).map((e) => e.name.replace(/\.(ts|tsx)$/, "")).sort();
+}
+var fs3, path3, ID_RE;
+var init_validate = __esm(() => {
+  fs3 = __toESM(require("fs"));
+  path3 = __toESM(require("path"));
+  ID_RE = /^[a-z][a-zA-Z0-9]*$/;
+});
+
+// src/lib/components/add.ts
+function addComponents(opts) {
+  const genDir = path4.join(opts.templatesRoot, "_generators", "components");
+  const outDir = path4.join(opts.projectRoot, "src", "webview", "components");
+  fs4.mkdirSync(outDir, { recursive: true });
+  const created = [];
+  const skipped = [];
+  for (const file of COMPONENT_FILES) {
+    const src = path4.join(genDir, `${file}.tpl`);
+    const dest = path4.join(outDir, file);
+    if (fs4.existsSync(dest) && !opts.force) {
+      skipped.push(dest);
+      continue;
+    }
+    fs4.writeFileSync(dest, fs4.readFileSync(src, "utf8"));
+    created.push(dest);
+  }
+  return { created, skipped, dir: outDir };
+}
+function componentsExist(projectRoot) {
+  return fs4.existsSync(path4.join(projectRoot, "src", "webview", "components", "index.ts"));
+}
+var fs4, path4, COMPONENT_FILES;
+var init_add = __esm(() => {
+  fs4 = __toESM(require("fs"));
+  path4 = __toESM(require("path"));
+  COMPONENT_FILES = [
+    "Button.tsx",
+    "Input.tsx",
+    "Field.tsx",
+    "Card.tsx",
+    "List.tsx",
+    "index.ts",
+    "components.css"
+  ];
+});
+
+// src/lib/panel/add.ts
+function addPanel(opts) {
+  const name = assertId("panel name", normalizeCamel(opts.name));
+  const Pascal = name.charAt(0).toUpperCase() + name.slice(1);
+  const title = opts.title ?? Pascal;
+  const template = opts.template ?? "blank";
+  if (!PANEL_TEMPLATES.includes(template)) {
+    throw new Error(`Unknown panel template "${template}". Available: ${PANEL_TEMPLATES.join(", ")}.`);
+  }
+  const withApi = template !== "blank" ? true : opts.withApi !== false;
+  const apiName = `${Pascal}Api`;
+  const panelTs = path5.join(opts.projectRoot, "src", "panels", `${name}.ts`);
+  const uiDir = path5.join(opts.projectRoot, "src", "webview", "panels", name);
+  const appTsx = path5.join(uiDir, "App.tsx");
+  const mainTsx = path5.join(uiDir, "main.tsx");
+  const apiPath = path5.join(opts.projectRoot, "src", "shared", "api.ts");
+  assertNoOverwrite(opts.projectRoot, panelTs, "Panel");
+  assertNoOverwrite(opts.projectRoot, uiDir, "Webview dir");
+  const genDir = path5.join(opts.templatesRoot, "_generators", "panel");
+  const readTpl = (n) => fs5.readFileSync(path5.join(genDir, n), "utf8");
+  const vars = {
+    name,
+    Name: Pascal,
+    title,
+    api: withApi ? apiName : "",
+    apiImport: withApi ? `import type { ${apiName} } from '../shared/api';
+` : "",
+    apiGeneric: withApi ? `<${apiName}>` : "",
+    rpcBlock: withApi ? `
+  rpc: (vscode) => ({
+    // add RPC handlers here
+  }),` : "",
+    apiBlock: withApi ? `import { connectWebview } from '../../../shared/vsceasy/client';
+import type { ${apiName} } from '../../../shared/api';
+
+const api = connectWebview<${apiName}>();
+void api;
+` : ""
+  };
+  const created = [];
+  const modified = [];
+  const skipped = [];
+  if (template !== "blank" && !componentsExist(opts.projectRoot)) {
+    const comp = addComponents({ projectRoot: opts.projectRoot, templatesRoot: opts.templatesRoot });
+    created.push(...comp.created);
+  }
+  fs5.mkdirSync(path5.dirname(panelTs), { recursive: true });
+  fs5.writeFileSync(panelTs, substitute(readTpl("panel.ts.tpl"), vars));
+  created.push(panelTs);
+  fs5.mkdirSync(uiDir, { recursive: true });
+  const appSrc = template === "blank" ? readTpl("App.tsx.tpl") : fs5.readFileSync(path5.join(genDir, "templates", template, "App.tsx.tpl"), "utf8");
+  fs5.writeFileSync(appTsx, substitute(appSrc, { ...vars, ...TEMPLATE_VARS[template] }));
+  created.push(appTsx);
+  fs5.writeFileSync(mainTsx, substitute(readTpl("main.tsx.tpl"), vars));
+  created.push(mainTsx);
+  if (withApi) {
+    appendApi(apiPath, apiName, API_BODY[template], created, modified, skipped);
+  }
+  let genRan = false;
+  if (opts.runGen !== false) {
+    genRan = runGen(opts.projectRoot);
+  }
+  return { created, modified, skipped, genRan };
+}
+function appendApi(apiPath, apiName, body, created, modified, skipped) {
+  const decl = `export interface ${apiName} {${body}}
+`;
+  if (!fs5.existsSync(apiPath)) {
+    fs5.mkdirSync(path5.dirname(apiPath), { recursive: true });
+    fs5.writeFileSync(apiPath, decl);
+    created.push(apiPath);
+    return;
+  }
+  const current = fs5.readFileSync(apiPath, "utf8");
+  const re = new RegExp(`\\bexport\\s+interface\\s+${apiName}\\b`);
+  if (re.test(current)) {
+    skipped.push(`${apiPath} (interface ${apiName} already declared)`);
+    return;
+  }
+  const sep = current.endsWith(`
+`) ? `
+` : `
+
+`;
+  fs5.writeFileSync(apiPath, current + sep + decl);
+  modified.push(apiPath);
+}
+function runGen(cwd) {
+  const tryRun = (cmd, args) => {
+    const r = import_child_process.spawnSync(cmd, args, { cwd, stdio: "inherit" });
+    return r.status === 0;
+  };
+  if (which("bun") && tryRun("bun", ["run", "gen"]))
+    return true;
+  if (which("npm") && tryRun("npm", ["run", "gen"]))
+    return true;
+  console.warn('\n! Could not run "gen" automatically. Run `bun run gen` (or `npm run gen`) manually to wire up the new panel.\n');
+  return false;
+}
+function which(cmd) {
+  const r = import_child_process.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" });
+  return r.status === 0;
+}
+function normalizeCamel(s) {
+  const cleaned = s.trim().replace(/[^a-zA-Z0-9]+(.)/g, (_m, c) => c.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "");
+  if (!cleaned)
+    return "";
+  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+}
+var fs5, path5, import_child_process, PANEL_TEMPLATES, API_BODY, TEMPLATE_VARS;
+var init_add2 = __esm(() => {
+  init_scaffold();
+  init_validate();
+  init_add();
+  fs5 = __toESM(require("fs"));
+  path5 = __toESM(require("path"));
+  import_child_process = require("child_process");
+  PANEL_TEMPLATES = ["blank", "form", "list", "dashboard"];
+  API_BODY = {
+    blank: "",
+    form: `
+  save(input: { name: string; email: string }): Promise<void>;
+`,
+    list: `
+  list(): Promise<{ id: string; label: string }[]>;
+`,
+    dashboard: `
+  stats(): Promise<{ total: number; active: number; updatedAt: string }>;
+`
+  };
+  TEMPLATE_VARS = {
+    blank: {},
+    form: { submitCall: "await api.save({ name, email });" },
+    list: { loadCall: "setRows(await api.list());" },
+    dashboard: { statsCall: "setStats(await api.stats());" }
+  };
+});
+
+// src/lib/menu/add.ts
+function addMenu(opts) {
+  const name = assertId("menu name", normalizeCamel2(opts.name));
+  const Pascal = name.charAt(0).toUpperCase() + name.slice(1);
+  const title = opts.title ?? Pascal;
+  const cfg = readConfig(opts.projectRoot);
+  const icon = opts.icon ?? cfg.defaultIcon ?? "symbol-misc";
+  const menuTs = path6.join(opts.projectRoot, "src", "menus", `${name}.ts`);
+  assertNoOverwrite(opts.projectRoot, menuTs, "Menu");
+  const tplPath = path6.join(opts.templatesRoot, "_generators", "menu", "menu.ts.tpl");
+  const body = substitute(fs6.readFileSync(tplPath, "utf8"), { name, Name: Pascal, title, icon });
+  fs6.mkdirSync(path6.dirname(menuTs), { recursive: true });
+  fs6.writeFileSync(menuTs, body);
+  const created = [menuTs];
+  let genRan = false;
+  if (opts.runGen !== false)
+    genRan = runGen2(opts.projectRoot);
+  return { created, genRan };
+}
+function runGen2(cwd) {
+  const tryRun = (cmd, args) => {
+    const r = import_child_process2.spawnSync(cmd, args, { cwd, stdio: "inherit" });
+    return r.status === 0;
+  };
+  if (which2("bun") && tryRun("bun", ["run", "gen"]))
+    return true;
+  if (which2("npm") && tryRun("npm", ["run", "gen"]))
+    return true;
+  console.warn('\n! Could not run "gen" automatically. Run `bun run gen` manually.\n');
+  return false;
+}
+function which2(cmd) {
+  const r = import_child_process2.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" });
+  return r.status === 0;
+}
+function normalizeCamel2(s) {
+  const cleaned = s.trim().replace(/[^a-zA-Z0-9]+(.)/g, (_m, c) => c.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "");
+  if (!cleaned)
+    return "";
+  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+}
+var fs6, path6, import_child_process2;
+var init_add3 = __esm(() => {
+  init_scaffold();
+  init_validate();
+  init_config();
+  fs6 = __toESM(require("fs"));
+  path6 = __toESM(require("path"));
+  import_child_process2 = require("child_process");
+});
+
+// src/lib/menu/edit.ts
+function listMenus(projectRoot) {
+  const dir = path7.join(projectRoot, "src", "menus");
+  if (!fs7.existsSync(dir))
+    return [];
+  return fs7.readdirSync(dir).filter((f) => f.endsWith(".ts")).map((f) => f.replace(/\.ts$/, "")).sort();
+}
+function listPanels(projectRoot) {
+  const dir = path7.join(projectRoot, "src", "panels");
+  if (!fs7.existsSync(dir))
+    return [];
+  return fs7.readdirSync(dir).filter((f) => f.endsWith(".ts")).map((f) => f.replace(/\.ts$/, "")).sort();
+}
+function listCommands(projectRoot) {
+  const dir = path7.join(projectRoot, "src", "commands");
+  if (!fs7.existsSync(dir))
+    return [];
+  return fs7.readdirSync(dir).filter((f) => f.endsWith(".ts")).map((f) => f.replace(/\.ts$/, "")).sort();
+}
+function listGroups(src) {
+  const root = findArrayContents(src, findItemsArrayStart(src));
+  if (!root)
+    return [];
+  const inner = src.slice(root.openIdx + 1, root.closeIdx);
+  const groups = [];
+  const re = /\blabel\s*:\s*(['"`])([^'"`]+)\1[^{}]*?\bchildren\s*:\s*\[/g;
+  let m;
+  while ((m = re.exec(inner)) !== null) {
+    groups.push(m[2]);
+  }
+  return groups;
+}
+function editMenu(opts) {
+  const file = path7.join(opts.projectRoot, "src", "menus", `${opts.menuName}.ts`);
+  if (!fs7.existsSync(file)) {
+    throw new Error(`Menu not found: ${path7.relative(opts.projectRoot, file)}`);
+  }
+  const src = fs7.readFileSync(file, "utf8");
+  const updated = insertItem(src, opts.item);
+  fs7.writeFileSync(file, updated.source);
+  const genRan = opts.runGen === false ? false : runGen3(opts.projectRoot);
+  return { file, inserted: updated.inserted, genRan };
+}
+function runGen3(cwd) {
+  const tryRun = (cmd, args) => {
+    const r = import_child_process3.spawnSync(cmd, args, { cwd, stdio: "inherit" });
+    return r.status === 0;
+  };
+  if (which3("bun") && tryRun("bun", ["run", "gen"]))
+    return true;
+  if (which3("npm") && tryRun("npm", ["run", "gen"]))
+    return true;
+  console.warn('\n! Could not run "gen" automatically. Run `bun run gen` manually.\n');
+  return false;
+}
+function which3(cmd) {
+  const r = import_child_process3.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" });
+  return r.status === 0;
+}
+function insertItem(src, item) {
+  const target = item.parentLabel ? findGroupChildrenArray(src, item.parentLabel) : findArrayContents(src, findItemsArrayStart(src));
+  if (!target) {
+    throw new Error(item.parentLabel ? `Group "${item.parentLabel}" not found in menu` : "Could not locate items: [...] array in menu file");
+  }
+  const indent = detectArrayItemIndent(src, target);
+  const rendered = renderItem(item, indent);
+  const before = src.slice(0, target.closeIdx);
+  const after = src.slice(target.closeIdx);
+  const trimmedBefore = before.replace(/[ \t]*$/, "");
+  const insertion = (trimmedBefore.endsWith(`
+`) ? "" : `
+`) + rendered + `
+` + " ".repeat(closeIndent(src, target.closeIdx));
+  return { source: trimmedBefore + insertion + after, inserted: rendered };
+}
+function renderItem(item, indent) {
+  const parts = [];
+  parts.push(`${indent}{`);
+  parts.push(`${indent}  label: ${quote(item.label)},`);
+  if (item.icon)
+    parts.push(`${indent}  icon: ${quote(item.icon)},`);
+  if (item.description)
+    parts.push(`${indent}  description: ${quote(item.description)},`);
+  switch (item.kind) {
+    case "panel":
+      if (!item.target)
+        throw new Error("panel kind requires target");
+      parts.push(`${indent}  panel: ${quote(item.target)},`);
+      break;
+    case "command":
+      if (!item.target)
+        throw new Error("command kind requires target");
+      parts.push(`${indent}  command: ${quote(item.target)},`);
+      break;
+    case "url":
+      if (!item.target)
+        throw new Error("url kind requires target");
+      parts.push(`${indent}  url: ${quote(item.target)},`);
+      break;
+    case "group":
+      parts.push(`${indent}  children: [],`);
+      break;
+  }
+  parts.push(`${indent}},`);
+  return parts.join(`
+`);
+}
+function quote(s) {
+  return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function detectArrayItemIndent(src, arr) {
+  const inner = src.slice(arr.openIdx + 1, arr.closeIdx);
+  const m = inner.match(/\n([ \t]+)\{/);
+  if (m)
+    return m[1];
+  return " ".repeat(closeIndent(src, arr.closeIdx) + 2);
+}
+function closeIndent(src, closeIdx) {
+  let i = closeIdx - 1;
+  while (i >= 0 && src[i] !== `
+`)
+    i--;
+  let n = 0;
+  let j = i + 1;
+  while (j < closeIdx && (src[j] === " " || src[j] === "\t")) {
+    n++;
+    j++;
+  }
+  return n;
+}
+function findItemsArrayStart(src) {
+  const re = /\bitems\s*:\s*\[/g;
+  const m = re.exec(src);
+  if (!m)
+    throw new Error("Menu file missing items: [...] array");
+  return m.index + m[0].length - 1;
+}
+function findArrayContents(src, openIdx) {
+  if (src[openIdx] !== "[")
+    return null;
+  const closeIdx = findMatching(src, openIdx);
+  if (closeIdx < 0)
+    return null;
+  return { openIdx, closeIdx };
+}
+function findGroupChildrenArray(src, label) {
+  const root = findArrayContents(src, findItemsArrayStart(src));
+  if (!root)
+    return null;
+  let i = root.openIdx + 1;
+  while (i < root.closeIdx) {
+    const ch = src[i];
+    if (ch === "{") {
+      const objEnd = findMatching(src, i);
+      if (objEnd < 0)
+        break;
+      const obj = src.slice(i, objEnd + 1);
+      const labelMatch = obj.match(/\blabel\s*:\s*(['"`])([^'"`]+)\1/);
+      if (labelMatch && labelMatch[2] === label) {
+        const childRe = /\bchildren\s*:\s*\[/;
+        const cm = childRe.exec(obj);
+        if (!cm)
+          return null;
+        const openInObj = cm.index + cm[0].length - 1;
+        const openIdx = i + openInObj;
+        const closeIdx = findMatching(src, openIdx);
+        if (closeIdx < 0)
+          return null;
+        return { openIdx, closeIdx };
+      }
+      i = objEnd + 1;
+    } else {
+      i++;
+    }
+  }
+  return null;
+}
+function findMatching(src, openIdx) {
+  const open = src[openIdx];
+  const close = open === "[" ? "]" : open === "{" ? "}" : open === "(" ? ")" : "";
+  if (!close)
+    return -1;
+  let depth = 0;
+  let i = openIdx;
+  const n = src.length;
+  while (i < n) {
+    const ch = src[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote2 = ch;
+      i++;
+      while (i < n && src[i] !== quote2) {
+        if (src[i] === "\\")
+          i += 2;
+        else if (quote2 === "`" && src[i] === "$" && src[i + 1] === "{") {
+          const end = findMatching(src, i + 1);
+          if (end < 0)
+            return -1;
+          i = end + 1;
+        } else
+          i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "/") {
+      while (i < n && src[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(src[i] === "*" && src[i + 1] === "/"))
+        i++;
+      i += 2;
+      continue;
+    }
+    if (ch === open)
+      depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+    i++;
+  }
+  return -1;
+}
+var fs7, path7, import_child_process3;
+var init_edit = __esm(() => {
+  fs7 = __toESM(require("fs"));
+  path7 = __toESM(require("path"));
+  import_child_process3 = require("child_process");
+});
+
+// src/lib/command/add.ts
+function addCommand(opts) {
+  const name = assertId("command name", normalizeCamel3(opts.name));
+  const Pascal = name.charAt(0).toUpperCase() + name.slice(1);
+  const title = (opts.title ?? Pascal).trim() || Pascal;
+  const file = path8.join(opts.projectRoot, "src", "commands", `${name}.ts`);
+  assertNoOverwrite(opts.projectRoot, file, "Command");
+  if (opts.menuEntry)
+    assertSiblingExists(opts.projectRoot, "menu", opts.menuEntry);
+  const tplPath = path8.join(opts.templatesRoot, "_generators", "command", "command.ts.tpl");
+  if (!fs8.existsSync(tplPath))
+    throw new Error(`Template missing: ${tplPath}`);
+  const cfg = readConfig(opts.projectRoot);
+  const category = opts.category ?? cfg.defaultCategory;
+  const vars = {
+    name,
+    Name: Pascal,
+    title,
+    categoryLine: category ? `
+  category: '${escapeQuotes(category)}',` : "",
+    keybindingLine: opts.keybinding ? `
+  keybinding: '${escapeQuotes(opts.keybinding)}',` : "",
+    whenLine: opts.when ? `
+  when: '${escapeQuotes(opts.when)}',` : ""
+  };
+  fs8.mkdirSync(path8.dirname(file), { recursive: true });
+  fs8.writeFileSync(file, substitute(fs8.readFileSync(tplPath, "utf8"), vars));
+  const created = [file];
+  const modified = [];
+  let menuUpdated = false;
+  if (opts.menuEntry) {
+    const result = editMenu({
+      projectRoot: opts.projectRoot,
+      menuName: opts.menuEntry,
+      runGen: false,
+      item: {
+        label: title,
+        kind: "command",
+        target: name,
+        icon: opts.icon || undefined,
+        parentLabel: opts.group || undefined
+      }
+    });
+    modified.push(result.file);
+    menuUpdated = true;
+  }
+  let genRan = false;
+  if (opts.runGen !== false)
+    genRan = runGen4(opts.projectRoot);
+  return { created, modified, menuUpdated, genRan };
+}
+function runGen4(cwd) {
+  const tryRun = (cmd, args) => {
+    const r = import_child_process4.spawnSync(cmd, args, { cwd, stdio: "inherit" });
+    return r.status === 0;
+  };
+  if (which4("bun") && tryRun("bun", ["run", "gen"]))
+    return true;
+  if (which4("npm") && tryRun("npm", ["run", "gen"]))
+    return true;
+  console.warn('\n! Could not run "gen" automatically. Run `bun run gen` manually.\n');
+  return false;
+}
+function which4(cmd) {
+  const r = import_child_process4.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" });
+  return r.status === 0;
+}
+function escapeQuotes(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function normalizeCamel3(s) {
+  const cleaned = s.trim().replace(/[^a-zA-Z0-9]+(.)/g, (_m, c) => c.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "");
+  if (!cleaned)
+    return "";
+  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+}
+var fs8, path8, import_child_process4;
+var init_add4 = __esm(() => {
+  init_scaffold();
+  init_edit();
+  init_validate();
+  init_config();
+  fs8 = __toESM(require("fs"));
+  path8 = __toESM(require("path"));
+  import_child_process4 = require("child_process");
+});
+
+// src/lib/rpc/add.ts
+function addRpcMethod(opts) {
+  const panelId = assertId("panel id", opts.panel.trim());
+  const method = assertId("method name", opts.method.trim());
+  assertSiblingExists(opts.projectRoot, "panel", panelId);
+  const panelFile = path9.join(opts.projectRoot, "src", "panels", `${panelId}.ts`);
+  const apiFile = path9.join(opts.projectRoot, "src", "shared", "api.ts");
+  if (!fs9.existsSync(apiFile)) {
+    throw new Error(`RPC contract file missing at \`src/shared/api.ts\`. Create it (an empty file is fine) and retry.`);
+  }
+  const Pascal = panelId.charAt(0).toUpperCase() + panelId.slice(1);
+  const apiName = `${Pascal}Api`;
+  const paramSig = (opts.paramSig ?? "").trim();
+  const rawReturn = (opts.returns ?? "void").trim() || "void";
+  const returnType = /^Promise<.+>$/.test(rawReturn) ? rawReturn : `Promise<${rawReturn}>`;
+  let apiSrc = fs9.readFileSync(apiFile, "utf8");
+  const ifaceRange = findInterfaceRange(apiSrc, apiName);
+  let interfaceCreated = false;
+  if (ifaceRange) {
+    const body = apiSrc.slice(ifaceRange.bodyStart, ifaceRange.bodyEnd);
+    if (methodAlreadyDeclared(body, method)) {
+      throw new Error(`Method "${method}" already declared in ${apiName}`);
+    }
+    const trimmedBody = body.replace(/\s+$/, "");
+    const newBody = `${trimmedBody}
+  ${method}(${paramSig}): ${returnType};
+`;
+    apiSrc = apiSrc.slice(0, ifaceRange.bodyStart) + newBody + apiSrc.slice(ifaceRange.bodyEnd);
+  } else {
+    interfaceCreated = true;
+    const block = `
+export interface ${apiName} {
+  ${method}(${paramSig}): ${returnType};
+}
+`;
+    apiSrc = apiSrc.replace(/\s*$/, "") + `
+` + block;
+  }
+  fs9.writeFileSync(apiFile, apiSrc);
+  let panelSrc = fs9.readFileSync(panelFile, "utf8");
+  const argNames = parseArgNames(paramSig);
+  const handlerBody = `    async ${method}(${argNames.join(", ")}) {
+` + `      // TODO: implement
+` + `      throw new Error('Not implemented');
+` + `    },`;
+  if (!new RegExp(`\\b${apiName}\\b`).test(panelSrc)) {
+    panelSrc = ensureApiImport(panelSrc, apiName);
+    panelSrc = ensurePanelGeneric(panelSrc, apiName);
+  }
+  let rpcBlockCreated = false;
+  const rpcRange = findRpcBodyRange(panelSrc);
+  if (rpcRange) {
+    const inner = panelSrc.slice(rpcRange.start, rpcRange.end).replace(/\s+$/, "");
+    const newInner = `${inner}
+${handlerBody}
+  `;
+    panelSrc = panelSrc.slice(0, rpcRange.start) + newInner + panelSrc.slice(rpcRange.end);
+  } else {
+    rpcBlockCreated = true;
+    panelSrc = insertRpcBlock(panelSrc, handlerBody);
+  }
+  fs9.writeFileSync(panelFile, panelSrc);
+  const webviewSnippet = buildSnippet(method, argNames);
+  let genRan = false;
+  if (opts.runGen === true)
+    genRan = runGen5(opts.projectRoot);
+  return { apiFile, panelFile, interfaceCreated, rpcBlockCreated, webviewSnippet, genRan };
+}
+function findInterfaceRange(src, name) {
+  const re = new RegExp(`export\\s+interface\\s+${escapeRe(name)}\\b[^{]*\\{`, "m");
+  const m = re.exec(src);
+  if (!m)
+    return null;
+  const bodyStart = m.index + m[0].length;
+  const bodyEnd = findMatchingBrace(src, bodyStart);
+  if (bodyEnd === -1)
+    return null;
+  return { bodyStart, bodyEnd };
+}
+function findRpcBodyRange(src) {
+  const re = /\brpc\s*:\s*\([^)]*\)\s*=>\s*\(\s*\{/m;
+  const m = re.exec(src);
+  if (!m)
+    return null;
+  const start = m.index + m[0].length;
+  const end = findMatchingBrace(src, start);
+  if (end === -1)
+    return null;
+  return { start, end };
+}
+function findMatchingBrace(src, start) {
+  let depth = 1;
+  for (let i = start;i < src.length; i++) {
+    const c = src[i];
+    if (c === "{")
+      depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  }
+  return -1;
+}
+function methodAlreadyDeclared(interfaceBody, method) {
+  return new RegExp(`\\b${escapeRe(method)}\\s*\\(`).test(interfaceBody);
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseArgNames(sig) {
+  if (!sig)
+    return [];
+  return sig.split(",").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const name = part.split(":")[0].trim();
+    return name.replace(/\?$/, "").replace(/^\.\.\./, "");
+  }).filter(Boolean);
+}
+function ensureApiImport(src, apiName) {
+  if (new RegExp(`from\\s+['"]\\.\\./shared/api['"]`).test(src)) {
+    return src.replace(/import\s+type\s+\{([^}]*)\}\s+from\s+['"]\.\.\/shared\/api['"];/, (_m, group) => {
+      const names = new Set(group.split(",").map((n) => n.trim()).filter(Boolean));
+      names.add(apiName);
+      return `import type { ${[...names].join(", ")} } from '../shared/api';`;
+    });
+  }
+  const importLine = `import type { ${apiName} } from '../shared/api';
+`;
+  const lastImport = src.match(/^(import[^\n]*\n)+/m);
+  if (lastImport) {
+    const end = lastImport.index + lastImport[0].length;
+    return src.slice(0, end) + importLine + src.slice(end);
+  }
+  return importLine + src;
+}
+function ensurePanelGeneric(src, apiName) {
+  return src.replace(/definePanel\s*(<[^>]+>)?\s*\(/, (_m, generic) => {
+    return generic ? `definePanel${generic}(` : `definePanel<${apiName}>(`;
+  });
+}
+function insertRpcBlock(src, handlerBody) {
+  const block = `
+  rpc: (vscode) => ({
+${handlerBody}
+  }),`;
+  if (/title\s*:\s*['"][^'"]*['"]\s*,/.test(src)) {
+    return src.replace(/(title\s*:\s*['"][^'"]*['"]\s*,)/, `$1${block}`);
+  }
+  return src.replace(/\}\s*\)\s*;?\s*$/, `${block}
+});
+`);
+}
+function buildSnippet(method, argNames) {
+  const args = argNames.length ? argNames.join(", ") : "";
+  return `const result = await api.${method}(${args});`;
+}
+function runGen5(cwd) {
+  const tryRun = (cmd, args) => {
+    const r = import_child_process5.spawnSync(cmd, args, { cwd, stdio: "inherit" });
+    return r.status === 0;
+  };
+  if (which5("bun") && tryRun("bun", ["run", "gen"]))
+    return true;
+  if (which5("npm") && tryRun("npm", ["run", "gen"]))
+    return true;
+  return false;
+}
+function which5(cmd) {
+  const r = import_child_process5.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" });
+  return r.status === 0;
+}
+var fs9, path9, import_child_process5;
+var init_add5 = __esm(() => {
+  init_validate();
+  fs9 = __toESM(require("fs"));
+  path9 = __toESM(require("path"));
+  import_child_process5 = require("child_process");
+});
+
+// src/lib/statusBar/add.ts
+function addStatusBar(opts) {
+  const name = assertId("status bar name", normalizeCamel4(opts.name));
+  const file = path10.join(opts.projectRoot, "src", "statusBars", `${name}.ts`);
+  assertNoOverwrite(opts.projectRoot, file, "Status bar");
+  const tplPath = path10.join(opts.templatesRoot, "_generators", "statusBar", "statusBar.ts.tpl");
+  if (!fs10.existsSync(tplPath))
+    throw new Error(`Template missing: ${tplPath}`);
+  let commandId = opts.command;
+  let commandCreated;
+  if (opts.newCommandTitle) {
+    const cmdId = `${name}Action`;
+    addCommand({
+      name: cmdId,
+      title: opts.newCommandTitle,
+      projectRoot: opts.projectRoot,
+      templatesRoot: opts.templatesRoot,
+      runGen: false
+    });
+    commandId = cmdId;
+    commandCreated = cmdId;
+  }
+  const text = opts.text ?? "";
+  const alignment = opts.alignment ?? "left";
+  const priority = String(opts.priority ?? 100);
+  const vars = {
+    name,
+    text: escapeSingleQuotes(text),
+    alignment,
+    priority,
+    iconLine: opts.icon ? `
+  icon: '${escapeSingleQuotes(opts.icon)}',` : "",
+    tooltipLine: opts.tooltipMarkdown ? `
+  tooltipMarkdown: ${asBacktickString(opts.tooltipMarkdown)},` : opts.tooltip ? `
+  tooltip: '${escapeSingleQuotes(opts.tooltip)}',` : "",
+    commandLine: !opts.panel && !opts.menu && commandId ? `
+  command: '${escapeSingleQuotes(commandId)}',` : "",
+    panelLine: opts.panel && !opts.menu ? `
+  panel: '${escapeSingleQuotes(opts.panel)}',` : ""
+  };
+  if (opts.menu && opts.menu.length > 0) {
+    const itemLines = opts.menu.map((it) => {
+      const fields = [`label: '${escapeSingleQuotes(it.label)}'`];
+      if (it.description)
+        fields.push(`description: '${escapeSingleQuotes(it.description)}'`);
+      if (it.detail)
+        fields.push(`detail: '${escapeSingleQuotes(it.detail)}'`);
+      if (it.command)
+        fields.push(`command: '${escapeSingleQuotes(it.command)}'`);
+      if (it.panel)
+        fields.push(`panel: '${escapeSingleQuotes(it.panel)}'`);
+      if (it.url)
+        fields.push(`url: '${escapeSingleQuotes(it.url)}'`);
+      return `    { ${fields.join(", ")} },`;
+    }).join(`
+`);
+    vars.panelLine += `
+  menu: [
+${itemLines}
+  ],`;
+  }
+  fs10.mkdirSync(path10.dirname(file), { recursive: true });
+  fs10.writeFileSync(file, substitute(fs10.readFileSync(tplPath, "utf8"), vars));
+  let genRan = false;
+  if (opts.runGen !== false)
+    genRan = runGen6(opts.projectRoot);
+  return { created: [file], commandCreated, genRan };
+}
+function escapeSingleQuotes(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function asBacktickString(s) {
+  return "`" + s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${") + "`";
+}
+function runGen6(cwd) {
+  const tryRun = (cmd, args) => {
+    const r = import_child_process6.spawnSync(cmd, args, { cwd, stdio: "inherit" });
+    return r.status === 0;
+  };
+  if (which6("bun") && tryRun("bun", ["run", "gen"]))
+    return true;
+  if (which6("npm") && tryRun("npm", ["run", "gen"]))
+    return true;
+  return false;
+}
+function which6(cmd) {
+  const r = import_child_process6.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" });
+  return r.status === 0;
+}
+function normalizeCamel4(s) {
+  const cleaned = s.trim().replace(/[^a-zA-Z0-9]+(.)/g, (_m, c) => c.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "");
+  if (!cleaned)
+    return "";
+  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+}
+var fs10, path10, import_child_process6;
+var init_add6 = __esm(() => {
+  init_scaffold();
+  init_add4();
+  init_validate();
+  fs10 = __toESM(require("fs"));
+  path10 = __toESM(require("path"));
+  import_child_process6 = require("child_process");
+});
+
+// src/lib/subpanel/add.ts
+function addSubpanel(opts) {
+  const name = assertId("subpanel name", normalizeCamel5(opts.name));
+  const menu = assertId("menu id", normalizeCamel5(opts.menu ?? ""));
+  assertSiblingExists(opts.projectRoot, "menu", menu);
+  const Pascal = name.charAt(0).toUpperCase() + name.slice(1);
+  const title = opts.title ?? Pascal;
+  const withApi = opts.withApi !== false;
+  const apiName = `${Pascal}ViewApi`;
+  const viewTs = path11.join(opts.projectRoot, "src", "subpanels", `${name}.ts`);
+  const uiDir = path11.join(opts.projectRoot, "src", "webview", "subpanels", name);
+  const appTsx = path11.join(uiDir, "App.tsx");
+  const mainTsx = path11.join(uiDir, "main.tsx");
+  const apiPath = path11.join(opts.projectRoot, "src", "shared", "api.ts");
+  assertNoOverwrite(opts.projectRoot, viewTs, "Subpanel");
+  assertNoOverwrite(opts.projectRoot, uiDir, "Webview dir");
+  const genDir = path11.join(opts.templatesRoot, "_generators", "subpanel");
+  const readTpl = (n) => fs11.readFileSync(path11.join(genDir, n), "utf8");
+  const vars = {
+    name,
+    Name: Pascal,
+    title,
+    menu,
+    apiImport: withApi ? `import type { ${apiName} } from '../shared/api';
+` : "",
+    apiGeneric: withApi ? `<${apiName}>` : "",
+    rpcBlock: withApi ? `
+  rpc: (vscode) => ({
+    // add RPC handlers here
+  }),` : "",
+    apiBlock: withApi ? `import { connectWebview } from '../../../shared/vsceasy/client';
+import type { ${apiName} } from '../../../shared/api';
+
+const api = connectWebview<${apiName}>();
+void api;
+` : ""
+  };
+  const created = [];
+  const modified = [];
+  const skipped = [];
+  fs11.mkdirSync(path11.dirname(viewTs), { recursive: true });
+  fs11.writeFileSync(viewTs, substitute(readTpl("subpanel.ts.tpl"), vars));
+  created.push(viewTs);
+  fs11.mkdirSync(uiDir, { recursive: true });
+  fs11.writeFileSync(appTsx, substitute(readTpl("App.tsx.tpl"), vars));
+  created.push(appTsx);
+  fs11.writeFileSync(mainTsx, substitute(readTpl("main.tsx.tpl"), vars));
+  created.push(mainTsx);
+  if (withApi) {
+    appendApi2(apiPath, apiName, created, modified, skipped);
+  }
+  let genRan = false;
+  if (opts.runGen !== false)
+    genRan = runGen7(opts.projectRoot);
+  return { created, modified, skipped, genRan };
+}
+function appendApi2(apiPath, apiName, created, modified, skipped) {
+  if (!fs11.existsSync(apiPath)) {
+    fs11.mkdirSync(path11.dirname(apiPath), { recursive: true });
+    fs11.writeFileSync(apiPath, `export interface ${apiName} {}
+`);
+    created.push(apiPath);
+    return;
+  }
+  const current = fs11.readFileSync(apiPath, "utf8");
+  const re = new RegExp(`\\bexport\\s+interface\\s+${apiName}\\b`);
+  if (re.test(current)) {
+    skipped.push(`${apiPath} (interface ${apiName} already declared)`);
+    return;
+  }
+  const sep = current.endsWith(`
+`) ? `
+` : `
+
+`;
+  fs11.writeFileSync(apiPath, current + `${sep}export interface ${apiName} {}
+`);
+  modified.push(apiPath);
+}
+function runGen7(cwd) {
+  const tryRun = (cmd, args) => {
+    const r = import_child_process7.spawnSync(cmd, args, { cwd, stdio: "inherit" });
+    return r.status === 0;
+  };
+  if (which7("bun") && tryRun("bun", ["run", "gen"]))
+    return true;
+  if (which7("npm") && tryRun("npm", ["run", "gen"]))
+    return true;
+  console.warn('\n! Could not run "gen" automatically. Run `bun run gen` manually.\n');
+  return false;
+}
+function which7(cmd) {
+  const r = import_child_process7.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" });
+  return r.status === 0;
+}
+function normalizeCamel5(s) {
+  const cleaned = s.trim().replace(/[^a-zA-Z0-9]+(.)/g, (_m, c) => c.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "");
+  if (!cleaned)
+    return "";
+  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+}
+var fs11, path11, import_child_process7;
+var init_add7 = __esm(() => {
+  init_scaffold();
+  init_validate();
+  fs11 = __toESM(require("fs"));
+  path11 = __toESM(require("path"));
+  import_child_process7 = require("child_process");
+});
+
+// src/lib/menuTree.ts
+function parseMenu(src) {
+  const title = matchString(src, /\btitle\s*:\s*(['"`])([^'"`]+)\1/);
+  const icon = matchString(src, /\bicon\s*:\s*(['"`])([^'"`]+)\1/);
+  const items = parseItemsArray(src);
+  return { title, icon, items };
+}
+function parseItemsArray(src) {
+  const start = findItemsStart(src);
+  if (start < 0)
+    return [];
+  const end = findMatching2(src, start);
+  if (end < 0)
+    return [];
+  return parseArrayItems(src.slice(start + 1, end));
+}
+function parseArrayItems(inner) {
+  const out = [];
+  let i = 0;
+  while (i < inner.length) {
+    skipTrivia(inner, { idx: i });
+    while (i < inner.length && /[\s,]/.test(inner[i]))
+      i++;
+    if (i >= inner.length)
+      break;
+    if (inner[i] === "/" && (inner[i + 1] === "/" || inner[i + 1] === "*")) {
+      i = skipComment(inner, i);
+      continue;
+    }
+    if (inner[i] !== "{") {
+      i++;
+      continue;
+    }
+    const end = findMatching2(inner, i);
+    if (end < 0)
+      break;
+    const obj = inner.slice(i, end + 1);
+    out.push(parseObject(obj));
+    i = end + 1;
+  }
+  return out;
+}
+function parseObject(obj) {
+  const label = matchString(obj, /\blabel\s*:\s*(['"`])([^'"`]+)\1/) ?? "(unnamed)";
+  const icon = matchString(obj, /\bicon\s*:\s*(['"`])([^'"`]+)\1/);
+  const panel = matchString(obj, /\bpanel\s*:\s*(['"`])([^'"`]+)\1/);
+  const command = matchString(obj, /\bcommand\s*:\s*(['"`])([^'"`]+)\1/);
+  const url = matchString(obj, /\burl\s*:\s*(['"`])([^'"`]+)\1/);
+  const childrenIdx = obj.search(/\bchildren\s*:\s*\[/);
+  let children;
+  if (childrenIdx >= 0) {
+    const arrOpen = obj.indexOf("[", childrenIdx);
+    if (arrOpen >= 0) {
+      const arrClose = findMatching2(obj, arrOpen);
+      if (arrClose >= 0) {
+        children = parseArrayItems(obj.slice(arrOpen + 1, arrClose));
+      }
+    }
+  }
+  let kind = "item";
+  let target;
+  if (children !== undefined) {
+    kind = "group";
+  } else if (panel) {
+    kind = "panel";
+    target = panel;
+  } else if (command) {
+    kind = "command";
+    target = command;
+  } else if (url) {
+    kind = "url";
+    target = url;
+  }
+  return { label, kind, target, icon, children };
+}
+function matchString(s, re) {
+  const m = s.match(re);
+  return m?.[2];
+}
+function findItemsStart(src) {
+  const re = /\bitems\s*:\s*\[/g;
+  const m = re.exec(src);
+  if (!m)
+    return -1;
+  return m.index + m[0].length - 1;
+}
+function findMatching2(src, openIdx) {
+  const open = src[openIdx];
+  const close = open === "[" ? "]" : open === "{" ? "}" : open === "(" ? ")" : "";
+  if (!close)
+    return -1;
+  let depth = 0;
+  let i = openIdx;
+  const n = src.length;
+  while (i < n) {
+    const ch = src[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const q = ch;
+      i++;
+      while (i < n && src[i] !== q) {
+        if (src[i] === "\\")
+          i += 2;
+        else
+          i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "/") {
+      while (i < n && src[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(src[i] === "*" && src[i + 1] === "/"))
+        i++;
+      i += 2;
+      continue;
+    }
+    if (ch === open)
+      depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+    i++;
+  }
+  return -1;
+}
+function skipTrivia(_s, _ref) {}
+function skipComment(s, i) {
+  if (s[i + 1] === "/") {
+    while (i < s.length && s[i] !== `
+`)
+      i++;
+    return i;
+  }
+  if (s[i + 1] === "*") {
+    i += 2;
+    while (i < s.length && !(s[i] === "*" && s[i + 1] === "/"))
+      i++;
+    return i + 2;
+  }
+  return i + 1;
+}
+var ESC = "\x1B", DIM, BOLD, CYAN, GREEN, YELLOW, MAGENTA, RST, KIND_BADGE;
+var init_menuTree = __esm(() => {
+  DIM = `${ESC}[2m`;
+  BOLD = `${ESC}[1m`;
+  CYAN = `${ESC}[36m`;
+  GREEN = `${ESC}[32m`;
+  YELLOW = `${ESC}[33m`;
+  MAGENTA = `${ESC}[35m`;
+  RST = `${ESC}[0m`;
+  KIND_BADGE = {
+    panel: `${MAGENTA}■${RST}`,
+    command: `${GREEN}▶${RST}`,
+    url: `${CYAN}↗${RST}`,
+    group: `${YELLOW}▾${RST}`,
+    item: `${DIM}·${RST}`
+  };
+});
+
+// src/data/codicons.ts
+function isKnownCodicon(name) {
+  return CODICONS.some((c) => c.name === name);
+}
+var CODICONS;
+var init_codicons = __esm(() => {
+  CODICONS = [
+    { name: "play", category: "actions" },
+    { name: "play-circle", category: "actions" },
+    { name: "debug-start", category: "actions" },
+    { name: "debug-stop", category: "actions" },
+    { name: "debug-restart", category: "actions" },
+    { name: "debug-pause", category: "actions" },
+    { name: "stop", category: "actions" },
+    { name: "stop-circle", category: "actions" },
+    { name: "refresh", category: "actions" },
+    { name: "sync", category: "actions" },
+    { name: "add", category: "actions" },
+    { name: "remove", category: "actions" },
+    { name: "trash", category: "actions" },
+    { name: "edit", category: "actions" },
+    { name: "save", category: "actions" },
+    { name: "save-all", category: "actions" },
+    { name: "cloud-upload", category: "actions" },
+    { name: "cloud-download", category: "actions" },
+    { name: "export", category: "actions" },
+    { name: "desktop-download", category: "actions" },
+    { name: "search", category: "actions" },
+    { name: "filter", category: "actions" },
+    { name: "replace", category: "actions" },
+    { name: "check", category: "actions" },
+    { name: "close", category: "actions" },
+    { name: "eye", category: "actions" },
+    { name: "eye-closed", category: "actions" },
+    { name: "lock", category: "actions" },
+    { name: "unlock", category: "actions" },
+    { name: "key", category: "actions" },
+    { name: "symbol-class", category: "symbols" },
+    { name: "symbol-method", category: "symbols" },
+    { name: "symbol-function", category: "symbols" },
+    { name: "symbol-variable", category: "symbols" },
+    { name: "symbol-constant", category: "symbols" },
+    { name: "symbol-property", category: "symbols" },
+    { name: "symbol-field", category: "symbols" },
+    { name: "symbol-event", category: "symbols" },
+    { name: "symbol-interface", category: "symbols" },
+    { name: "symbol-enum", category: "symbols" },
+    { name: "symbol-module", category: "symbols" },
+    { name: "symbol-namespace", category: "symbols" },
+    { name: "symbol-array", category: "symbols" },
+    { name: "symbol-boolean", category: "symbols" },
+    { name: "symbol-numeric", category: "symbols" },
+    { name: "symbol-string", category: "symbols" },
+    { name: "symbol-misc", category: "symbols" },
+    { name: "symbol-color", category: "symbols" },
+    { name: "symbol-key", category: "symbols" },
+    { name: "symbol-parameter", category: "symbols" },
+    { name: "symbol-snippet", category: "symbols" },
+    { name: "file", category: "files" },
+    { name: "file-code", category: "files" },
+    { name: "file-text", category: "files" },
+    { name: "file-media", category: "files" },
+    { name: "file-pdf", category: "files" },
+    { name: "file-zip", category: "files" },
+    { name: "file-binary", category: "files" },
+    { name: "file-symlink-file", category: "files" },
+    { name: "file-symlink-directory", category: "files" },
+    { name: "files", category: "files" },
+    { name: "folder", category: "files" },
+    { name: "folder-opened", category: "files" },
+    { name: "folder-active", category: "files" },
+    { name: "folder-library", category: "files" },
+    { name: "new-file", category: "files" },
+    { name: "new-folder", category: "files" },
+    { name: "archive", category: "files" },
+    { name: "home", category: "ui" },
+    { name: "dashboard", category: "ui" },
+    { name: "gear", category: "ui" },
+    { name: "settings", category: "ui" },
+    { name: "settings-gear", category: "ui" },
+    { name: "preferences", category: "ui" },
+    { name: "list-flat", category: "ui" },
+    { name: "list-tree", category: "ui" },
+    { name: "list-unordered", category: "ui" },
+    { name: "list-ordered", category: "ui" },
+    { name: "list-selection", category: "ui" },
+    { name: "layout", category: "ui" },
+    { name: "layout-sidebar-left", category: "ui" },
+    { name: "layout-sidebar-right", category: "ui" },
+    { name: "layout-panel", category: "ui" },
+    { name: "split-horizontal", category: "ui" },
+    { name: "split-vertical", category: "ui" },
+    { name: "window", category: "ui" },
+    { name: "browser", category: "ui" },
+    { name: "preview", category: "ui" },
+    { name: "bell", category: "ui" },
+    { name: "bell-dot", category: "ui" },
+    { name: "info", category: "ui" },
+    { name: "warning", category: "ui" },
+    { name: "error", category: "ui" },
+    { name: "question", category: "ui" },
+    { name: "git-branch", category: "git" },
+    { name: "git-commit", category: "git" },
+    { name: "git-merge", category: "git" },
+    { name: "git-compare", category: "git" },
+    { name: "git-pull-request", category: "git" },
+    { name: "git-fork", category: "git" },
+    { name: "source-control", category: "git" },
+    { name: "github", category: "git" },
+    { name: "github-alt", category: "git" },
+    { name: "github-inverted", category: "git" },
+    { name: "repo", category: "git" },
+    { name: "repo-clone", category: "git" },
+    { name: "repo-forked", category: "git" },
+    { name: "repo-pull", category: "git" },
+    { name: "repo-push", category: "git" },
+    { name: "cloud", category: "git" },
+    { name: "bug", category: "debug" },
+    { name: "debug", category: "debug" },
+    { name: "debug-alt", category: "debug" },
+    { name: "debug-console", category: "debug" },
+    { name: "debug-breakpoint", category: "debug" },
+    { name: "debug-step-over", category: "debug" },
+    { name: "debug-step-into", category: "debug" },
+    { name: "debug-step-out", category: "debug" },
+    { name: "debug-continue", category: "debug" },
+    { name: "debug-disconnect", category: "debug" },
+    { name: "beaker", category: "debug" },
+    { name: "terminal", category: "terminal" },
+    { name: "terminal-bash", category: "terminal" },
+    { name: "terminal-cmd", category: "terminal" },
+    { name: "terminal-powershell", category: "terminal" },
+    { name: "terminal-linux", category: "terminal" },
+    { name: "console", category: "terminal" },
+    { name: "output", category: "terminal" },
+    { name: "server", category: "terminal" },
+    { name: "server-environment", category: "terminal" },
+    { name: "server-process", category: "terminal" },
+    { name: "code", category: "editor" },
+    { name: "json", category: "editor" },
+    { name: "markdown", category: "editor" },
+    { name: "note", category: "editor" },
+    { name: "notebook", category: "editor" },
+    { name: "pencil", category: "editor" },
+    { name: "comment", category: "editor" },
+    { name: "comment-discussion", category: "editor" },
+    { name: "tag", category: "editor" },
+    { name: "bookmark", category: "editor" },
+    { name: "pin", category: "editor" },
+    { name: "pinned", category: "editor" },
+    { name: "history", category: "editor" },
+    { name: "clock", category: "editor" },
+    { name: "watch", category: "editor" },
+    { name: "wand", category: "editor" },
+    { name: "sparkle", category: "editor" },
+    { name: "lightbulb", category: "editor" },
+    { name: "image", category: "media" },
+    { name: "video", category: "media" },
+    { name: "play-circle", category: "media" },
+    { name: "record", category: "media" },
+    { name: "mute", category: "media" },
+    { name: "unmute", category: "media" },
+    { name: "megaphone", category: "media" },
+    { name: "broadcast", category: "media" },
+    { name: "rocket", category: "misc" },
+    { name: "star", category: "misc" },
+    { name: "star-empty", category: "misc" },
+    { name: "star-full", category: "misc" },
+    { name: "heart", category: "misc" },
+    { name: "flame", category: "misc" },
+    { name: "zap", category: "misc" },
+    { name: "globe", category: "misc" },
+    { name: "book", category: "misc" },
+    { name: "mortar-board", category: "misc" },
+    { name: "tools", category: "misc" },
+    { name: "package", category: "misc" },
+    { name: "database", category: "misc" },
+    { name: "extensions", category: "misc" },
+    { name: "plug", category: "misc" },
+    { name: "link", category: "misc" },
+    { name: "link-external", category: "misc" },
+    { name: "mail", category: "misc" },
+    { name: "person", category: "misc" },
+    { name: "organization", category: "misc" },
+    { name: "account", category: "misc" },
+    { name: "shield", category: "misc" },
+    { name: "verified", category: "misc" },
+    { name: "graph", category: "misc" },
+    { name: "pulse", category: "misc" },
+    { name: "flag", category: "misc" },
+    { name: "inbox", category: "misc" },
+    { name: "calendar", category: "misc" },
+    { name: "location", category: "misc" },
+    { name: "compass", category: "misc" }
+  ];
+});
+
+// src/lib/doctor.ts
+function runDoctor(opts) {
+  const root = opts.projectRoot;
+  const pkg = readPkg(root);
+  const results = [];
+  results.push(checkEngine(pkg));
+  results.push(checkScripts(pkg));
+  results.push(...checkPanels(root));
+  results.push(...checkRpcContracts(root));
+  results.push(...checkMenus(root));
+  results.push(...checkStatusBars(root));
+  results.push(...checkSubpanels(root));
+  results.push(checkContributesSync(root, pkg));
+  results.push(checkActivationEvents(pkg));
+  results.push(checkMarketplaceIcon(root, pkg));
+  results.push(checkGenScript(root));
+  results.push(checkGitignore(root));
+  const counts = { ok: 0, warn: 0, error: 0 };
+  for (const r of results)
+    counts[r.level]++;
+  return {
+    projectRoot: root,
+    displayName: pkg?.displayName ?? pkg?.name ?? path12.basename(root),
+    results,
+    counts
+  };
+}
+function checkEngine(pkg) {
+  const engine = pkg?.engines?.vscode;
+  if (!engine) {
+    return { id: "engine", level: "error", message: "package.json missing engines.vscode" };
+  }
+  if (!/^[\^~>=]?\d+\.\d+/.test(engine)) {
+    return { id: "engine", level: "warn", message: `engines.vscode looks malformed: ${engine}` };
+  }
+  return { id: "engine", level: "ok", message: `engines.vscode  ${engine}` };
+}
+function checkScripts(pkg) {
+  const scripts = pkg?.scripts ?? {};
+  const required = ["gen", "dev", "launch", "build"];
+  const missing = required.filter((s) => typeof scripts[s] !== "string");
+  if (missing.length === 0) {
+    return { id: "scripts", level: "ok", message: `scripts          ${required.join(", ")}` };
+  }
+  return {
+    id: "scripts",
+    level: "error",
+    message: `missing scripts: ${missing.join(", ")}`
+  };
+}
+function checkPanels(root) {
+  const panels = listPanels(root);
+  if (panels.length === 0) {
+    return [{ id: "panels", level: "ok", message: "panels           none" }];
+  }
+  const out = [];
+  for (const id of panels) {
+    const file = path12.join(root, "src", "panels", `${id}.ts`);
+    const src = fs12.readFileSync(file, "utf8");
+    if (!/\bdefinePanel\b/.test(src)) {
+      out.push({ id: `panel.${id}`, level: "error", message: `panel ${id}: missing definePanel export` });
+      continue;
+    }
+    const webviewDir = path12.join(root, "src", "webview", "panels", id);
+    if (!fs12.existsSync(webviewDir)) {
+      out.push({
+        id: `panel.${id}.webview`,
+        level: "warn",
+        message: `panel ${id}: webview dir missing (src/webview/panels/${id}/)`
+      });
+    }
+  }
+  if (out.length === 0) {
+    out.push({ id: "panels", level: "ok", message: `panels           ${panels.length} valid` });
+  }
+  return out;
+}
+function checkRpcContracts(root) {
+  const apiFile = path12.join(root, "src", "shared", "api.ts");
+  if (!fs12.existsSync(apiFile))
+    return [];
+  const apiSrc = fs12.readFileSync(apiFile, "utf8");
+  const interfaces = parseInterfaces(apiSrc);
+  const out = [];
+  const panels = listPanels(root);
+  for (const id of panels) {
+    const Pascal = id.charAt(0).toUpperCase() + id.slice(1);
+    const apiName = `${Pascal}Api`;
+    if (!interfaces[apiName])
+      continue;
+    const file = path12.join(root, "src", "panels", `${id}.ts`);
+    const src = fs12.readFileSync(file, "utf8");
+    const handlers = parseRpcHandlers(src);
+    if (handlers === null) {
+      out.push({
+        id: `rpc.${id}`,
+        level: "warn",
+        message: `panel ${id}: ${apiName} interface declared but no rpc block`
+      });
+      continue;
+    }
+    const declared = interfaces[apiName];
+    const missing = declared.filter((m) => !handlers.includes(m));
+    const extra = handlers.filter((m) => !declared.includes(m));
+    if (missing.length === 0 && extra.length === 0) {
+      out.push({ id: `rpc.${id}`, level: "ok", message: `rpc ${id}        ${declared.length} method(s) in sync` });
+    } else {
+      out.push({
+        id: `rpc.${id}`,
+        level: "error",
+        message: `rpc ${id}: contract drift`,
+        details: [
+          ...missing.map((m) => `missing handler: ${m}`),
+          ...extra.map((m) => `extra handler (not in api): ${m}`)
+        ],
+        fix: missing.length > 0 ? () => {
+          addRpcHandlerStubs(file, missing);
+          return `added ${missing.length} handler stub(s) to ${path12.relative(root, file)}: ${missing.join(", ")}`;
+        } : undefined
+      });
+    }
+  }
+  return out;
+}
+function checkMenus(root) {
+  const menus = listMenus(root);
+  if (menus.length === 0)
+    return [];
+  const panels = new Set(listPanels(root));
+  const commands = new Set(listCommands(root));
+  const out = [];
+  for (const id of menus) {
+    const file = path12.join(root, "src", "menus", `${id}.ts`);
+    const tree = parseMenu(fs12.readFileSync(file, "utf8"));
+    const orphans = [];
+    const badIcons = [];
+    walk(tree.items, (n) => {
+      if (n.kind === "panel" && n.target && !panels.has(n.target)) {
+        orphans.push(`panel "${n.target}" (in "${n.label}")`);
+      }
+      if (n.kind === "command" && n.target && !commands.has(n.target)) {
+        orphans.push(`command "${n.target}" (in "${n.label}")`);
+      }
+      if (n.icon && !isKnownCodicon(n.icon)) {
+        badIcons.push(`${n.icon} (in "${n.label}")`);
+      }
+    });
+    if (tree.icon && !isKnownCodicon(tree.icon)) {
+      badIcons.push(`${tree.icon} (menu icon)`);
+    }
+    if (orphans.length === 0 && badIcons.length === 0) {
+      out.push({ id: `menu.${id}`, level: "ok", message: `menu ${id}       refs OK` });
+    } else {
+      if (orphans.length) {
+        const orphanTargets = [];
+        walk(tree.items, (n) => {
+          if (n.kind === "panel" && n.target && !panels.has(n.target)) {
+            orphanTargets.push({ kind: "panel", target: n.target });
+          }
+          if (n.kind === "command" && n.target && !commands.has(n.target)) {
+            orphanTargets.push({ kind: "command", target: n.target });
+          }
+        });
+        out.push({
+          id: `menu.${id}.refs`,
+          level: "error",
+          message: `menu ${id}: ${orphans.length} orphan ref(s)`,
+          details: orphans,
+          fix: () => {
+            const removed = removeOrphanMenuItems(file, orphanTargets);
+            return `removed ${removed} orphan item(s) from ${path12.relative(root, file)}`;
+          }
+        });
+      }
+      if (badIcons.length) {
+        out.push({
+          id: `menu.${id}.icons`,
+          level: "warn",
+          message: `menu ${id}: ${badIcons.length} unknown codicon(s)`,
+          details: badIcons
+        });
+      }
+    }
+  }
+  return out;
+}
+function checkStatusBars(root) {
+  const dir = path12.join(root, "src", "statusBars");
+  if (!fs12.existsSync(dir))
+    return [];
+  const files = fs12.readdirSync(dir).filter((f) => f.endsWith(".ts"));
+  if (files.length === 0)
+    return [];
+  const commands = new Set(listCommands(root));
+  const out = [];
+  for (const f of files) {
+    const id = f.replace(/\.ts$/, "");
+    const src = fs12.readFileSync(path12.join(dir, f), "utf8");
+    const cmdMatch = /\bcommand\s*:\s*(['"`])([^'"`]+)\1/.exec(src);
+    if (cmdMatch) {
+      const target = cmdMatch[2];
+      if (!target.includes(".") && !commands.has(target)) {
+        out.push({
+          id: `statusBar.${id}`,
+          level: "error",
+          message: `statusBar ${id}: command "${target}" not found in src/commands/`
+        });
+        continue;
+      }
+    }
+    out.push({ id: `statusBar.${id}`, level: "ok", message: `statusBar ${id}  OK` });
+  }
+  return out;
+}
+function checkSubpanels(root) {
+  const dir = path12.join(root, "src", "subpanels");
+  if (!fs12.existsSync(dir))
+    return [];
+  const files = fs12.readdirSync(dir).filter((f) => f.endsWith(".ts"));
+  if (files.length === 0)
+    return [];
+  const menus = new Set(listMenus(root));
+  const out = [];
+  for (const f of files) {
+    const id = f.replace(/\.ts$/, "");
+    const src = fs12.readFileSync(path12.join(dir, f), "utf8");
+    const m = /\bmenu\s*:\s*(['"`])([^'"`]+)\1/.exec(src);
+    if (!m) {
+      out.push({ id: `subpanel.${id}`, level: "error", message: `subpanel ${id}: missing \`menu\` field` });
+      continue;
+    }
+    if (!menus.has(m[2])) {
+      out.push({
+        id: `subpanel.${id}`,
+        level: "error",
+        message: `subpanel ${id}: references unknown menu "${m[2]}"`
+      });
+      continue;
+    }
+    out.push({ id: `subpanel.${id}`, level: "ok", message: `subpanel ${id}  → ${m[2]}` });
+  }
+  return out;
+}
+function checkContributesSync(root, pkg) {
+  const contributes = pkg?.contributes;
+  if (!contributes) {
+    return { id: "contributes", level: "warn", message: "package.json has no contributes — run `bun run gen`" };
+  }
+  const commands = new Set(listCommands(root));
+  const panels = new Set(listPanels(root));
+  const stale = [];
+  const prefix = pkg?.vsceasy?.commandPrefix ?? pkg.name?.replace(/^@[^/]+\//, "").replace(/[^a-zA-Z0-9]+/g, "") ?? "";
+  for (const c of contributes.commands ?? []) {
+    const id = c.command ?? "";
+    if (!id.startsWith(`${prefix}.`))
+      continue;
+    const suffix = id.slice(prefix.length + 1);
+    if (suffix.startsWith("open")) {
+      const panelId = suffix.slice(4).charAt(0).toLowerCase() + suffix.slice(5);
+      if (!panels.has(panelId))
+        stale.push(id);
+    } else if (!commands.has(suffix)) {
+      stale.push(id);
+    }
+  }
+  if (stale.length === 0) {
+    return { id: "contributes", level: "ok", message: "contributes       in sync with src/" };
+  }
+  return {
+    id: "contributes",
+    level: "warn",
+    message: `contributes: ${stale.length} stale entry(ies) — run \`bun run gen\``,
+    details: stale
+  };
+}
+function checkGitignore(root) {
+  const file = path12.join(root, ".gitignore");
+  const required = ["dist", "node_modules"];
+  if (!fs12.existsSync(file)) {
+    return {
+      id: "gitignore",
+      level: "warn",
+      message: ".gitignore missing",
+      fix: () => {
+        fs12.writeFileSync(file, required.join(`
+`) + `
+`);
+        return `created .gitignore with ${required.join(", ")}`;
+      }
+    };
+  }
+  const lines = fs12.readFileSync(file, "utf8").split(`
+`).map((l) => l.trim());
+  const missing = required.filter((p) => !lines.some((l) => l === p || l === `/${p}` || l === `${p}/`));
+  if (missing.length === 0)
+    return { id: "gitignore", level: "ok", message: ".gitignore       OK" };
+  return {
+    id: "gitignore",
+    level: "warn",
+    message: `.gitignore missing entries: ${missing.join(", ")}`,
+    fix: () => {
+      const raw = fs12.readFileSync(file, "utf8");
+      const suffix = raw.endsWith(`
+`) ? "" : `
+`;
+      fs12.writeFileSync(file, raw + suffix + missing.join(`
+`) + `
+`);
+      return `appended to .gitignore: ${missing.join(", ")}`;
+    }
+  };
+}
+function checkActivationEvents(pkg) {
+  const ae = pkg?.activationEvents;
+  if (!Array.isArray(ae)) {
+    return {
+      id: "activationEvents",
+      level: "warn",
+      message: "package.json missing activationEvents — should be `[]` (auto-derived from commands)",
+      fix: () => {
+        pkg.activationEvents = [];
+        return "Run `bun run gen` after fixing manually — auto-fix not safe to write package.json here";
+      }
+    };
+  }
+  if (ae.length === 0) {
+    return { id: "activationEvents", level: "ok", message: "activationEvents auto-derived from commands" };
+  }
+  const suspect = ae.filter((e) => typeof e === "string" && /^onCommand:/.test(e));
+  if (suspect.length) {
+    return {
+      id: "activationEvents",
+      level: "warn",
+      message: `activationEvents has ${suspect.length} redundant onCommand: entry(ies) — VS Code now auto-activates contributed commands`,
+      details: suspect.map(String)
+    };
+  }
+  return { id: "activationEvents", level: "ok", message: `activationEvents ${ae.length} explicit entry(ies)` };
+}
+function checkMarketplaceIcon(root, pkg) {
+  const iconRel = pkg?.icon;
+  if (!iconRel) {
+    return {
+      id: "icon",
+      level: "warn",
+      message: "package.json has no `icon` — marketplace listings without an icon look broken"
+    };
+  }
+  const abs = path12.join(root, iconRel);
+  if (!fs12.existsSync(abs)) {
+    return { id: "icon", level: "error", message: `icon path \`${iconRel}\` not found on disk` };
+  }
+  const buf = fs12.readFileSync(abs);
+  const isPng = buf.length > 24 && buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71;
+  if (!isPng) {
+    return { id: "icon", level: "warn", message: `icon \`${iconRel}\` is not a PNG — marketplace requires PNG ≥128×128` };
+  }
+  const w = buf.readUInt32BE(16);
+  const h = buf.readUInt32BE(20);
+  if (w < 128 || h < 128) {
+    return {
+      id: "icon",
+      level: "warn",
+      message: `icon is ${w}×${h} — marketplace requires ≥128×128 (use 128×128 square PNG)`
+    };
+  }
+  if (w !== h) {
+    return { id: "icon", level: "warn", message: `icon is ${w}×${h} (non-square) — use a square PNG` };
+  }
+  return { id: "icon", level: "ok", message: `icon             ${iconRel} (${w}×${h})` };
+}
+function checkGenScript(root) {
+  const genPath = path12.join(root, "scripts", "gen.ts");
+  if (!fs12.existsSync(genPath)) {
+    return { id: "gen-script", level: "error", message: "scripts/gen.ts missing — run `vsceasy upgrade --apply=true`" };
+  }
+  const src = fs12.readFileSync(genPath, "utf8");
+  const required = [
+    { name: "treeViews scan", needle: "TREE_VIEWS_DIR" },
+    { name: "jobs scan", needle: "JOBS_DIR" },
+    { name: "commandPalette when", needle: "commandPalette" }
+  ];
+  const missing = required.filter((r) => !src.includes(r.needle));
+  if (missing.length === 0) {
+    return { id: "gen-script", level: "ok", message: "scripts/gen.ts   up to date" };
+  }
+  return {
+    id: "gen-script",
+    level: "warn",
+    message: `scripts/gen.ts is outdated (missing: ${missing.map((m) => m.name).join(", ")}) — run \`vsceasy upgrade --apply=true\``
+  };
+}
+function readPkg(root) {
+  const p = path12.join(root, "package.json");
+  if (!fs12.existsSync(p))
+    throw new Error(`package.json not found at ${p}`);
+  return JSON.parse(fs12.readFileSync(p, "utf8"));
+}
+function parseInterfaces(src) {
+  const out = {};
+  const re = /export\s+interface\s+(\w+)\s*\{/g;
+  let m;
+  while (m = re.exec(src)) {
+    const name = m[1];
+    const bodyStart = m.index + m[0].length;
+    const bodyEnd = matchBrace(src, bodyStart);
+    if (bodyEnd === -1)
+      continue;
+    const body = src.slice(bodyStart, bodyEnd);
+    const methods = [];
+    const methRe = /(?:^|\n)\s*(\w+)\s*\(/g;
+    let mm;
+    while (mm = methRe.exec(body)) {
+      const key = mm[1];
+      if (!methods.includes(key))
+        methods.push(key);
+    }
+    out[name] = methods;
+  }
+  return out;
+}
+function matchBrace(src, start) {
+  let depth = 1;
+  for (let i = start;i < src.length; i++) {
+    const c = src[i];
+    if (c === "{")
+      depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  }
+  return -1;
+}
+function parseRpcHandlers(src) {
+  const re = /\brpc\s*:\s*\([^)]*\)\s*=>\s*\(\s*\{/m;
+  const m = re.exec(src);
+  if (!m)
+    return null;
+  const start = m.index + m[0].length;
+  let depth = 1;
+  let end = -1;
+  for (let i = start;i < src.length; i++) {
+    const c = src[i];
+    if (c === "{")
+      depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end === -1)
+    return [];
+  const body = src.slice(start, end);
+  const handlers = [];
+  const handRe = /(?:^|\n|,)\s*(?:async\s+)?(\w+)\s*\(/g;
+  let mm;
+  while (mm = handRe.exec(body)) {
+    handlers.push(mm[1]);
+  }
+  return handlers;
+}
+function walk(items, fn) {
+  for (const n of items) {
+    fn(n);
+    if (n.children)
+      walk(n.children, fn);
+  }
+}
+function applyFixes(report) {
+  const applied = [];
+  for (const r of report.results) {
+    if (!r.fix)
+      continue;
+    try {
+      const msg = r.fix();
+      applied.push({ id: r.id, message: msg });
+    } catch (e) {
+      applied.push({ id: r.id, message: `fix failed: ${e?.message ?? e}` });
+    }
+  }
+  return applied;
+}
+function addRpcHandlerStubs(panelFile, methods) {
+  let src = fs12.readFileSync(panelFile, "utf8");
+  const stubs = methods.map((m) => `    async ${m}() {
+      // TODO: implement
+      throw new Error('Not implemented');
+    },`);
+  const range = findRpcBodyRange2(src);
+  if (range) {
+    const inner = src.slice(range.start, range.end).replace(/\s+$/, "");
+    const sep = inner ? `
+` : "";
+    const newInner = `${inner}${sep}${stubs.join(`
+`)}
+  `;
+    src = src.slice(0, range.start) + newInner + src.slice(range.end);
+  } else {
+    const block = `
+  rpc: (vscode) => ({
+${stubs.join(`
+`)}
+  }),`;
+    if (/title\s*:\s*['"][^'"]*['"]\s*,/.test(src)) {
+      src = src.replace(/(title\s*:\s*['"][^'"]*['"]\s*,)/, `$1${block}`);
+    } else {
+      src = src.replace(/\}\s*\)\s*;?\s*$/, `${block}
+});
+`);
+    }
+  }
+  fs12.writeFileSync(panelFile, src);
+}
+function findRpcBodyRange2(src) {
+  const re = /\brpc\s*:\s*\([^)]*\)\s*=>\s*\(\s*\{/m;
+  const m = re.exec(src);
+  if (!m)
+    return null;
+  const start = m.index + m[0].length;
+  const end = matchBrace(src, start);
+  if (end === -1)
+    return null;
+  return { start, end };
+}
+function removeOrphanMenuItems(menuFile, orphans) {
+  let src = fs12.readFileSync(menuFile, "utf8");
+  let removed = 0;
+  for (const o of orphans) {
+    const targetRe = new RegExp(`${o.kind}\\s*:\\s*(['"\`])${escapeRe2(o.target)}\\1`);
+    while (true) {
+      const m = targetRe.exec(src);
+      if (!m)
+        break;
+      const idx = m.index;
+      const openIdx = findEnclosingObjectStart(src, idx);
+      if (openIdx === -1) {
+        break;
+      }
+      const closeIdx = matchBrace(src, openIdx + 1);
+      if (closeIdx === -1)
+        break;
+      let end = closeIdx + 1;
+      while (end < src.length && /[\s,]/.test(src[end]) && src[end] !== `
+`)
+        end++;
+      if (src[end] === ",")
+        end++;
+      let start = openIdx;
+      while (start > 0 && /[ \t]/.test(src[start - 1]))
+        start--;
+      src = src.slice(0, start) + src.slice(end);
+      removed++;
+    }
+  }
+  fs12.writeFileSync(menuFile, src);
+  return removed;
+}
+function escapeRe2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findEnclosingObjectStart(src, from) {
+  let depth = 0;
+  for (let i = from;i >= 0; i--) {
+    const c = src[i];
+    if (c === "}")
+      depth++;
+    else if (c === "{") {
+      if (depth === 0)
+        return i;
+      depth--;
+    }
+  }
+  return -1;
+}
+var fs12, path12;
+var init_doctor = __esm(() => {
+  init_edit();
+  init_menuTree();
+  init_codicons();
+  fs12 = __toESM(require("fs"));
+  path12 = __toESM(require("path"));
+});
+
+// src/lib/upgrade.ts
+function upgrade(opts) {
+  const ui = opts.ui ?? "react";
+  const sourceRoot = path13.join(opts.templatesRoot, ui);
+  if (!fs13.existsSync(sourceRoot)) {
+    throw new Error(`Templates UI not found: ${sourceRoot}`);
+  }
+  const changes = [];
+  for (const rel of SYNC_PATHS) {
+    const src = path13.join(sourceRoot, rel);
+    const dest = path13.join(opts.projectRoot, rel);
+    if (!fs13.existsSync(src)) {
+      changes.push({ path: rel, status: "missing-source" });
+      continue;
+    }
+    if (!fs13.existsSync(dest)) {
+      if (opts.apply) {
+        fs13.mkdirSync(path13.dirname(dest), { recursive: true });
+        fs13.copyFileSync(src, dest);
+        changes.push({ path: rel, status: "created" });
+      } else {
+        changes.push({ path: rel, status: "would-create" });
+      }
+      continue;
+    }
+    const same = filesEqual(src, dest);
+    if (same) {
+      changes.push({ path: rel, status: "in-sync" });
+    } else if (opts.apply) {
+      fs13.copyFileSync(src, dest);
+      changes.push({ path: rel, status: "updated" });
+    } else {
+      changes.push({ path: rel, status: "would-update" });
+    }
+  }
+  let genRan = false;
+  if (opts.apply && opts.runGen !== false) {
+    if (changes.some((c) => c.status === "updated" || c.status === "created")) {
+      genRan = runGen8(opts.projectRoot);
+    }
+  }
+  return { changes, applied: !!opts.apply, genRan };
+}
+function filesEqual(a, b) {
+  const sa = fs13.statSync(a);
+  const sb = fs13.statSync(b);
+  if (sa.size !== sb.size)
+    return false;
+  return fs13.readFileSync(a).equals(fs13.readFileSync(b));
+}
+function runGen8(cwd) {
+  const tryRun = (cmd, args) => {
+    const r = import_child_process8.spawnSync(cmd, args, { cwd, stdio: "inherit" });
+    return r.status === 0;
+  };
+  if (which8("bun") && tryRun("bun", ["run", "gen"]))
+    return true;
+  if (which8("npm") && tryRun("npm", ["run", "gen"]))
+    return true;
+  return false;
+}
+function which8(cmd) {
+  const r = import_child_process8.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" });
+  return r.status === 0;
+}
+var fs13, path13, import_child_process8, SYNC_PATHS;
+var init_upgrade = __esm(() => {
+  fs13 = __toESM(require("fs"));
+  path13 = __toESM(require("path"));
+  import_child_process8 = require("child_process");
+  SYNC_PATHS = [
+    "src/shared/vsceasy/define.ts",
+    "src/shared/vsceasy/bootstrap.ts",
+    "src/shared/vsceasy/rpc.ts",
+    "src/shared/vsceasy/client.ts",
+    "src/shared/vsceasy/index.ts",
+    "src/shared/vsceasy/codiconNames.ts",
+    "scripts/gen.ts",
+    "vite.config.ts"
+  ];
+});
+
+// src/lib/findProject.ts
+function findProjectRoot(start = process.cwd()) {
+  let dir = path14.resolve(start);
+  const { root } = path14.parse(dir);
+  while (true) {
+    const pkgPath = path14.join(dir, "package.json");
+    if (fs14.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf8"));
+        const genScript = pkg?.scripts?.gen;
+        const hasScan = typeof pkg?.scripts?.["gen:scan"] === "string";
+        if (genScript === "bun scripts/gen.ts" || hasScan)
+          return dir;
+      } catch {}
+    }
+    if (dir === root) {
+      throw new Error(`Not inside a vsceasy project (no package.json with scripts.gen="bun scripts/gen.ts" found above ${start}).`);
+    }
+    dir = path14.dirname(dir);
+  }
+}
+function findTemplatesRoot(fromFile = __dirname) {
+  const candidates = [
+    path14.resolve(fromFile, "..", "templates"),
+    path14.resolve(fromFile, "..", "..", "templates"),
+    path14.resolve(fromFile, "..", "..", "..", "templates")
+  ];
+  for (const c of candidates)
+    if (fs14.existsSync(c))
+      return c;
+  throw new Error(`templates/ directory not found near ${fromFile}`);
+}
+var fs14, path14, __dirname = "/home/runner/work/vsceasy/vsceasy/src/lib";
+var init_findProject = __esm(() => {
+  fs14 = __toESM(require("fs"));
+  path14 = __toESM(require("path"));
+});
+
+// src/lib/treeView/add.ts
+function addTreeView(opts) {
+  const name = assertId("tree view name", normalizeCamel6(opts.name));
+  const menu = assertId("menu id", normalizeCamel6(opts.menu));
+  assertSiblingExists(opts.projectRoot, "menu", menu);
+  const title = opts.title?.trim() || pascal(name);
+  const target = path15.join(opts.projectRoot, "src", "treeViews", `${name}.ts`);
+  assertNoOverwrite(opts.projectRoot, target, "Tree view");
+  const tpl = path15.join(opts.templatesRoot, "_generators", "treeView", "treeView.ts.tpl");
+  const body = substitute(fs15.readFileSync(tpl, "utf8"), { name, Name: pascal(name), title, menu });
+  fs15.mkdirSync(path15.dirname(target), { recursive: true });
+  fs15.writeFileSync(target, body);
+  let genRan = false;
+  if (opts.runGen !== false)
+    genRan = runGen9(opts.projectRoot);
+  return { created: [target], genRan };
+}
+function runGen9(cwd) {
+  const tryRun = (cmd, args) => import_child_process9.spawnSync(cmd, args, { cwd, stdio: "inherit" }).status === 0;
+  if (which9("bun") && tryRun("bun", ["run", "gen"]))
+    return true;
+  if (which9("npm") && tryRun("npm", ["run", "gen"]))
+    return true;
+  console.warn('\n! Could not run "gen" automatically. Run `bun run gen` manually.\n');
+  return false;
+}
+function which9(cmd) {
+  return import_child_process9.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" }).status === 0;
+}
+function normalizeCamel6(s) {
+  const cleaned = s.trim().replace(/[^a-zA-Z0-9]+(.)/g, (_m, c) => c.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "");
+  if (!cleaned)
+    return "";
+  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+}
+function pascal(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+var fs15, path15, import_child_process9;
+var init_add8 = __esm(() => {
+  init_scaffold();
+  init_validate();
+  fs15 = __toESM(require("fs"));
+  path15 = __toESM(require("path"));
+  import_child_process9 = require("child_process");
+});
+
+// src/lib/testSetup/index.ts
+function setupTests(opts) {
+  const created = [];
+  const vitestCfg = path16.join(opts.projectRoot, "vitest.config.ts");
+  if (!fs16.existsSync(vitestCfg) || opts.force) {
+    fs16.writeFileSync(vitestCfg, fs16.readFileSync(path16.join(opts.templatesRoot, "_generators", "test", "vitest.config.ts.tpl"), "utf8"));
+    created.push(vitestCfg);
+  }
+  const sampleDir = path16.join(opts.projectRoot, "src", "__tests__");
+  fs16.mkdirSync(sampleDir, { recursive: true });
+  const sample = path16.join(sampleDir, "sample.test.ts");
+  if (!fs16.existsSync(sample) || opts.force) {
+    fs16.writeFileSync(sample, fs16.readFileSync(path16.join(opts.templatesRoot, "_generators", "test", "sample.test.ts.tpl"), "utf8"));
+    created.push(sample);
+  }
+  const helpers = path16.join(sampleDir, "_helpers.ts");
+  if (!fs16.existsSync(helpers) || opts.force) {
+    fs16.writeFileSync(helpers, fs16.readFileSync(path16.join(opts.templatesRoot, "_generators", "test", "_helpers.ts.tpl"), "utf8"));
+    created.push(helpers);
+  }
+  const mocksDir = path16.join(sampleDir, "__mocks__");
+  fs16.mkdirSync(mocksDir, { recursive: true });
+  const vscodeStub = path16.join(mocksDir, "vscode.ts");
+  if (!fs16.existsSync(vscodeStub) || opts.force) {
+    fs16.writeFileSync(vscodeStub, fs16.readFileSync(path16.join(opts.templatesRoot, "_generators", "test", "vscode.stub.ts.tpl"), "utf8"));
+    created.push(vscodeStub);
+  }
+  const pkgPath = path16.join(opts.projectRoot, "package.json");
+  const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf8"));
+  pkg.scripts ??= {};
+  let pkgUpdated = false;
+  if (!pkg.scripts.test || pkg.scripts.test === 'echo "Error: no test specified" && exit 1') {
+    pkg.scripts.test = "vitest run";
+    pkgUpdated = true;
+  }
+  if (!pkg.scripts["test:watch"]) {
+    pkg.scripts["test:watch"] = "vitest";
+    pkgUpdated = true;
+  }
+  pkg.devDependencies ??= {};
+  if (!pkg.devDependencies.vitest) {
+    pkg.devDependencies.vitest = "^2.0.0";
+    pkgUpdated = true;
+  }
+  if (pkgUpdated) {
+    fs16.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + `
+`);
+  }
+  return { created, pkgUpdated };
+}
+var fs16, path16;
+var init_testSetup = __esm(() => {
+  fs16 = __toESM(require("fs"));
+  path16 = __toESM(require("path"));
+});
+
+// src/lib/publish/init.ts
+function publishInit(opts) {
+  const created = [];
+  const warnings = [];
+  const pkgPath = path17.join(opts.projectRoot, "package.json");
+  if (!fs17.existsSync(pkgPath))
+    throw new Error(`No package.json at ${opts.projectRoot}`);
+  const pkg = JSON.parse(fs17.readFileSync(pkgPath, "utf8"));
+  const vars = {
+    displayName: pkg.displayName ?? pkg.name ?? "My Extension",
+    description: pkg.description ?? ""
+  };
+  const readme = path17.join(opts.projectRoot, "README.md");
+  if (!fs17.existsSync(readme)) {
+    fs17.writeFileSync(readme, substitute(fs17.readFileSync(path17.join(opts.templatesRoot, "_generators", "publish", "README.md.tpl"), "utf8"), vars));
+    created.push(readme);
+  }
+  const changelog = path17.join(opts.projectRoot, "CHANGELOG.md");
+  if (!fs17.existsSync(changelog)) {
+    fs17.writeFileSync(changelog, fs17.readFileSync(path17.join(opts.templatesRoot, "_generators", "publish", "CHANGELOG.md.tpl"), "utf8"));
+    created.push(changelog);
+  }
+  const license = path17.join(opts.projectRoot, "LICENSE");
+  if (!fs17.existsSync(license)) {
+    warnings.push("LICENSE not found — marketplace recommends an explicit license file.");
+  }
+  const iconDir = path17.join(opts.projectRoot, "assets");
+  const iconFile = path17.join(iconDir, "icon.png");
+  if (!fs17.existsSync(iconFile)) {
+    fs17.mkdirSync(iconDir, { recursive: true });
+    fs17.writeFileSync(iconFile + ".placeholder", `Drop a 128×128 PNG named icon.png here.
+`);
+    warnings.push("No `assets/icon.png` yet — marketplace requires a 128×128 icon.");
+  }
+  let pkgUpdated = false;
+  if (!pkg.publisher || pkg.publisher === "your-publisher") {
+    warnings.push("`publisher` in package.json is missing or placeholder. Set it before publishing.");
+  }
+  if (!pkg.repository) {
+    pkg.repository = { type: "git", url: "" };
+    pkgUpdated = true;
+    warnings.push("Added empty `repository.url` — fill it before publishing.");
+  }
+  if (!pkg.icon && fs17.existsSync(iconFile)) {
+    pkg.icon = "assets/icon.png";
+    pkgUpdated = true;
+  }
+  if (!pkg.categories) {
+    pkg.categories = ["Other"];
+    pkgUpdated = true;
+  }
+  if (pkgUpdated)
+    fs17.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + `
+`);
+  let dryPackOk = null;
+  if (opts.runDryPack !== false) {
+    const r = import_child_process10.spawnSync("npx", ["--yes", "@vscode/vsce", "ls"], { cwd: opts.projectRoot, stdio: "inherit" });
+    dryPackOk = r.status === 0;
+    if (!dryPackOk)
+      warnings.push("`vsce ls` exited non-zero — inspect output above.");
+  }
+  return { created, pkgUpdated, warnings, dryPackOk };
+}
+var fs17, path17, import_child_process10;
+var init_init = __esm(() => {
+  init_scaffold();
+  fs17 = __toESM(require("fs"));
+  path17 = __toESM(require("path"));
+  import_child_process10 = require("child_process");
+});
+
+// src/lib/helper/add.ts
+function addHelper(opts) {
+  if (!HELPER_KINDS.includes(opts.kind)) {
+    throw new Error(`Unknown helper kind: "${opts.kind}". Available: ${HELPER_KINDS.map((k) => `"${k}"`).join(", ")}.`);
+  }
+  const cfg = readConfig(opts.projectRoot);
+  const pkgPath = path18.join(opts.projectRoot, "package.json");
+  const pkg = fs18.existsSync(pkgPath) ? JSON.parse(fs18.readFileSync(pkgPath, "utf8")) : {};
+  const vars = {
+    commandPrefix: cfg.commandPrefix ?? pkg.vsceasy?.commandPrefix ?? deriveCommandPrefix(pkg.name ?? "ext"),
+    displayName: pkg.displayName ?? pkg.name ?? "My Extension"
+  };
+  const tpl = path18.join(opts.templatesRoot, "_generators", "helper", `${opts.kind}.ts.tpl`);
+  if (!fs18.existsSync(tpl))
+    throw new Error(`Helper template missing: ${tpl}`);
+  const targetDir = path18.join(opts.projectRoot, "src", "helpers");
+  fs18.mkdirSync(targetDir, { recursive: true });
+  const target = path18.join(targetDir, `${opts.kind}.ts`);
+  const created = [];
+  const skipped = [];
+  if (fs18.existsSync(target) && !opts.force) {
+    skipped.push(target);
+  } else {
+    fs18.writeFileSync(target, substitute(fs18.readFileSync(tpl, "utf8"), vars));
+    created.push(target);
+  }
+  return { created, skipped };
+}
+function deriveCommandPrefix(name) {
+  return name.replace(/^@[^/]+\//, "").replace(/[^a-zA-Z0-9]+/g, "");
+}
+var fs18, path18, HELPER_KINDS;
+var init_add9 = __esm(() => {
+  init_scaffold();
+  init_config();
+  fs18 = __toESM(require("fs"));
+  path18 = __toESM(require("path"));
+  HELPER_KINDS = ["secrets", "config", "state", "notifications", "cache"];
+});
+
+// src/lib/job/add.ts
+function addJob(opts) {
+  const name = assertId("job name", normalizeCamel7(opts.name));
+  const Pascal = name.charAt(0).toUpperCase() + name.slice(1);
+  const title = opts.title?.trim() || Pascal;
+  const target = path19.join(opts.projectRoot, "src", "jobs", `${name}.ts`);
+  assertNoOverwrite(opts.projectRoot, target, "Job");
+  const tpl = path19.join(opts.templatesRoot, "_generators", "job", "job.ts.tpl");
+  if (!fs19.existsSync(tpl))
+    throw new Error(`Job template missing: ${tpl}`);
+  const vars = {
+    name,
+    Name: Pascal,
+    title,
+    schedule: stringifyTrigger(opts.trigger),
+    minIntervalLine: opts.minIntervalMs ? `
+  minIntervalMs: ${opts.minIntervalMs},` : ""
+  };
+  fs19.mkdirSync(path19.dirname(target), { recursive: true });
+  fs19.writeFileSync(target, substitute(fs19.readFileSync(tpl, "utf8"), vars));
+  let genRan = false;
+  if (opts.runGen !== false)
+    genRan = runGen10(opts.projectRoot);
+  return { created: [target], genRan };
+}
+function stringifyTrigger(t) {
+  if ("every" in t)
+    return `{ every: '${escape(t.every)}' }`;
+  if ("dailyAt" in t)
+    return `{ dailyAt: '${escape(t.dailyAt)}' }`;
+  if ("on" in t)
+    return `{ on: '${escape(t.on)}' }`;
+  if ("onFile" in t)
+    return `{ onFile: '${escape(t.onFile)}' }`;
+  throw new Error("Job requires a schedule: --every | --dailyAt | --on | --onFile");
+}
+function escape(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function runGen10(cwd) {
+  const tryRun = (cmd, args) => import_child_process11.spawnSync(cmd, args, { cwd, stdio: "inherit" }).status === 0;
+  if (which10("bun") && tryRun("bun", ["run", "gen"]))
+    return true;
+  if (which10("npm") && tryRun("npm", ["run", "gen"]))
+    return true;
+  console.warn('\n! Could not run "gen" automatically. Run `bun run gen` manually.\n');
+  return false;
+}
+function which10(cmd) {
+  return import_child_process11.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" }).status === 0;
+}
+function normalizeCamel7(s) {
+  const cleaned = s.trim().replace(/[^a-zA-Z0-9]+(.)/g, (_m, c) => c.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "");
+  if (!cleaned)
+    return "";
+  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+}
+var fs19, path19, import_child_process11;
+var init_add10 = __esm(() => {
+  init_scaffold();
+  init_validate();
+  fs19 = __toESM(require("fs"));
+  path19 = __toESM(require("path"));
+  import_child_process11 = require("child_process");
+});
+
+// src/lib/db/init.ts
+function initDb(opts) {
+  const provider = opts.provider ?? "storage";
+  const targetDir = path20.join(opts.projectRoot, "src", "helpers");
+  fs20.mkdirSync(targetDir, { recursive: true });
+  const target = path20.join(targetDir, "db.ts");
+  const tpl = path20.join(opts.templatesRoot, "_generators", "helper", "db.ts.tpl");
+  if (!fs20.existsSync(tpl))
+    throw new Error(`db template missing: ${tpl}`);
+  const created = [];
+  const skipped = [];
+  if (fs20.existsSync(target) && !opts.force) {
+    skipped.push(target);
+  } else {
+    const body = substitute(fs20.readFileSync(tpl, "utf8"), { provider });
+    fs20.writeFileSync(target, body);
+    created.push(target);
+  }
+  return { created, skipped, path: target, provider };
+}
+function dbExists(projectRoot) {
+  return fs20.existsSync(path20.join(projectRoot, "src", "helpers", "db.ts"));
+}
+var fs20, path20;
+var init_init2 = __esm(() => {
+  init_scaffold();
+  fs20 = __toESM(require("fs"));
+  path20 = __toESM(require("path"));
+});
+
+// src/lib/db/wire.ts
+function wireInitDb(projectRoot, importPath = "../helpers/db") {
+  const entry = path21.join(projectRoot, "src", "extension", "extension.ts");
+  if (!fs21.existsSync(entry)) {
+    return { status: "no-entry", path: entry };
+  }
+  let src = fs21.readFileSync(entry, "utf8");
+  if (/from\s+['"]\.\.\/helpers\/db['"]/.test(src) && /onActivate\s*:\s*\[[^\]]*initDb/.test(src)) {
+    return { status: "already-wired", path: entry, message: "initDb already in onActivate hooks." };
+  }
+  if (!/from\s+['"]\.\.\/helpers\/db['"]/.test(src)) {
+    const importLine = `import { initDb } from '${importPath}';
+`;
+    const lastImport = src.match(/(^import[^\n]*\n)+/m);
+    src = lastImport ? src.slice(0, lastImport.index + lastImport[0].length) + importLine + src.slice(lastImport.index + lastImport[0].length) : importLine + src;
+  } else if (!/\binitDb\b/.test(src)) {
+    src = src.replace(/import\s+\{([^}]*)\}\s+from\s+(['"])\.\.\/helpers\/db\2/, (_m, names, q) => {
+      const set = new Set(String(names).split(",").map((n) => n.trim()).filter(Boolean));
+      set.add("initDb");
+      return `import { ${[...set].join(", ")} } from ${q}../helpers/db${q}`;
+    });
+  }
+  const callRe = /\bbootstrap\s*\(\s*registry\s*(,\s*\{[\s\S]*?\})?\s*\)/;
+  const m = callRe.exec(src);
+  if (!m) {
+    return { status: "unrecognized", path: entry, message: "Could not locate `bootstrap(registry)` call. Wire manually:\n    bootstrap(registry, { onActivate: [initDb] })" };
+  }
+  if (!m[1]) {
+    src = src.replace(callRe, "bootstrap(registry, { onActivate: [initDb] })");
+  } else {
+    const opts = m[1];
+    let nextOpts;
+    if (/onActivate\s*:\s*\[/.test(opts)) {
+      nextOpts = opts.replace(/onActivate\s*:\s*\[([^\]]*)\]/, (_o, inner) => {
+        const items = inner.split(",").map((x) => x.trim()).filter(Boolean);
+        if (items.includes("initDb"))
+          return `onActivate: [${items.join(", ")}]`;
+        return `onActivate: [${[...items, "initDb"].join(", ")}]`;
+      });
+    } else {
+      nextOpts = opts.replace(/\{/, "{ onActivate: [initDb],");
+    }
+    src = src.replace(callRe, `bootstrap(registry${nextOpts})`);
+  }
+  fs21.writeFileSync(entry, src);
+  return { status: "wired", path: entry };
+}
+var fs21, path21;
+var init_wire = __esm(() => {
+  fs21 = __toESM(require("fs"));
+  path21 = __toESM(require("path"));
+});
+
+// src/lib/crud/parseModel.ts
+function parseModelFile(file) {
+  if (!fs22.existsSync(file))
+    throw new Error(`Model file not found: ${file}`);
+  const src = fs22.readFileSync(file, "utf8");
+  const ifaceMatch = /export\s+interface\s+([A-Z][A-Za-z0-9_]*)\s*\{([\s\S]*?)\n\}/.exec(src);
+  if (!ifaceMatch) {
+    throw new Error(`Model "${path22.basename(file)}" does not declare \`export interface\`.`);
+  }
+  const name = ifaceMatch[1];
+  const body = ifaceMatch[2];
+  const fields = parseInterfaceBody(body);
+  if (fields.length === 0) {
+    throw new Error(`Model "${name}" has no fields — add at least one before generating CRUD.`);
+  }
+  const pluralMatch = /export\s+const\s+([A-Z][A-Za-z0-9_]*)\s*=\s*defineEntity\s*<\s*[^>]+>\s*\(\s*(['"`])([^'"`]+)\2\s*,\s*\{([\s\S]*?)\}\s*\)/m.exec(src);
+  if (!pluralMatch) {
+    throw new Error(`Model "${name}" does not call \`defineEntity\`. Was it generated by \`vsceasy model add\`?`);
+  }
+  const plural = pluralMatch[1];
+  const collection = pluralMatch[3];
+  const entityBody = pluralMatch[4];
+  const pk = /\bprimaryKey\s*:\s*(['"`])([^'"`]+)\1/.exec(entityBody)?.[2];
+  if (!pk)
+    throw new Error(`Model "${name}" defineEntity is missing primaryKey.`);
+  const indexes = [];
+  const idxMatch = /\bindexes\s*:\s*\[([^\]]*)\]/.exec(entityBody);
+  if (idxMatch) {
+    const inner = idxMatch[1];
+    const re = /['"`]([^'"`]+)['"`]/g;
+    let m;
+    while (m = re.exec(inner))
+      indexes.push(m[1]);
+  }
+  const id = path22.basename(file).replace(/\.(ts|tsx)$/, "");
+  return { name, id, plural, collection, primaryKey: pk, indexes, fields, path: file };
+}
+function parseInterfaceBody(body) {
+  const fields = [];
+  const lines = body.split(/\n/).map((l) => l.trim()).filter(Boolean);
+  for (const raw of lines) {
+    if (raw.startsWith("//") || raw.startsWith("*") || raw.startsWith("/*"))
+      continue;
+    const line = raw.replace(/;$/, "").replace(/,$/, "").trim();
+    if (!line)
+      continue;
+    const colon = line.indexOf(":");
+    if (colon < 0)
+      continue;
+    let name = line.slice(0, colon).trim();
+    const type = line.slice(colon + 1).trim();
+    if (!name || !type)
+      continue;
+    let optional = false;
+    if (name.endsWith("?")) {
+      optional = true;
+      name = name.slice(0, -1);
+    }
+    fields.push({ name, type, optional });
+  }
+  return fields;
+}
+function inferInputSpec(type) {
+  const t = type.trim();
+  const cleaned = t.split("|").map((p) => p.trim()).filter((p) => p !== "null" && p !== "undefined");
+  if (cleaned.length > 1 && cleaned.every((p) => /^(['"`]).*\1$/.test(p))) {
+    return { kind: "select", options: cleaned.map((p) => p.slice(1, -1)) };
+  }
+  const single = cleaned[0] ?? t;
+  if (/^number$/.test(single))
+    return { kind: "number" };
+  if (/^boolean$/.test(single))
+    return { kind: "boolean" };
+  if (/^Date$/.test(single))
+    return { kind: "date" };
+  if (/^string$/.test(single))
+    return { kind: "text" };
+  return { kind: "text" };
+}
+var fs22, path22;
+var init_parseModel = __esm(() => {
+  fs22 = __toESM(require("fs"));
+  path22 = __toESM(require("path"));
+});
+
+// src/lib/crud/crudConfig.ts
+function readCrudConfig(projectRoot, modelName) {
+  const file = path23.join(projectRoot, "src", "models", `${modelName}.crud.ts`);
+  if (!fs23.existsSync(file))
+    return {};
+  try {
+    const src = fs23.readFileSync(file, "utf8");
+    return parseConfigSource(src);
+  } catch {
+    return {};
+  }
+}
+function parseConfigSource(src) {
+  const head = /export\s+default\s*\{/.exec(src);
+  if (!head)
+    return {};
+  const open = head.index + head[0].length - 1;
+  let depth = 0;
+  let close = -1;
+  for (let i = open;i < src.length; i++) {
+    const c = src[i];
+    if (c === "{")
+      depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0) {
+        close = i;
+        break;
+      }
+    }
+  }
+  if (close < 0)
+    return {};
+  const literal = src.slice(open, close + 1);
+  try {
+    const jsonish = literal.replace(/\/\/.*$/gm, "").replace(/,\s*([}\]])/g, "$1").replace(/([{,]\s*)([A-Za-z_][\w]*)\s*:/g, '$1"$2":').replace(/'/g, '"');
+    return JSON.parse(jsonish);
+  } catch {
+    return {};
+  }
+}
+var fs23, path23;
+var init_crudConfig = __esm(() => {
+  fs23 = __toESM(require("fs"));
+  path23 = __toESM(require("path"));
+});
+
+// src/lib/crud/add.ts
+function addCrud(opts) {
+  const modelFile = path24.join(opts.projectRoot, "src", "models", `${opts.model}.ts`);
+  const model = parseModelFile(modelFile);
+  const cfg = readCrudConfig(opts.projectRoot, opts.model);
+  const hidden = new Set(cfg.hidden ?? []);
+  const ordered = orderFields(model.fields, cfg.order ?? []);
+  const visible = ordered.filter((f) => !hidden.has(f.name));
+  if (visible.length === 0) {
+    throw new Error(`CRUD for "${model.name}": no visible fields after applying \`hidden\` config.`);
+  }
+  const title = cfg.title ?? model.plural;
+  const listId = `${camelLower(model.plural)}List`;
+  const formId = `${camelLower(model.name)}Form`;
+  const listApiName = `${model.plural}ListApi`;
+  const formApiName = `${model.name}FormApi`;
+  const servicePath = path24.join(opts.projectRoot, "src", "services", `${model.name}Service.ts`);
+  const listPanelPath = path24.join(opts.projectRoot, "src", "panels", `${listId}.ts`);
+  const formPanelPath = path24.join(opts.projectRoot, "src", "panels", `${formId}.ts`);
+  const listWebDir = path24.join(opts.projectRoot, "src", "webview", "panels", listId);
+  const formWebDir = path24.join(opts.projectRoot, "src", "webview", "panels", formId);
+  const apiPath = path24.join(opts.projectRoot, "src", "shared", "api.ts");
+  assertNoOverwrite(opts.projectRoot, servicePath, "Service");
+  assertNoOverwrite(opts.projectRoot, listPanelPath, "List panel");
+  assertNoOverwrite(opts.projectRoot, formPanelPath, "Form panel");
+  assertNoOverwrite(opts.projectRoot, listWebDir, "List webview dir");
+  assertNoOverwrite(opts.projectRoot, formWebDir, "Form webview dir");
+  const pkg = JSON.parse(fs24.readFileSync(path24.join(opts.projectRoot, "package.json"), "utf8"));
+  const prefix = pkg.vsceasy?.commandPrefix ?? pkg.name?.replace(/^@[^/]+\//, "").replace(/[^a-zA-Z0-9]+/g, "") ?? "ext";
+  const baseVars = {
+    Name: model.name,
+    name: camelLower(model.name),
+    Plural: model.plural,
+    plural: camelLower(model.plural),
+    primaryKey: model.primaryKey,
+    title,
+    listId,
+    formId,
+    prefix
+  };
+  const created = [];
+  const modified = [];
+  writeFromTpl(path24.join(opts.templatesRoot, "_generators", "crud", "service.ts.tpl"), servicePath, baseVars, created);
+  writeFromTpl(path24.join(opts.templatesRoot, "_generators", "crud", "formNav.ts.tpl"), path24.join(opts.projectRoot, "src", "services", `${camelLower(model.name)}FormNav.ts`), baseVars, created);
+  writeFromTpl(path24.join(opts.templatesRoot, "_generators", "crud", "listPanel.ts.tpl"), listPanelPath, baseVars, created);
+  writeFromTpl(path24.join(opts.templatesRoot, "_generators", "crud", "formPanel.ts.tpl"), formPanelPath, baseVars, created);
+  fs24.mkdirSync(listWebDir, { recursive: true });
+  const listVars = {
+    ...baseVars,
+    listHeaderCells: visible.map((f) => `              <th style={{ padding: '6px 8px' }}>${escapeJsx(label(f, cfg))}</th>`).join(`
+`),
+    listBodyCells: visible.map((f) => `                <td style={{ padding: '6px 8px' }}>{String(r.${f.name} ?? '')}</td>`).join(`
+`),
+    listColCount: String(visible.length + 1)
+  };
+  writeFromTpl(path24.join(opts.templatesRoot, "_generators", "crud", "listApp.tsx.tpl"), path24.join(listWebDir, "App.tsx"), listVars, created);
+  writeFromTpl(path24.join(opts.templatesRoot, "_generators", "crud", "main.tsx.tpl"), path24.join(listWebDir, "main.tsx"), baseVars, created);
+  fs24.mkdirSync(formWebDir, { recursive: true });
+  const formInputs = visible.filter((f) => !cfg.fields?.[f.name]?.hideInForm).map((f) => renderInput(f, cfg.fields?.[f.name])).join(`
+`);
+  const emptyLit = buildEmptyFormLiteral(visible, cfg);
+  writeFromTpl(path24.join(opts.templatesRoot, "_generators", "crud", "formApp.tsx.tpl"), path24.join(formWebDir, "App.tsx"), { ...baseVars, formFieldInputs: formInputs, emptyFormLiteral: emptyLit }, created);
+  writeFromTpl(path24.join(opts.templatesRoot, "_generators", "crud", "main.tsx.tpl"), path24.join(formWebDir, "main.tsx"), baseVars, created);
+  appendApi3(apiPath, listApiName, model, created, modified);
+  appendApiForm(apiPath, formApiName, model, created, modified);
+  let menuInfo;
+  if (opts.menu && opts.menu !== "none") {
+    menuInfo = wireMenu(opts, model, cfg, listId, formId);
+  }
+  let genRan = false;
+  if (opts.runGen !== false)
+    genRan = runGen11(opts.projectRoot);
+  return { created, modified, menu: menuInfo, genRan };
+}
+function writeFromTpl(tpl, target, vars, created) {
+  if (!fs24.existsSync(tpl))
+    throw new Error(`CRUD template missing: ${tpl}`);
+  fs24.mkdirSync(path24.dirname(target), { recursive: true });
+  fs24.writeFileSync(target, substitute(fs24.readFileSync(tpl, "utf8"), vars));
+  created.push(target);
+}
+function orderFields(fields, order) {
+  const byName = new Map(fields.map((f) => [f.name, f]));
+  const out = [];
+  for (const name of order) {
+    const f = byName.get(name);
+    if (f) {
+      out.push(f);
+      byName.delete(name);
+    }
+  }
+  for (const f of byName.values())
+    out.push(f);
+  return out;
+}
+function label(field, cfg) {
+  const override = cfg.fields?.[field.name]?.label;
+  if (override)
+    return override;
+  return field.name.charAt(0).toUpperCase() + field.name.slice(1).replace(/([A-Z])/g, " $1");
+}
+function escapeJsx(s) {
+  return s.replace(/'/g, "&apos;").replace(/"/g, "&quot;");
+}
+function escapeAttr(s) {
+  return s.replace(/'/g, "\\'");
+}
+function renderInput(field, override) {
+  const spec = override?.input ? { kind: override.input, options: override.options } : inferInputSpec(field.type);
+  const labelText = override?.label ?? field.name.charAt(0).toUpperCase() + field.name.slice(1).replace(/([A-Z])/g, " $1");
+  const placeholder = override?.placeholder ?? "";
+  const placeholderAttr = placeholder ? ` placeholder='${escapeAttr(placeholder)}'` : "";
+  const required = field.optional ? "" : " required";
+  const name = field.name;
+  const wrap = (input) => `      <label style={{ display: 'grid', gap: 4 }}>
+` + `        <span style={{ opacity: 0.8 }}>${labelText}</span>
+` + `${input}
+` + `      </label>`;
+  switch (spec.kind) {
+    case "number":
+      return wrap(`        <input type="number"${placeholderAttr}${required} value={form.${name} as any ?? ''} onChange={(e) => onChange('${name}', e.target.value === '' ? undefined : Number(e.target.value))} />`);
+    case "boolean":
+      return wrap(`        <input type="checkbox" checked={!!form.${name}} onChange={(e) => onChange('${name}', e.target.checked as any)} />`);
+    case "date":
+      return wrap(`        <input type="date"${required} value={(form.${name} as any) ?? ''} onChange={(e) => onChange('${name}', e.target.value as any)} />`);
+    case "select": {
+      const opts = (spec.options ?? []).map((o) => `          <option value=${JSON.stringify(o)}>${escapeJsx(o)}</option>`).join(`
+`);
+      return wrap(`        <select${required} value={(form.${name} as any) ?? ''} onChange={(e) => onChange('${name}', e.target.value as any)}>
+` + `          <option value=""></option>
+` + `${opts}
+` + `        </select>`);
+    }
+    case "textarea":
+      return wrap(`        <textarea${placeholderAttr}${required} rows={4} value={(form.${name} as any) ?? ''} onChange={(e) => onChange('${name}', e.target.value as any)} />`);
+    case "text":
+    default:
+      return wrap(`        <input type="text"${placeholderAttr}${required} value={(form.${name} as any) ?? ''} onChange={(e) => onChange('${name}', e.target.value as any)} />`);
+  }
+}
+function buildEmptyFormLiteral(fields, cfg) {
+  const lines = ["{"];
+  for (const f of fields) {
+    if (cfg.fields?.[f.name]?.hideInForm)
+      continue;
+    const spec = cfg.fields?.[f.name]?.input ? { kind: cfg.fields[f.name].input } : inferInputSpec(f.type);
+    let val = "''";
+    if (spec.kind === "number")
+      val = "0";
+    else if (spec.kind === "boolean")
+      val = "false";
+    lines.push(`  ${f.name}: ${val} as any,`);
+  }
+  lines.push("}");
+  return lines.join(`
+`);
+}
+function appendApi3(apiPath, apiName, model, created, modified) {
+  const sig = `
+export interface ${apiName} {
+` + `  list(): Promise<${model.name}[]>;
+` + `  delete(id: ${model.name}['${model.primaryKey}']): Promise<boolean>;
+` + `  openForm(id?: ${model.name}['${model.primaryKey}']): Promise<void>;
+` + `}
+`;
+  ensureImport(apiPath, model.name);
+  appendIfMissing(apiPath, apiName, sig, created, modified);
+}
+function appendApiForm(apiPath, apiName, model, created, modified) {
+  const sig = `
+export interface ${apiName} {
+` + `  pendingId(): Promise<${model.name}['${model.primaryKey}'] | null>;
+` + `  get(id: ${model.name}['${model.primaryKey}'] | null): Promise<${model.name} | null>;
+` + `  save(row: ${model.name}): Promise<${model.name}>;
+` + `  cancel(): Promise<void>;
+` + `}
+`;
+  ensureImport(apiPath, model.name);
+  appendIfMissing(apiPath, apiName, sig, created, modified);
+}
+function ensureImport(apiPath, modelName) {
+  if (!fs24.existsSync(apiPath)) {
+    fs24.mkdirSync(path24.dirname(apiPath), { recursive: true });
+    fs24.writeFileSync(apiPath, `import type { ${modelName} } from '../models/${modelName}';
+`);
+    return;
+  }
+  let src = fs24.readFileSync(apiPath, "utf8");
+  if (new RegExp(`from\\s+['"]\\.\\./models/${modelName}['"]`).test(src))
+    return;
+  src = `import type { ${modelName} } from '../models/${modelName}';
+` + src;
+  fs24.writeFileSync(apiPath, src);
+}
+function appendIfMissing(apiPath, apiName, block, created, modified) {
+  if (!fs24.existsSync(apiPath)) {
+    fs24.writeFileSync(apiPath, block.trimStart());
+    created.push(apiPath);
+    return;
+  }
+  const src = fs24.readFileSync(apiPath, "utf8");
+  if (new RegExp(`\\bexport\\s+interface\\s+${apiName}\\b`).test(src))
+    return;
+  const sep = src.endsWith(`
+`) ? "" : `
+`;
+  fs24.writeFileSync(apiPath, src + sep + block);
+  if (!modified.includes(apiPath))
+    modified.push(apiPath);
+}
+function wireMenu(opts, model, cfg, listId, formId) {
+  const spec = opts.menu;
+  const [kind, value] = spec.split(":");
+  let menuId;
+  let created = false;
+  if (kind === "new") {
+    menuId = value || camelLower(model.plural);
+    addMenu({
+      name: menuId,
+      title: cfg.title ?? model.plural,
+      icon: cfg.icon,
+      projectRoot: opts.projectRoot,
+      templatesRoot: opts.templatesRoot,
+      runGen: false
+    });
+    created = true;
+  } else if (kind === "existing") {
+    if (!value)
+      throw new Error("--menu existing requires `:<menuId>` (e.g. existing:settings).");
+    menuId = value;
+  } else {
+    throw new Error(`Invalid --menu "${spec}". Use: none | existing:<id> | new:<id>`);
+  }
+  editMenu({
+    projectRoot: opts.projectRoot,
+    menuName: menuId,
+    runGen: false,
+    item: { label: cfg.title ?? model.plural, kind: "panel", target: listId, icon: cfg.icon ?? "list-unordered" }
+  });
+  editMenu({
+    projectRoot: opts.projectRoot,
+    menuName: menuId,
+    runGen: false,
+    item: { label: `New ${model.name}`, kind: "panel", target: formId, icon: "add" }
+  });
+  return { id: menuId, created };
+}
+function camelLower(s) {
+  return s.charAt(0).toLowerCase() + s.slice(1);
+}
+function runGen11(cwd) {
+  const tryRun = (cmd, args) => import_child_process12.spawnSync(cmd, args, { cwd, stdio: "inherit" }).status === 0;
+  if (which11("bun") && tryRun("bun", ["run", "gen"]))
+    return true;
+  if (which11("npm") && tryRun("npm", ["run", "gen"]))
+    return true;
+  console.warn('\n! Could not run "gen" automatically. Run `bun run gen` manually.\n');
+  return false;
+}
+function which11(cmd) {
+  return import_child_process12.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" }).status === 0;
+}
+var fs24, path24, import_child_process12;
+var init_add11 = __esm(() => {
+  init_scaffold();
+  init_validate();
+  init_parseModel();
+  init_crudConfig();
+  init_add3();
+  init_edit();
+  fs24 = __toESM(require("fs"));
+  path24 = __toESM(require("path"));
+  import_child_process12 = require("child_process");
+});
+
+// src/lib/model/add.ts
+function addModel(opts) {
+  const name = assertId("model name", normalizeCamel8(opts.name));
+  const Name = name.charAt(0).toUpperCase() + name.slice(1);
+  if (!dbExists(opts.projectRoot)) {
+    throw new Error("No database initialized. Run `vsceasy db init` first, then re-run `vsceasy model add`.");
+  }
+  if (opts.fields.length === 0) {
+    throw new Error("Model needs at least one field. Re-run and add fields in the interactive loop.");
+  }
+  const Plural = opts.plural?.trim() || `${Name}s`;
+  const collection = opts.collection?.trim() || Plural.toLowerCase();
+  const explicitPk = opts.fields.filter((f) => f.primaryKey);
+  if (explicitPk.length > 1) {
+    throw new Error(`Model "${Name}": more than one field marked primaryKey: ${explicitPk.map((f) => f.name).join(", ")}.`);
+  }
+  const pkField = explicitPk[0] ?? opts.fields.find((f) => f.name === "id") ?? opts.fields[0];
+  const primaryKey = pkField.name;
+  const indexes = opts.fields.filter((f) => f.indexed && f.name !== primaryKey).map((f) => f.name);
+  const target = path25.join(opts.projectRoot, "src", "models", `${Name}.ts`);
+  assertNoOverwrite(opts.projectRoot, target, "Model");
+  const tpl = path25.join(opts.templatesRoot, "_generators", "model", "model.ts.tpl");
+  const fieldLines = opts.fields.map((f) => `  ${f.name}${f.optional ? "?" : ""}: ${f.type};`).join(`
+`);
+  const vars = {
+    name,
+    Name,
+    Plural,
+    collection,
+    primaryKey,
+    fieldLines,
+    indexesLine: indexes.length ? `
+  indexes: [${indexes.map((i) => `'${i}'`).join(", ")}],` : ""
+  };
+  fs25.mkdirSync(path25.dirname(target), { recursive: true });
+  fs25.writeFileSync(target, substitute(fs25.readFileSync(tpl, "utf8"), vars));
+  return { created: [target], primaryKey, indexes };
+}
+function normalizeCamel8(s) {
+  const cleaned = s.trim().replace(/[^a-zA-Z0-9]+(.)/g, (_m, c) => c.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "");
+  if (!cleaned)
+    return "";
+  return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+}
+var fs25, path25;
+var init_add12 = __esm(() => {
+  init_scaffold();
+  init_validate();
+  init_init2();
+  fs25 = __toESM(require("fs"));
+  path25 = __toESM(require("path"));
+});
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  writeConfig: () => writeConfig,
+  wireInitDb: () => wireInitDb,
+  upgrade: () => upgrade,
+  substitute: () => substitute,
+  setupTests: () => setupTests,
+  scaffold: () => scaffold,
+  runDoctor: () => runDoctor,
+  readCrudConfig: () => readCrudConfig,
+  readConfig: () => readConfig,
+  publishInit: () => publishInit,
+  parseModelFile: () => parseModelFile,
+  listPanels: () => listPanels,
+  listMenus: () => listMenus,
+  listGroups: () => listGroups,
+  listCommands: () => listCommands,
+  initDb: () => initDb,
+  inferInputSpec: () => inferInputSpec,
+  findTemplatesRoot: () => findTemplatesRoot,
+  findProjectRoot: () => findProjectRoot,
+  editMenu: () => editMenu,
+  dbExists: () => dbExists,
+  configPath: () => configPath,
+  assertSiblingExists: () => assertSiblingExists,
+  assertNoOverwrite: () => assertNoOverwrite,
+  assertId: () => assertId,
+  applyFixes: () => applyFixes,
+  addTreeView: () => addTreeView,
+  addSubpanel: () => addSubpanel,
+  addStatusBar: () => addStatusBar,
+  addRpcMethod: () => addRpcMethod,
+  addPanel: () => addPanel,
+  addModel: () => addModel,
+  addMenu: () => addMenu,
+  addJob: () => addJob,
+  addHelper: () => addHelper,
+  addCrud: () => addCrud,
+  addCommand: () => addCommand,
+  HELPER_KINDS: () => HELPER_KINDS
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/lib/index.ts
+init_scaffold();
+init_add2();
+init_add3();
+init_add4();
+init_add5();
+init_add6();
+init_add7();
+init_edit();
+init_doctor();
+init_upgrade();
+init_findProject();
+init_config();
+init_add8();
+init_testSetup();
+init_validate();
+init_init();
+init_add9();
+init_add10();
+init_init2();
+init_wire();
+init_add11();
+init_parseModel();
+init_crudConfig();
+init_add12();