pulse-rb 1.2.24

package/dist/index.js

@@ -0,0 +1,3285 @@
+'use strict';
+
+var os = require('os');
+var path = require('path');
+var pc = require('picocolors');
+var prompts = require('@clack/prompts');
+var fs = require('fs');
+var pathe = require('pathe');
+var ofetch = require('ofetch');
+var child_process = require('child_process');
+var chokidar = require('chokidar');
+var execa = require('execa');
+var globby = require('globby');
+var promises = require('fs/promises');
+var citty = require('citty');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pc__default = /*#__PURE__*/_interopDefault(pc);
+var chokidar__default = /*#__PURE__*/_interopDefault(chokidar);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/.pnpm/tsup@8.5.1_postcss@8.5.15_tsx@4.22.4_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/.pnpm/tsup@8.5.1_postcss@8.5.15_tsx@4.22.4_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js"() {
+  }
+});
+var RB_VERSION, RB_HOME, IRONBREW2_DIR, IRONBREW2_REPO, ALWAYS_EXCLUDE, VALID_UI_LIBS, OBFUSCATION_PRESETS, CDN_BASE_URL;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    init_cjs_shims();
+    RB_VERSION = "1.2.24";
+    RB_HOME = path.join(os.homedir(), ".rb");
+    path.join(RB_HOME, "bin");
+    IRONBREW2_DIR = path.join(RB_HOME, "ironbrew2");
+    IRONBREW2_REPO = "https://github.com/LorekeeperZinnia/IronBrew2.git";
+    ALWAYS_EXCLUDE = /* @__PURE__ */ new Set(["types.lua"]);
+    VALID_UI_LIBS = /* @__PURE__ */ new Set(["linoria", "windui"]);
+    OBFUSCATION_PRESETS = ["Low", "Medium", "Strong"];
+    CDN_BASE_URL = "https://cdn.pulse-rb.dev";
+  }
+});
+
+// src/ui.ts
+var ui_exports = {};
+__export(ui_exports, {
+  bold: () => bold,
+  confirm: () => prompts.confirm,
+  cyan: () => cyan,
+  dim: () => dim,
+  gray: () => gray,
+  green: () => green,
+  isCancel: () => prompts.isCancel,
+  pDim: () => pDim,
+  pDone: () => pDone,
+  pFail: () => pFail,
+  pHeader: () => pHeader,
+  pHr: () => pHr,
+  pInfo: () => pInfo,
+  pKv: () => pKv,
+  pOk: () => pOk,
+  pSection: () => pSection,
+  pWarn: () => pWarn,
+  red: () => red,
+  select: () => prompts.select,
+  spinner: () => prompts.spinner,
+  text: () => prompts.text,
+  yellow: () => yellow
+});
+function pHeader(cmd) {
+  console.log(`
+  ${cyan("\u25B6")}  ${bold("rb " + cmd)}
+`);
+}
+function pSection(title) {
+  console.log(`
+  ${bold(title)}`);
+}
+function pOk(label, ...details) {
+  const tail = details.length ? `  ${gray(details.join(" \xB7 "))}` : "";
+  console.log(`    ${green("\u2713")}  ${label}${tail}`);
+}
+function pFail(msg, hint = "") {
+  console.log(`    ${red("\u2717")}  ${red(msg)}`);
+  if (hint) console.log(`       ${dim(hint)}`);
+}
+function pInfo(msg) {
+  console.log(`    ${cyan("\u2192")}  ${msg}`);
+}
+function pWarn(msg) {
+  console.log(`    ${yellow("!")}  ${yellow(msg)}`);
+}
+function pDim(msg, indent = 7) {
+  console.log(`${" ".repeat(indent)}${dim(msg)}`);
+}
+function pKv(key, val, width = 12) {
+  console.log(`    ${gray(key.padEnd(width))}  ${val}`);
+}
+function pHr(width = 44) {
+  console.log(`  ${dim("\u2500".repeat(width))}`);
+}
+function pDone(elapsed) {
+  console.log(`
+  ${dim(`Done in ${elapsed.toFixed(1)}s`)}
+`);
+}
+var isTTY, c, bold, dim, green, red, yellow, cyan, gray;
+var init_ui = __esm({
+  "src/ui.ts"() {
+    init_cjs_shims();
+    isTTY = Boolean(process.stdout.isTTY);
+    c = (fn, t) => isTTY ? fn(t) : t;
+    bold = (t) => c(pc__default.default.bold, t);
+    dim = (t) => c(pc__default.default.dim, t);
+    green = (t) => c(pc__default.default.green, t);
+    red = (t) => c(pc__default.default.red, t);
+    yellow = (t) => c(pc__default.default.yellow, t);
+    cyan = (t) => c(pc__default.default.cyan, t);
+    gray = (t) => c(pc__default.default.gray, t);
+  }
+});
+function findProjectRoot(start) {
+  let current = path.resolve(process.cwd());
+  while (true) {
+    if (fs.existsSync(path.join(current, "src"))) return current;
+    const parent = path.join(current, "..");
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function requireProjectRoot() {
+  const root = findProjectRoot();
+  if (!root) {
+    pFail("Not inside an rb project", "run from a directory containing src/");
+    process.exit(1);
+  }
+  return root;
+}
+var init_project = __esm({
+  "src/project.ts"() {
+    init_cjs_shims();
+    init_ui();
+  }
+});
+
+// src/transpiler/helpers.ts
+function extractBlock(text2, start) {
+  let depth = 1;
+  let i = start;
+  while (i < text2.length && depth > 0) {
+    if (text2[i] === "{") depth++;
+    else if (text2[i] === "}") depth--;
+    i++;
+  }
+  return [text2.slice(start, i - 1), i];
+}
+var EVENT_MAP, DEFAULT_DEBOUNCE, CHAR_REFS;
+var init_helpers = __esm({
+  "src/transpiler/helpers.ts"() {
+    init_cjs_shims();
+    EVENT_MAP = {
+      Heartbeat: "_PulseRS.Heartbeat",
+      RenderStepped: "_PulseRS.RenderStepped",
+      Stepped: "_PulseRS.Stepped",
+      InputBegan: "_PulseUIS.InputBegan",
+      InputEnded: "_PulseUIS.InputEnded",
+      CharacterAdded: "_LocalPlayer.CharacterAdded",
+      CharacterRemoving: "_LocalPlayer.CharacterRemoving"
+    };
+    DEFAULT_DEBOUNCE = 0.2;
+    CHAR_REFS = {
+      hrp: "_PulseGetHRP()",
+      humanoid: "_PulseGetHumanoid()",
+      character: "_PulseGetChar()",
+      alive: "_PulseGetAlive()"
+    };
+  }
+});
+
+// src/transpiler/component.ts
+function remotePathToChain(path) {
+  let chain = 'game:GetService("ReplicatedStorage")';
+  for (const part of path.split("/").map((p) => p.trim()).filter(Boolean)) {
+    chain += `:WaitForChild("${part}")`;
+  }
+  return chain;
+}
+function watchExprToLua(expr, charVar) {
+  const m = expr.trim().match(/^Character\.(\w+)$/);
+  if (m) return `${charVar} and ${charVar}:FindFirstChild("${m[1]}") or nil`;
+  return expr.trim();
+}
+function findComponentBlock(src) {
+  const m = src.match(/\bcomponent\s*\{/);
+  if (!m || m.index === void 0) return [null, -1, -1];
+  const [inner, end] = extractBlock(src, m.index + m[0].length);
+  return [inner, m.index + m[0].length, end];
+}
+function parseUiWidgets(body, name) {
+  const widgets = [];
+  for (const raw of body.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("--")) continue;
+    if (line === "separator") {
+      widgets.push({ type: "separator" });
+      continue;
+    }
+    let m = line.match(/^label\s+"([^"]+)"$/);
+    if (m) {
+      widgets.push({ type: "label", label: m[1] });
+      continue;
+    }
+    m = line.match(/^toggle\s+"([^"]+)"\s+->\s+(\w+)(?:\s+default=(\S+?))?(?:\s+tip="([^"]*)")?$/);
+    if (m) {
+      const w = { type: "toggle", id: `${name}_${m[2]}`, label: m[1], signal: m[2], tip: m[4] ?? "" };
+      if (m[3] !== void 0) w.default = m[3];
+      widgets.push(w);
+      continue;
+    }
+    m = line.match(/^slider\s+"([^"]+)"\s+->\s+(\w+)\s+\[([^\],]+),\s*([^\]]+)\](?:\s+default=(\S+?))?(?:\s+tip="([^"]*)")?$/);
+    if (m) {
+      const w = { type: "slider", id: `${name}_${m[2]}`, label: m[1], signal: m[2], min: m[3].trim(), max: m[4].trim(), tip: m[6] ?? "" };
+      if (m[5] !== void 0) w.default = m[5];
+      widgets.push(w);
+      continue;
+    }
+    m = line.match(/^dropdown\s+"([^"]+)"\s+->\s+(\w+)\s+(\[[^\]]+\])(?:\s+default=(\S+?))?(?:\s+tip="([^"]*)")?$/);
+    if (m) {
+      const w = { type: "dropdown", id: `${name}_${m[2]}`, label: m[1], signal: m[2], options: "{" + m[3].slice(1, -1) + "}", tip: m[5] ?? "" };
+      if (m[4] !== void 0) w.default = m[4];
+      widgets.push(w);
+      continue;
+    }
+    m = line.match(/^multidropdown\s+"([^"]+)"\s+->\s+(\w+)\s+(\[[^\]]+\])(?:\s+tip="([^"]*)")?$/);
+    if (m) {
+      widgets.push({ type: "multidropdown", id: `${name}_${m[2]}`, label: m[1], signal: m[2], options: "{" + m[3].slice(1, -1) + "}", tip: m[4] ?? "" });
+      continue;
+    }
+    m = line.match(/^button\s+"([^"]+)"\s+->\s+(\w+)\(\)(?:\s+tip="([^"]*)")?$/);
+    if (m) {
+      widgets.push({ type: "button", label: m[1], func: m[2], tip: m[3] ?? "" });
+      continue;
+    }
+    m = line.match(/^keybind\s+"([^"]+)"\s+key="([^"]+)"\s+->\s+(\w+)\(\)$/);
+    if (m) {
+      widgets.push({ type: "keybind", id: `${name}_kb_${m[3]}`, label: m[1], key: m[2], func: m[3] });
+      continue;
+    }
+  }
+  return widgets;
+}
+function parseModifiers(text2) {
+  const mods = {};
+  for (const m of text2.matchAll(/(when|every|debounce)\s+(\S+)/g)) {
+    mods[m[1]] = m[2];
+  }
+  return mods;
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var ComponentParser, ComponentGenerator;
+var init_component = __esm({
+  "src/transpiler/component.ts"() {
+    init_cjs_shims();
+    init_helpers();
+    ComponentParser = class {
+      name;
+      inner;
+      signals = {};
+      computed = {};
+      shared = {};
+      configBody = null;
+      watches = {};
+      remotes = {};
+      invokes = {};
+      keybinds = [];
+      events = [];
+      localFuncs = [];
+      funcs = [];
+      handlers = [];
+      initBody = null;
+      respawnBody = null;
+      uiWidgets = [];
+      constructor(inner, name) {
+        this.inner = inner;
+        this.name = name;
+      }
+      parse() {
+        const text2 = this.inner;
+        let i = 0;
+        while (i < text2.length) {
+          if (" 	\r\n".includes(text2[i])) {
+            i++;
+            continue;
+          }
+          let m;
+          m = text2.slice(i).match(/^signal\s+(\w+)\s*=\s*/);
+          if (m) {
+            const nameI = i + m[0].length;
+            const endI = text2.indexOf("\n", nameI) === -1 ? text2.length : text2.indexOf("\n", nameI);
+            this.signals[m[1]] = text2.slice(nameI, endI).trim().replace(/,$/, "");
+            i = endI;
+            continue;
+          }
+          m = text2.slice(i).match(/^computed\s+(\w+)\s*=\s*/);
+          if (m) {
+            const nameI = i + m[0].length;
+            const endI = text2.indexOf("\n", nameI) === -1 ? text2.length : text2.indexOf("\n", nameI);
+            this.computed[m[1]] = text2.slice(nameI, endI).trim().replace(/,$/, "");
+            i = endI;
+            continue;
+          }
+          m = text2.slice(i).match(/^config\s*\{/);
+          if (m) {
+            const [body, end] = extractBlock(text2, i + m[0].length);
+            this.configBody = body.trim();
+            i = end;
+            continue;
+          }
+          m = text2.slice(i).match(/^watch\s*\{/);
+          if (m) {
+            const [body, end] = extractBlock(text2, i + m[0].length);
+            for (const line of body.split("\n")) {
+              const wm = line.match(/^\s*(\w+)\s*=\s*(.+),?\s*$/);
+              if (wm) this.watches[wm[1]] = wm[2].trim().replace(/,$/, "");
+            }
+            i = end;
+            continue;
+          }
+          m = text2.slice(i).match(/^shared\s*\{/);
+          if (m) {
+            const [body, end] = extractBlock(text2, i + m[0].length);
+            for (const line of body.split("\n")) {
+              const sm = line.match(/^\s*(\w+)\s*=\s*(.+),?\s*$/);
+              if (sm) this.shared[sm[1]] = sm[2].trim().replace(/,$/, "");
+            }
+            i = end;
+            continue;
+          }
+          m = text2.slice(i).match(/^invoke\s+(\w+)\s*=\s*["']([^"']+)["']/);
+          if (m) {
+            this.invokes[m[1]] = m[2];
+            i += m[0].length;
+            continue;
+          }
+          m = text2.slice(i).match(/^remote\s+(\w+)\s*=\s*["']([^"']+)["']/);
+          if (m) {
+            this.remotes[m[1]] = m[2];
+            i += m[0].length;
+            continue;
+          }
+          m = text2.slice(i).match(/^keybind\s+(\S+)\s*(?:→|->)\s*(\w+)/);
+          if (m) {
+            this.keybinds.push([m[1], m[2], "toggle"]);
+            i += m[0].length;
+            continue;
+          }
+          m = text2.slice(i).match(/^event\s+(\w+)/);
+          if (m) {
+            this.events.push(m[1]);
+            i += m[0].length;
+            continue;
+          }
+          m = text2.slice(i).match(/^local\s+func\s+(\w+)\s*\(([^)]*)\)\s*\{/);
+          if (m) {
+            const [body, end] = extractBlock(text2, i + m[0].length);
+            this.localFuncs.push([m[1], m[2].trim(), body]);
+            i = end;
+            continue;
+          }
+          m = text2.slice(i).match(/^func\s+(\w+)\s*\(([^)]*)\)\s*\{/);
+          if (m) {
+            const [body, end] = extractBlock(text2, i + m[0].length);
+            this.funcs.push([m[1], m[2].trim(), body]);
+            i = end;
+            continue;
+          }
+          m = text2.slice(i).match(/^ui\s*\{/);
+          if (m) {
+            const [body, end] = extractBlock(text2, i + m[0].length);
+            this.uiWidgets = parseUiWidgets(body, this.name);
+            i = end;
+            continue;
+          }
+          m = text2.slice(i).match(/^init\s*\{/);
+          if (m) {
+            const [body, end] = extractBlock(text2, i + m[0].length);
+            this.initBody = body;
+            i = end;
+            continue;
+          }
+          m = text2.slice(i).match(/^on\s+Respawn\s*\{/);
+          if (m) {
+            const [body, end] = extractBlock(text2, i + m[0].length);
+            this.respawnBody = body;
+            i = end;
+            continue;
+          }
+          m = text2.slice(i).match(/^on\s+(\w+)(?:\(([^)]*)\))?((?:\s+(?:when|every|debounce)\s+\S+)*)\s*\{/);
+          if (m) {
+            const mods = parseModifiers(m[3] ?? "");
+            const [body, end] = extractBlock(text2, i + m[0].length);
+            this.handlers.push({ event: m[1], params: (m[2] ?? "").trim(), mods, body });
+            i = end;
+            continue;
+          }
+          m = text2.slice(i).match(/^after\s+(\S+)\s*\{/);
+          if (m) {
+            const [body, end] = extractBlock(text2, i + m[0].length);
+            this.handlers.push({ event: "__after__", params: m[1], mods: {}, body });
+            i = end;
+            continue;
+          }
+          i++;
+        }
+      }
+    };
+    ComponentGenerator = class {
+      p;
+      name;
+      src;
+      constructor(parser, sourcePath) {
+        this.p = parser;
+        this.name = parser.name;
+        this.src = sourcePath;
+      }
+      generate() {
+        const p = this.p;
+        const name = this.name;
+        const lines = [];
+        lines.push(`-- [transpiled from ${this.src}]`);
+        lines.push(`${name} = Component("${name}")`);
+        for (const [sig, def] of Object.entries(p.signals)) {
+          lines.push(`${name}.${sig} = Signal(${def})`);
+        }
+        if ("enabled" in p.signals) {
+          lines.push(`${name}.onEnable  = PulseEvent("${name}.onEnable")`);
+          lines.push(`${name}.onDisable = PulseEvent("${name}.onDisable")`);
+        }
+        for (const [cname, expr] of Object.entries(p.computed)) {
+          lines.push(`${name}.${cname} = Computed(function() return ${expr} end)`);
+        }
+        for (const ev of p.events) {
+          lines.push(`${name}.${ev} = PulseEvent("${name}.${ev}")`);
+        }
+        lines.push("");
+        if ("enabled" in p.signals) {
+          lines.push(`${name}.enabled:onChange(function(v)`);
+          lines.push(`    if v then ${name}.onEnable:fire() else ${name}.onDisable:fire() end`);
+          lines.push("end)");
+          lines.push("");
+        }
+        lines.push(`local function _setup_${name}()`);
+        if (p.configBody) {
+          lines.push("    local cfg = {");
+          for (const ln of p.configBody.split("\n")) lines.push("        " + ln.trim());
+          lines.push("    }");
+          lines.push("");
+        }
+        const mirrorNames = {};
+        const watchNames = {};
+        const usedSignals = this.signalsUsedInHandlers();
+        for (const sig of Object.keys(p.signals)) {
+          if (usedSignals.has(sig)) {
+            const v = `_m_${sig}`;
+            mirrorNames[sig] = v;
+            lines.push(`    local ${v} = ${p.signals[sig]}`);
+            lines.push(`    ${name}:watch(${name}.${sig}, function(v) ${v} = v end)`);
+          }
+        }
+        if (Object.keys(mirrorNames).length) lines.push("");
+        for (const wname of Object.keys(p.watches)) {
+          watchNames[wname] = `_w_${wname}`;
+          lines.push(`    local _w_${wname} = nil`);
+        }
+        if (Object.keys(p.watches).length) {
+          lines.push("    local function _refreshWatches()");
+          lines.push('        local _char = game:GetService("Players").LocalPlayer.Character');
+          for (const [wname, expr] of Object.entries(p.watches)) {
+            lines.push(`        ${watchNames[wname]} = ${watchExprToLua(expr, "_char")}`);
+          }
+          lines.push("    end");
+          lines.push("    _refreshWatches()");
+          lines.push(`    ${name}:onRespawn(_refreshWatches)`);
+          lines.push("");
+        }
+        for (const [rname, path] of Object.entries(p.remotes)) {
+          lines.push(`    local _r_${rname} = ${remotePathToChain(path)}`);
+          lines.push(`    local function ${rname}(...) _r_${rname}:FireServer(...) end`);
+        }
+        if (Object.keys(p.remotes).length) lines.push("");
+        for (const [iname, path] of Object.entries(p.invokes)) {
+          lines.push(`    local _i_${iname} = ${remotePathToChain(path)}`);
+          lines.push(`    local function ${iname}(...) return _i_${iname}:InvokeServer(...) end`);
+        }
+        if (Object.keys(p.invokes).length) lines.push("");
+        for (let idx = 0; idx < p.keybinds.length; idx++) {
+          const [keycode, sigName, action] = p.keybinds[idx];
+          const dbVar = `_kb_db_${idx}`;
+          const bindKey = `_keybind_${idx}`;
+          lines.push(`    local ${dbVar} = false`);
+          lines.push(`    ${name}:bind("${bindKey}", _PulseUIS.InputBegan:Connect(function(input, gpe)`);
+          lines.push(`        if gpe then return end`);
+          lines.push(`        if input.KeyCode ~= ${keycode} then return end`);
+          lines.push(`        if ${dbVar} then return end`);
+          lines.push(`        ${dbVar} = true`);
+          if (action === "toggle") lines.push(`        ${name}.${sigName}(not ${name}.${sigName}())`);
+          lines.push(`        task.delay(${DEFAULT_DEBOUNCE}, function() ${dbVar} = false end)`);
+          lines.push("    end))");
+          lines.push("");
+        }
+        if (p.initBody) {
+          lines.push("    -- init");
+          for (const ln of p.initBody.split("\n")) lines.push("    " + ln.trimEnd());
+          lines.push("");
+        }
+        for (const [lfname, lfparams, lfbody] of p.localFuncs) {
+          lines.push(`    local function ${lfname}(${lfparams})`);
+          for (const ln of this.rewriteBody(lfbody, mirrorNames, watchNames).split("\n")) {
+            lines.push("        " + ln.trimEnd());
+          }
+          lines.push("    end");
+          lines.push("");
+        }
+        const funcMirrors = {};
+        for (const sig of Object.keys(p.signals)) funcMirrors[sig] = `${name}.${sig}()`;
+        for (const [fname, fparams, fbody] of p.funcs) {
+          const paramStr = fparams ? `, ${fparams}` : "";
+          lines.push(`    ${name}.${fname} = function(self${paramStr})`);
+          for (const ln of this.rewriteBody(fbody, funcMirrors, watchNames).split("\n")) {
+            lines.push("        " + ln.trimEnd());
+          }
+          lines.push("    end");
+          lines.push("");
+        }
+        if ("enabled" in p.signals && !p.funcs.some(([fn]) => fn === "Toggle")) {
+          lines.push(`    ${name}.Toggle = function(self)`);
+          lines.push(`        ${name}.enabled(not ${name}.enabled())`);
+          lines.push(`    end`);
+          lines.push("");
+        }
+        for (const { event, params, mods, body } of p.handlers) {
+          if (event === "__after__") {
+            lines.push(`    ${name}:task(${params}, function()`);
+            for (const ln of this.rewriteBody(body, mirrorNames, watchNames).split("\n")) {
+              lines.push("        " + ln.trimEnd());
+            }
+            lines.push("    end)");
+            lines.push("");
+            continue;
+          }
+          if (event === "Respawn") continue;
+          if (event in p.signals) {
+            lines.push(`    ${name}:watch(${name}.${event}, function(v)`);
+            for (const ln of this.rewriteBody(body, mirrorNames, watchNames).split("\n")) {
+              lines.push("        " + ln.trimEnd());
+            }
+            lines.push("    end)");
+            lines.push("");
+            continue;
+          }
+          const serviceEvent = EVENT_MAP[event];
+          if (!serviceEvent) {
+            lines.push(`    -- [Pulse] WARNING: unknown event '${event}' \u2014 skipped`);
+            continue;
+          }
+          const bindKey = `on${event}`;
+          const paramStr = params || "_";
+          const debounce = mods["debounce"];
+          const when = mods["when"];
+          const everyVal = mods["every"];
+          const everyThreshold = everyVal && everyVal in p.signals ? mirrorNames[everyVal] ?? `${name}.${everyVal}()` : everyVal;
+          if (debounce) lines.push(`    local _db_${event} = false`);
+          if (everyVal) lines.push(`    local _thr_${event} = 0`);
+          lines.push(`    ${name}:bind("${bindKey}", ${serviceEvent}:Connect(function(${paramStr})`);
+          if (debounce) {
+            lines.push(`        if _db_${event} then return end`);
+            lines.push(`        _db_${event} = true`);
+          }
+          if (when) {
+            const whenVar = mirrorNames[when] ?? when;
+            lines.push(`        if not ${whenVar} then return end`);
+          }
+          if (everyVal) {
+            lines.push(`        local _now = tick()`);
+            lines.push(`        if (_now - _thr_${event}) < ${everyThreshold} then return end`);
+            lines.push(`        _thr_${event} = _now`);
+          }
+          lines.push(`        local _ok, _err = pcall(function()`);
+          for (const ln of this.rewriteBody(body, mirrorNames, watchNames).split("\n")) {
+            lines.push("            " + ln.trimEnd());
+          }
+          lines.push(`        end)`);
+          lines.push(`        if not _ok then Pulse.Log.error("${name}", "${event} error", { err = tostring(_err) }) end`);
+          if (debounce) lines.push(`        task.delay(${debounce}, function() _db_${event} = false end)`);
+          lines.push("    end))");
+          lines.push("");
+        }
+        if (p.respawnBody) {
+          lines.push(`    ${name}:onRespawn(function()`);
+          for (const ln of this.rewriteBody(p.respawnBody, mirrorNames, watchNames).split("\n")) {
+            lines.push("        " + ln.trimEnd());
+          }
+          lines.push("    end)");
+          lines.push("");
+        }
+        lines.push("end");
+        for (const [key, def] of Object.entries(p.shared)) {
+          lines.push(`Pulse.Store.define("${key}", ${def})`);
+        }
+        if (Object.keys(p.shared).length) lines.push("");
+        lines.push(`_setup_${name}()`);
+        lines.push("");
+        const uiLines = this.generateUiTable();
+        if (uiLines.length) {
+          lines.push(...uiLines);
+          lines.push("");
+        }
+        const defaultLines = this.generateDefaultsBlock();
+        if (defaultLines.length) {
+          lines.push(...defaultLines);
+          lines.push("");
+        }
+        return lines.join("\n");
+      }
+      generateUiTable() {
+        const { uiWidgets: ws } = this.p;
+        if (!ws.length) return [];
+        const name = this.name;
+        const lines = [`${name}._ui = {`];
+        for (const w of ws) {
+          switch (w.type) {
+            case "separator":
+              lines.push('    { type = "separator" },');
+              break;
+            case "label":
+              lines.push(`    { type = "label", label = "${w.label}" },`);
+              break;
+            case "toggle":
+              lines.push(`    { type = "toggle", id = "${w.id}", label = "${w.label}", signal = "${w.signal}", tip = "${w.tip}" },`);
+              break;
+            case "slider":
+              lines.push(`    { type = "slider", id = "${w.id}", label = "${w.label}", signal = "${w.signal}", min = ${w.min}, max = ${w.max}, tip = "${w.tip}" },`);
+              break;
+            case "dropdown":
+              lines.push(`    { type = "dropdown", id = "${w.id}", label = "${w.label}", signal = "${w.signal}", options = ${w.options}, tip = "${w.tip}" },`);
+              break;
+            case "multidropdown":
+              lines.push(`    { type = "multidropdown", id = "${w.id}", label = "${w.label}", signal = "${w.signal}", options = ${w.options}, tip = "${w.tip}" },`);
+              break;
+            case "button":
+              lines.push(`    { type = "button", label = "${w.label}", action = function() ${name}:${w.func}() end, tip = "${w.tip}" },`);
+              break;
+            case "keybind":
+              lines.push(`    { type = "keybind", id = "${w.id}", label = "${w.label}", key = "${w.key}", action = function() ${name}:${w.func}() end },`);
+              break;
+          }
+        }
+        lines.push("}");
+        return lines;
+      }
+      generateDefaultsBlock() {
+        const lines = [];
+        for (const w of this.p.uiWidgets) {
+          if (!("default" in w) || !["toggle", "slider", "dropdown"].includes(w.type)) continue;
+          const kind = w.type === "toggle" ? "toggle" : "option";
+          lines.push(
+            `_PULSE_DEFAULTS[#_PULSE_DEFAULTS+1] = { type="${kind}", id="${w.id}", value=${w.default}, set=function(v) ${this.name}.${w.signal}(v) end }`
+          );
+        }
+        return lines;
+      }
+      // ── Body rewriting ──────────────────────────────────────────────────────────
+      signalsUsedInHandlers() {
+        const used = /* @__PURE__ */ new Set();
+        for (const { mods } of this.p.handlers) {
+          for (const key of ["when", "every"]) {
+            const val = mods[key];
+            if (val && val in this.p.signals) used.add(val);
+          }
+        }
+        const allBodies = [
+          ...this.p.handlers.map((h) => h.body),
+          this.p.initBody ?? "",
+          this.p.respawnBody ?? "",
+          ...this.p.localFuncs.map(([, , b]) => b)
+        ].join("\n");
+        for (const sig of Object.keys(this.p.signals)) {
+          if (new RegExp(`\\b${escapeRe(sig)}\\b`).test(allBodies)) used.add(sig);
+        }
+        return used;
+      }
+      rewriteBody(body, mirrors, watches) {
+        return body.split("\n").map((ln) => this.rewriteLine(ln, mirrors, watches)).join("\n");
+      }
+      rewriteLine(line, mirrors, watches) {
+        const stripped = line.trimStart();
+        const indent = line.slice(0, line.length - stripped.length);
+        let m = stripped.match(/^guard\s+(\w+)\s*=\s*(.+)$/);
+        if (m) {
+          const expr = this.rewriteExpr(m[2].trim(), mirrors, watches);
+          return `${indent}local ${m[1]} = ${expr}
+${indent}if not ${m[1]} then return end`;
+        }
+        m = stripped.match(/^guard\s+(.+)$/);
+        if (m) {
+          const expr = this.rewriteExpr(m[1].trim(), mirrors, watches);
+          return /^\w+$/.test(expr) ? `${indent}if not ${expr} then return end` : `${indent}if not (${expr}) then return end`;
+        }
+        return this.rewriteExpr(line, mirrors, watches);
+      }
+      rewriteExpr(text2, mirrors, watches) {
+        text2 = text2.replace(/\bself\b/g, this.name);
+        for (const [ref, replacement] of Object.entries(CHAR_REFS)) {
+          text2 = text2.replace(new RegExp(`\\b${escapeRe(ref)}\\b`, "g"), replacement);
+        }
+        for (const [wname, wvar] of Object.entries(watches)) {
+          text2 = text2.replace(new RegExp(`\\b${escapeRe(wname)}\\b`, "g"), wvar);
+        }
+        for (const [sig, mvar] of Object.entries(mirrors)) {
+          text2 = text2.replace(new RegExp(`(?<!\\.)\\b${escapeRe(sig)}\\s*\\(`, "g"), `${this.name}.${sig}(`);
+          text2 = text2.replace(new RegExp(`(?<!\\.)\\b${escapeRe(sig)}\\b(?!\\s*\\()`, "g"), mvar);
+        }
+        return text2;
+      }
+    };
+  }
+});
+
+// src/transpiler/layout.ts
+function findLayoutBlock(src) {
+  const m = src.match(/\blayout\s*\{/);
+  if (!m || m.index === void 0) return [null, -1, -1];
+  const [inner, end] = extractBlock(src, m.index + m[0].length);
+  return [inner, m.index + m[0].length, end];
+}
+function parseLayoutOptions(body) {
+  const opts = {
+    title: "Script Hub",
+    toggle_key: "RightControl",
+    size: [950, 600],
+    compat_exclude: [],
+    ui_library: "linoria",
+    theme: "Dark",
+    folder: "Hub",
+    notify_title: "Hub",
+    icon: "",
+    author: "",
+    transparency: 0.8,
+    acrylic: false,
+    themes: [],
+    open_button_mobile_only: true,
+    open_button_icon: ""
+  };
+  const compatM = body.match(/compat_exclude\s*=\s*\{([^}]*)\}/s);
+  if (compatM) opts.compat_exclude = [...compatM[1].matchAll(/"([^"]+)"/g)].map((m) => m[1]);
+  const themesM = body.match(/\bthemes\s*=\s*\{/);
+  if (themesM) {
+    const [themesInner] = extractBlock(body, themesM.index + themesM[0].length);
+    const themesCode = themesInner.split("\n").filter((ln) => !ln.trim().startsWith("--")).join("\n");
+    let pos = 0;
+    while (pos < themesCode.length) {
+      const eM = themesCode.slice(pos).match(/\{/);
+      if (!eM) break;
+      const entryStart = pos + eM.index + 1;
+      const [entryInner, entryEnd] = extractBlock(themesCode, entryStart);
+      const tData = {};
+      for (let raw of entryInner.split("\n")) {
+        let ln = raw.trim().replace(/,$/, "");
+        const ci = ln.indexOf("--");
+        if (ci >= 0) ln = ln.slice(0, ci).trim();
+        const kv = ln.match(/^(\w+)\s*=\s*"([^"]*)"/);
+        if (kv) tData[kv[1]] = kv[2];
+      }
+      if (tData["name"]) opts.themes.push(tData);
+      pos = entryEnd;
+    }
+  }
+  for (let raw of body.split("\n")) {
+    let line = raw.trim();
+    const ci = line.indexOf("--");
+    if (ci >= 0) line = line.slice(0, ci).trim();
+    line = line.replace(/,$/, "");
+    if (!line) continue;
+    const m = line.match(/^(\w+)\s*=\s*(.+)$/);
+    if (!m) continue;
+    const [, key, val] = m;
+    switch (key) {
+      case "title": {
+        const stripped = val.replace(/^["']|["']$/g, "");
+        if (stripped !== val) opts.title = stripped;
+        else opts.title_expr = val;
+        break;
+      }
+      case "toggle_key":
+        opts.toggle_key = val.replace(/^["']|["']$/g, "");
+        break;
+      case "size": {
+        const nums = [...val.matchAll(/\d+/g)].map((m2) => parseInt(m2[0]));
+        if (nums.length >= 2) opts.size = [nums[0], nums[1]];
+        break;
+      }
+      case "ui_library": {
+        const lib = val.replace(/^["']|["']$/g, "");
+        if (lib === "linoria" || lib === "windui") opts.ui_library = lib;
+        break;
+      }
+      case "theme":
+        opts.theme = val.replace(/^["']|["']$/g, "");
+        break;
+      case "folder":
+        opts.folder = val.replace(/^["']|["']$/g, "");
+        break;
+      case "notify_title":
+        opts.notify_title = val.replace(/^["']|["']$/g, "");
+        break;
+      case "icon":
+        opts.icon = val.replace(/^["']|["']$/g, "");
+        break;
+      case "author":
+        opts.author = val.replace(/^["']|["']$/g, "");
+        break;
+      case "transparency": {
+        const n = parseFloat(val);
+        if (!isNaN(n)) opts.transparency = n;
+        break;
+      }
+      case "acrylic":
+        opts.acrylic = val.trim().toLowerCase() === "true";
+        break;
+      case "open_button_mobile_only":
+        opts.open_button_mobile_only = val.trim().toLowerCase() !== "false";
+        break;
+      case "open_button_icon":
+        opts.open_button_icon = val.replace(/^["']|["']$/g, "");
+        break;
+    }
+  }
+  return opts;
+}
+function transpileLayout(source, filePath) {
+  const [inner] = findLayoutBlock(source);
+  if (inner === null) throw new TranspileError(`${filePath}: no 'layout {}' block found.`);
+  const opts = parseLayoutOptions(inner);
+  const { toggle_key, folder, notify_title, icon, author, transparency, themes } = opts;
+  const [w, h] = opts.size;
+  const acrylic = opts.acrylic ? "true" : "false";
+  const openMobileOnly = opts.open_button_mobile_only ? "true" : "false";
+  const titleCode = opts.title_expr ?? `"${opts.title}"`;
+  const L = [];
+  L.push(`-- [transpiled from ${filePath}]`);
+  L.push(`local _PULSE_FOLDER        = "${folder}"`);
+  L.push(`local _PULSE_NOTIFY_TITLE  = "${notify_title}"`);
+  L.push(`local _PULSE_TOGGLE_KEY    = "${toggle_key}"`);
+  L.push(`local _PULSE_DEFAULT_THEME = "${opts.theme}"`);
+  L.push(`local _PULSE_ICON          = "${icon}"`);
+  L.push(`local _PULSE_AUTHOR        = "${author}"`);
+  L.push(`local _PULSE_TRANSPARENCY  = ${transparency}`);
+  L.push(`local _PULSE_ACRYLIC       = ${acrylic}`);
+  L.push(`local _PULSE_OPEN_BTN_MOBILE_ONLY = ${openMobileOnly}`);
+  L.push(`local _PULSE_OPEN_BTN_ICON        = "${opts.open_button_icon}"`);
+  for (const t of themes) {
+    const pairs = [`    name = "${t["name"]}"`];
+    for (const fld of THEME_FIELDS) {
+      if (t[fld]) pairs.push(`    ${fld} = "${t[fld]}"`);
+    }
+    L.push("_UIAdapter:RegisterTheme({");
+    L.push(pairs.join(",\n"));
+    L.push("})");
+  }
+  L.push(`local _Window = _UIAdapter:CreateWindow(${titleCode}, ${w}, ${h}, {`);
+  L.push(`    theme        = _PULSE_DEFAULT_THEME,`);
+  L.push(`    folder       = _PULSE_FOLDER,`);
+  L.push(`    notify_title = _PULSE_NOTIFY_TITLE,`);
+  L.push(`    icon         = _PULSE_ICON,`);
+  L.push(`    author       = _PULSE_AUTHOR,`);
+  L.push(`    transparency          = _PULSE_TRANSPARENCY,`);
+  L.push(`    acrylic               = _PULSE_ACRYLIC,`);
+  L.push(`    open_btn_mobile_only  = _PULSE_OPEN_BTN_MOBILE_ONLY,`);
+  L.push(`    open_btn_icon         = _PULSE_OPEN_BTN_ICON,`);
+  L.push(`})`);
+  L.push(`local _Tabs      = {}`);
+  L.push(`local _TabGroups = {}`);
+  L.push(``);
+  L.push(`local function _GetTab(name, icon)`);
+  L.push(`    if not _Tabs[name] then`);
+  L.push(`        _Tabs[name] = _Window:AddTab(name, icon)`);
+  L.push(`    end`);
+  L.push(`    return _Tabs[name]`);
+  L.push(`end`);
+  L.push(``);
+  L.push(`local function _GetGroupbox(tab, side, title_, icon)`);
+  L.push(`    local key = tab .. "|" .. side .. "|" .. title_`);
+  L.push(`    if not _TabGroups[key] then`);
+  L.push(`        local t = _GetTab(tab)`);
+  L.push(`        if side == "left" then`);
+  L.push(`            _TabGroups[key] = t:AddLeftGroupbox(title_, icon)`);
+  L.push(`        else`);
+  L.push(`            _TabGroups[key] = t:AddRightGroupbox(title_, icon)`);
+  L.push(`        end`);
+  L.push(`    end`);
+  L.push(`    return _TabGroups[key]`);
+  L.push(`end`);
+  L.push(``);
+  L.push(`_UIAdapter:SetToggleKey(Enum.KeyCode.${toggle_key})`);
+  return L.join("\n");
+}
+var THEME_FIELDS;
+var init_layout = __esm({
+  "src/transpiler/layout.ts"() {
+    init_cjs_shims();
+    init_helpers();
+    init_transpiler();
+    THEME_FIELDS = ["accent", "background", "outline", "text", "placeholder", "button", "icon"];
+  }
+});
+
+// src/transpiler/page.ts
+function findPageBlock(src) {
+  let m = src.match(/\bpage\s+"([^"]+)"\s+icon="([^"]+)"\s*\{/);
+  if (m && m.index !== void 0) {
+    const [inner, end] = extractBlock(src, m.index + m[0].length);
+    return [m[1], m[2], inner, m.index + m[0].length, end];
+  }
+  m = src.match(/\bpage\s+"([^"]+)"\s*\{/);
+  if (m && m.index !== void 0) {
+    const [inner, end] = extractBlock(src, m.index + m[0].length);
+    return [m[1], null, inner, m.index + m[0].length, end];
+  }
+  return [null, null, null, -1, -1];
+}
+function transpilePage(source, filePath) {
+  const [tabName, tabIcon, inner] = findPageBlock(source);
+  if (inner === null) throw new TranspileError(`${filePath}: no 'page "Name" icon="..." {}' block found.`);
+  if (tabIcon === null) {
+    throw new TranspileError(
+      `${filePath}: page "${tabName}" is missing a tab icon.
+  Fix: page "${tabName}" icon="house" { ... }
+  Use any Lucide icon name (e.g. "house", "swords", "pickaxe", "coins", "map-pin")`
+    );
+  }
+  const L = [`-- [transpiled from ${filePath}]`, "do"];
+  L.push(...transpilePageBody(tabName, tabIcon, inner, filePath));
+  L.push("end");
+  return L.join("\n");
+}
+function transpilePageBody(tabName, tabIcon, body, filePath) {
+  const lines = [];
+  lines.push(`    _GetTab("${tabName}", "${tabIcon}")`);
+  let i = 0;
+  while (i < body.length) {
+    if (" 	\r\n".includes(body[i])) {
+      i++;
+      continue;
+    }
+    let m = body.slice(i).match(/^groupbox\s+(left|right)\s+"([^"]+)"\s+icon="([^"]+)"\s*\{/);
+    if (m) {
+      const [side, title, icon] = [m[1], m[2], m[3]];
+      const gbVar = "_gb_" + title.replace(/[^a-zA-Z0-9]/g, "_");
+      const [gbBody, end] = extractBlock(body, i + m[0].length);
+      lines.push(`    local ${gbVar} = _GetGroupbox("${tabName}", "${side}", "${title}", "${icon}")`);
+      lines.push(...transpileGroupboxBody(gbBody, gbVar, "    "));
+      i = end;
+      continue;
+    }
+    m = body.slice(i).match(/^groupbox\s+(left|right)\s+"([^"]+)"\s*\{/);
+    if (m) {
+      throw new TranspileError(
+        `${filePath}: groupbox "${m[2]}" in page "${tabName}" is missing an icon.
+  Fix: groupbox ${m[1]} "${m[2]}" icon="eye" { ... }
+  Use any Lucide icon name (e.g. "eye", "crosshair", "pickaxe", "hammer", "coins")`
+      );
+    }
+    i++;
+  }
+  return lines;
+}
+function transpileGroupboxBody(body, gbVar, indent) {
+  const lines = [];
+  for (const raw of body.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("--")) continue;
+    let m = line.match(/^mount\s+(\w+)$/);
+    if (m) {
+      lines.push(`${indent}_UIAdapter:mount(${m[1]}, ${gbVar})`);
+      continue;
+    }
+    if (line === "separator") {
+      lines.push(`${indent}_UIAdapter:addSeparator(${gbVar})`);
+      continue;
+    }
+    m = line.match(/^label\s+"([^"]+)"$/);
+    if (m) {
+      lines.push(`${indent}_UIAdapter:addLabel(${gbVar}, "${m[1]}")`);
+      continue;
+    }
+    m = line.match(/^paragraph\s+"([^"]+)"\s+"([^"]*)"$/);
+    if (m) {
+      lines.push(`${indent}_UIAdapter:addParagraph(${gbVar}, "${m[1]}", "${m[2]}")`);
+      continue;
+    }
+    m = line.match(/^toggle\s+"([^"]+)"\s+->\s+(\w+)\.(\w+)(?:\s+tip="([^"]*)")?$/);
+    if (m) {
+      lines.push(`${indent}_UIAdapter:addToggle(${gbVar}, "${m[2]}_${m[3]}", { label = "${m[1]}", signal = ${m[2]}.${m[3]}, tip = "${m[4] ?? ""}" })`);
+      continue;
+    }
+    m = line.match(/^slider\s+"([^"]+)"\s+->\s+(\w+)\.(\w+)\s+\[([^\],]+),\s*([^\]]+)\](?:\s+tip="([^"]*)")?$/);
+    if (m) {
+      lines.push(`${indent}_UIAdapter:addSlider(${gbVar}, "${m[2]}_${m[3]}", { label = "${m[1]}", signal = ${m[2]}.${m[3]}, min = ${m[4].trim()}, max = ${m[5].trim()}, tip = "${m[6] ?? ""}" })`);
+      continue;
+    }
+    m = line.match(/^dropdown\s+"([^"]+)"\s+->\s+(\w+)\.(\w+)\s+(\[[^\]]+\])(?:\s+tip="([^"]*)")?$/);
+    if (m) {
+      const opts = "{" + m[4].slice(1, -1) + "}";
+      lines.push(`${indent}_UIAdapter:addDropdown(${gbVar}, "${m[2]}_${m[3]}", { label = "${m[1]}", signal = ${m[2]}.${m[3]}, options = ${opts}, tip = "${m[5] ?? ""}" })`);
+      continue;
+    }
+    m = line.match(/^button\s+"([^"]+)"\s+->\s+(\w+):(\w+)\(\)(?:\s+tip="([^"]*)")?$/);
+    if (m) {
+      lines.push(`${indent}_UIAdapter:addButton(${gbVar}, { label = "${m[1]}", action = function() ${m[2]}:${m[3]}() end, tip = "${m[4] ?? ""}" })`);
+      continue;
+    }
+    m = line.match(/^keybind\s+"([^"]+)"\s+key="([^"]+)"\s+->\s+(\w+):(\w+)\(\)$/);
+    if (m) {
+      lines.push(`${indent}_UIAdapter:addKeybind(${gbVar}, "${m[3]}_${m[4]}_kb", { label = "${m[1]}", key = "${m[2]}", action = function() ${m[3]}:${m[4]}() end })`);
+      continue;
+    }
+  }
+  return lines;
+}
+var init_page = __esm({
+  "src/transpiler/page.ts"() {
+    init_cjs_shims();
+    init_helpers();
+    init_transpiler();
+  }
+});
+function transpile(source, filePath) {
+  if (/\bpage\s+"[^"]+"/.test(source)) return transpilePage(source, filePath);
+  if (/\blayout\s*\{/.test(source)) return transpileLayout(source, filePath);
+  const [inner] = findComponentBlock(source);
+  if (inner === null) {
+    throw new TranspileError(
+      `${filePath}: no recognised top-level block found.
+  Expected: component { }, layout { }, or page "Name" { }`
+    );
+  }
+  const stem = path.basename(filePath, ".rblua");
+  const name = stem[0].toUpperCase() + stem.slice(1);
+  const parser = new ComponentParser(inner, name);
+  parser.parse();
+  return new ComponentGenerator(parser, filePath).generate();
+}
+var TranspileError;
+var init_transpiler = __esm({
+  "src/transpiler/index.ts"() {
+    init_cjs_shims();
+    init_component();
+    init_layout();
+    init_page();
+    TranspileError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "TranspileError";
+      }
+    };
+  }
+});
+
+// src/commands/publish.ts
+var publish_exports = {};
+__export(publish_exports, {
+  cmdPublish: () => cmdPublish,
+  hasCdnConfig: () => hasCdnConfig,
+  readPublishConfig: () => readPublishConfig
+});
+function readPublishConfig() {
+  for (const p of CONFIG_CANDIDATES) {
+    if (!fs.existsSync(p)) continue;
+    const config = {};
+    for (const line of fs.readFileSync(p, "utf8").split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq < 0) continue;
+      const key = trimmed.slice(0, eq).trim();
+      config[key] = trimmed.slice(eq + 1).trim();
+    }
+    return config;
+  }
+  return {};
+}
+function hasCdnConfig(projectRoot) {
+  const candidates = projectRoot ? [pathe.join(projectRoot, ".rb-publish"), ...CONFIG_CANDIDATES] : CONFIG_CANDIDATES;
+  for (const p of candidates) {
+    if (!fs.existsSync(p)) continue;
+    const content = fs.readFileSync(p, "utf8");
+    if (content.includes("R2_ACCOUNT_ID") && content.includes("R2_SECRET_TOKEN") && content.includes("R2_PUBLIC_URL")) return true;
+  }
+  return false;
+}
+async function uploadFile(content, remotePath, config) {
+  const url = `https://api.cloudflare.com/client/v4/accounts/${config.R2_ACCOUNT_ID}/r2/buckets/${config.R2_BUCKET}/objects/${remotePath}`;
+  await ofetch.ofetch(url, {
+    method: "PUT",
+    body: content,
+    headers: {
+      Authorization: `Bearer ${config.R2_SECRET_TOKEN}`,
+      "Content-Type": remotePath.endsWith(".lua") ? "text/plain; charset=utf-8" : "application/octet-stream"
+    }
+  });
+  return `${config.R2_PUBLIC_URL}/${remotePath}`;
+}
+async function cmdPublish(_args) {
+  pHeader("publish");
+  const config = readPublishConfig();
+  const missing = ["R2_ACCOUNT_ID", "R2_SECRET_TOKEN", "R2_BUCKET", "R2_PUBLIC_URL"].filter((k) => !config[k]);
+  if (missing.length) {
+    pFail("R2 credentials not configured");
+    console.log();
+    pInfo(`Create ${bold(".rb-publish")} in your project root (or ~/.rb-publish):`);
+    console.log();
+    console.log(`    ${dim("R2_ACCOUNT_ID")}=your_cloudflare_account_id`);
+    console.log(`    ${dim("R2_SECRET_TOKEN")}=cfat_your_api_token`);
+    console.log(`    ${dim("R2_BUCKET")}=pulse-runtime`);
+    console.log(`    ${dim("R2_PUBLIC_URL")}=https://pub-xxxx.r2.dev`);
+    console.log();
+    pInfo(`Get your token at: ${cyan("dash.cloudflare.com \u2192 R2 \u2192 Manage API Tokens")}`);
+    process.exit(1);
+  }
+  const PULSE_DIR2 = pathe.join(__dirname, "..", "pulse");
+  const ADAPTERS = pathe.join(__dirname, "..", "adapters");
+  const VERSION_PATH = `v${RB_VERSION}`;
+  const runtimeFile = pathe.join(PULSE_DIR2, "runtime.lua");
+  const helpersDir = pathe.join(PULSE_DIR2, "helpers");
+  if (!fs.existsSync(runtimeFile)) {
+    pFail("pulse/runtime.lua not found");
+    process.exit(1);
+  }
+  const bundleParts = [
+    `-- Pulse v${RB_VERSION} bundle (runtime + helpers)`,
+    fs.readFileSync(runtimeFile, "utf8").trimEnd()
+  ];
+  if (fs.existsSync(helpersDir)) {
+    for (const f of fs.readdirSync(helpersDir).filter((n) => n.endsWith(".lua")).sort()) {
+      bundleParts.push(`-- ${f}`);
+      bundleParts.push(fs.readFileSync(pathe.join(helpersDir, f), "utf8").trimEnd());
+    }
+  }
+  const bundleContent = Buffer.from(bundleParts.join("\n") + "\n", "utf8");
+  const uploads = [
+    { remote: `${VERSION_PATH}/bundle.lua`, content: bundleContent }
+  ];
+  for (const adapter of ["windui.lua", "linoria.lua"]) {
+    const p = pathe.join(ADAPTERS, adapter);
+    if (fs.existsSync(p)) uploads.push({
+      remote: `${VERSION_PATH}/adapters/${adapter}`,
+      content: fs.readFileSync(p)
+    });
+  }
+  pSection(`Uploading to R2  ${gray("(v" + RB_VERSION + " \xB7 " + uploads.length + " files)")}`);
+  for (const { remote, content } of uploads) {
+    try {
+      await uploadFile(content, remote, config);
+      pOk(remote, `${content.length.toLocaleString()} bytes`);
+    } catch (e) {
+      pFail(`Failed: ${remote}`, String(e?.data?.message ?? e?.message ?? "").split("\n")[0]);
+      process.exit(1);
+    }
+  }
+  console.log();
+  pOk(`Published  ${gray("v" + RB_VERSION)}`);
+  pInfo(`CDN base:  ${cyan(config.R2_PUBLIC_URL + "/" + VERSION_PATH)}`);
+  console.log();
+}
+var CONFIG_CANDIDATES;
+var init_publish = __esm({
+  "src/commands/publish.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_constants();
+    CONFIG_CANDIDATES = [
+      pathe.join(process.cwd(), ".rb-publish"),
+      pathe.join(process.env["USERPROFILE"] ?? process.env["HOME"] ?? "", ".rb-publish")
+    ];
+  }
+});
+function adapterPath(ui) {
+  if (!VALID_UI_LIBS.has(ui)) throw new Error(`Unknown UI library '${ui}'. Valid: ${[...VALID_UI_LIBS].sort().join(", ")}`);
+  return path.join(ADAPTERS_DIR, `${ui}.lua`);
+}
+function rglob(dir, exts) {
+  if (!fs.existsSync(dir)) return [];
+  const results = [];
+  function walk(d) {
+    for (const entry of fs.readdirSync(d)) {
+      const full = path.join(d, entry);
+      if (fs.statSync(full).isDirectory()) {
+        walk(full);
+        continue;
+      }
+      if (exts.some((e) => full.endsWith(e))) results.push(full);
+    }
+  }
+  walk(dir);
+  return results;
+}
+var PULSE_DIR, PULSE_RUNTIME, PULSE_HELPERS, PULSE_DEV_DIR, PULSE_UI_DIR, ADAPTERS_DIR, REEXEC_GUARD, DESTROY_REGISTRATION, DEFAULTS_RUNNER, Compiler;
+var init_compiler = __esm({
+  "src/compiler.ts"() {
+    init_cjs_shims();
+    init_transpiler();
+    init_layout();
+    init_ui();
+    init_constants();
+    init_publish();
+    PULSE_DIR = path.join(__dirname, "..", "pulse");
+    PULSE_RUNTIME = path.join(PULSE_DIR, "runtime.lua");
+    PULSE_HELPERS = path.join(PULSE_DIR, "helpers");
+    PULSE_DEV_DIR = path.join(PULSE_DIR, "dev");
+    PULSE_UI_DIR = path.join(PULSE_DIR, "ui");
+    ADAPTERS_DIR = path.join(__dirname, "..", "adapters");
+    REEXEC_GUARD = `-- Stop any previous instance before this one starts.
+-- Kills old Heartbeat loops, connections, and Linoria window.
+if _G.__AOT_R_DESTROY then pcall(_G.__AOT_R_DESTROY) end
+`;
+    DESTROY_REGISTRATION = `-- Register this instance so the next re-execution can clean it up.
+_G.__AOT_R_DESTROY = _PulseDestroy
+`;
+    DEFAULTS_RUNNER = `task.spawn(function()
+    task.wait(0.5)
+    for _, d in ipairs(_PULSE_DEFAULTS) do
+        local effectiveValue = d.value
+        if d.type == "toggle" and Pulse.TestMode and Pulse.TestMode.isActive() then
+            if not Pulse.TestMode.isTarget(d.id) then
+                effectiveValue = false
+            end
+        end
+        if d.set then pcall(d.set, effectiveValue) end
+        if d.type == "toggle" then
+            pcall(function()
+                local t = Toggles and Toggles[d.id]
+                if t then t:SetValue(effectiveValue) end
+            end)
+        else
+            pcall(function()
+                local t = Options and Options[d.id]
+                if t then t:SetValue(d.value) end
+            end)
+        end
+        task.wait(0.05)
+    end
+    if #_PULSE_DEFAULTS > 0 then
+        local _notifyMsg = "AOT:Resistance Hub ready!"
+        if Pulse.TestMode and Pulse.TestMode.isActive() then
+            local _tt = Pulse.TestMode.getTargets()
+            if #_tt > 0 then
+                _notifyMsg = "Test mode: " .. table.concat(_tt, ", ")
+            end
+        end
+        if _PulseNotify then
+            _PulseNotify(_notifyMsg, 5)
+        end
+    end
+end)
+`;
+    Compiler = class {
+      root;
+      srcDir;
+      buildDir;
+      constructor(root) {
+        this.root = root;
+        this.srcDir = path.join(root, "src");
+        this.buildDir = path.join(root, "build");
+      }
+      getUiLibrary() {
+        const layoutFile = path.join(this.srcDir, "ui", "layout.rblua");
+        if (!fs.existsSync(layoutFile)) return "linoria";
+        try {
+          const [inner] = findLayoutBlock(fs.readFileSync(layoutFile, "utf8"));
+          if (inner) return parseLayoutOptions(inner).ui_library ?? "linoria";
+        } catch {
+        }
+        return "linoria";
+      }
+      resolveUi(ui) {
+        if (!ui) ui = this.getUiLibrary();
+        if (!VALID_UI_LIBS.has(ui)) throw new Error(`Unknown UI library '${ui}'. Valid: ${[...VALID_UI_LIBS].sort().join(", ")}`);
+        return ui;
+      }
+      getLoadOrder(opts = {}) {
+        const ui = this.resolveUi(opts.ui);
+        const src = this.srcDir;
+        const uiDir = path.join(src, "ui");
+        const devDir = path.join(src, "dev");
+        const exclude = new Set(ALWAYS_EXCLUDE);
+        if (opts.compat) {
+          const layoutFile = path.join(src, "ui", "layout.rblua");
+          if (fs.existsSync(layoutFile)) {
+            try {
+              const [inner] = findLayoutBlock(fs.readFileSync(layoutFile, "utf8"));
+              if (inner) {
+                for (const p of parseLayoutOptions(inner).compat_exclude ?? []) exclude.add(p);
+              }
+            } catch {
+            }
+          }
+        }
+        const bootstrap = path.join(src, "misc", "helpers", "globals.lua");
+        const remotes = path.join(src, "misc", "remotes.lua");
+        const startup = path.join(src, "startup.lua");
+        const first = [];
+        const middle = [];
+        let uiFiles = [];
+        if (fs.existsSync(bootstrap)) first.push(bootstrap);
+        if (fs.existsSync(remotes)) first.push(remotes);
+        const allFiles = [
+          ...rglob(src, [".lua", ".rblua"])
+        ].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+        for (const f of allFiles) {
+          if (f.startsWith(devDir + "\\") || f.startsWith(devDir + "/")) continue;
+          const rel = path.relative(src, f).replace(/\\/g, "/");
+          if (exclude.has(rel)) continue;
+          if (f === bootstrap || f === remotes || f === startup) continue;
+          if (path.basename(f) === path.basename(src)) continue;
+          if (f.startsWith(uiDir + "\\") || f.startsWith(uiDir + "/")) {
+            uiFiles.push(f);
+            continue;
+          }
+          path.join(f, "...");
+          if (path.relative(src, f).split(/[/\\]/).length === 1) continue;
+          middle.push(f);
+        }
+        if (opts.dev) {
+          const fwDevUi = path.join(PULSE_DEV_DIR, "ui");
+          if (fs.existsSync(fwDevUi)) {
+            for (const f of rglob(fwDevUi, [".lua", ".rblua"]).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))) {
+              uiFiles.push(f);
+            }
+          }
+        }
+        uiFiles = uiFiles.filter((f) => {
+          const n = path.basename(f);
+          return n !== "7_Settings.lua" && !path.basename(f, path.extname(f)).endsWith("_windui");
+        });
+        uiFiles.sort((a, b) => {
+          const an = path.basename(a), bn = path.basename(b);
+          const ai = an === "layout.rblua" ? 0 : 1;
+          const bi = bn === "layout.rblua" ? 0 : 1;
+          return ai !== bi ? ai - bi : an.toLowerCase().localeCompare(bn.toLowerCase());
+        });
+        if (fs.existsSync(PULSE_UI_DIR)) {
+          for (const f of rglob(PULSE_UI_DIR, [".lua", ".rblua"]).sort((a, b) => path.basename(a).toLowerCase().localeCompare(path.basename(b).toLowerCase()))) {
+            const stem = path.basename(f, path.extname(f));
+            if (stem.startsWith("windui_") && ui !== "windui") continue;
+            if (stem.startsWith("linoria_") && ui !== "linoria") continue;
+            uiFiles.push(f);
+          }
+        }
+        const last = [];
+        if (fs.existsSync(startup)) last.push(startup);
+        return [...first, ...middle, ...uiFiles, ...last];
+      }
+      compile(opts = {}) {
+        const ui = this.resolveUi(opts.ui);
+        const order = this.getLoadOrder({ ...opts, ui });
+        const hasRblua = order.some((f) => f.endsWith(".rblua"));
+        const srcUiDir = path.join(this.srcDir, "ui");
+        const pulseDevUi = path.join(PULSE_DEV_DIR, "ui");
+        const useCdn = !opts.dev && hasCdnConfig(this.root);
+        const parts = [];
+        parts.push("-- [re-execution guard]\n");
+        parts.push(REEXEC_GUARD);
+        parts.push("\n");
+        if (opts.dev) {
+          parts.push("-- [dev flag]\n");
+          parts.push("local _PULSE_DEV = true\n\n");
+        }
+        if (hasRblua) {
+          if (useCdn) {
+            const base = `${CDN_BASE_URL}/v${RB_VERSION}`;
+            parts.push(`-- Pulse v${RB_VERSION}
+`);
+            parts.push(`local _P=loadstring(game:HttpGet("${base}/bundle.lua"))()
+`);
+            parts.push(`local _A=loadstring(game:HttpGet("${base}/adapters/${ui}.lua"))()
+`);
+            parts.push("\n");
+          } else {
+            if (fs.existsSync(PULSE_RUNTIME)) {
+              parts.push("-- [pulse/runtime.lua]\n");
+              parts.push(fs.readFileSync(PULSE_RUNTIME, "utf8"));
+              parts.push("\n");
+              if (fs.existsSync(PULSE_HELPERS)) {
+                for (const helper of fs.readdirSync(PULSE_HELPERS).filter((f) => f.endsWith(".lua")).sort()) {
+                  parts.push(`-- [pulse/helpers/${helper}]
+`);
+                  parts.push(fs.readFileSync(path.join(PULSE_HELPERS, helper), "utf8"));
+                  parts.push("\n");
+                }
+              }
+            }
+          }
+        }
+        if (opts.dev && fs.existsSync(PULSE_DEV_DIR)) {
+          const rbRoot = path.join(__dirname, "..", "..");
+          for (const f of fs.readdirSync(PULSE_DEV_DIR).filter((n) => n.endsWith(".lua")).sort()) {
+            const full = path.join(PULSE_DEV_DIR, f);
+            const rel = path.relative(rbRoot, full).replace(/\\/g, "/");
+            parts.push(`-- [${rel}]
+`);
+            parts.push(fs.readFileSync(full, "utf8"));
+            parts.push("\n");
+          }
+        }
+        const adapter = adapterPath(ui);
+        if (!useCdn && fs.existsSync(srcUiDir) && fs.existsSync(adapter)) {
+          parts.push(`-- [adapters/${ui}.lua]
+`);
+          parts.push(fs.readFileSync(adapter, "utf8"));
+          parts.push("\n");
+        }
+        const label = (p) => {
+          try {
+            return path.relative(this.root, p).replace(/\\/g, "/");
+          } catch {
+            return path.relative(path.join(__dirname, ".."), p).replace(/\\/g, "/");
+          }
+        };
+        const isUiFile = (p) => p.startsWith(srcUiDir + "\\") || p.startsWith(srcUiDir + "/") || p.startsWith(pulseDevUi + "\\") || p.startsWith(pulseDevUi + "/") || p.startsWith(PULSE_UI_DIR + "\\") || p.startsWith(PULSE_UI_DIR + "/");
+        const shouldChunk = (p) => p.endsWith(".rblua") && !isUiFile(p);
+        let exportedFunc = false;
+        for (const f of order) {
+          const lbl = label(f);
+          if (shouldChunk(f) && !exportedFunc) {
+            parts.push("-- [rb: chunks begin]\n");
+            parts.push("_G.__rb_func = func\n");
+            parts.push("_G.__rb_lp   = _LocalPlayer\n");
+            parts.push("local function _chunk(fn) fn() end\n\n");
+            exportedFunc = true;
+          }
+          parts.push(`-- [${lbl}]
+`);
+          if (shouldChunk(f)) {
+            const source = fs.readFileSync(f, "utf8");
+            let content;
+            try {
+              content = transpile(source, f);
+            } catch (e) {
+              if (e instanceof TranspileError) throw new Error(`Transpile error in ${lbl}: ${e.message}`);
+              throw e;
+            }
+            parts.push("_chunk(function()\n");
+            parts.push("local func = _G.__rb_func\n");
+            parts.push("local _LocalPlayer = _G.__rb_lp\n");
+            parts.push(content);
+            parts.push("\nend)\n");
+          } else if (f.endsWith(".rblua")) {
+            const source = fs.readFileSync(f, "utf8");
+            try {
+              parts.push(transpile(source, f));
+            } catch (e) {
+              if (e instanceof TranspileError) throw new Error(`Transpile error in ${lbl}: ${e.message}`);
+              throw e;
+            }
+          } else {
+            parts.push(fs.readFileSync(f, "utf8"));
+          }
+          parts.push("\n");
+        }
+        if (order.some((f) => f.endsWith(".rblua"))) {
+          parts.push("-- [generated: defaults runner]\n");
+          parts.push(DEFAULTS_RUNNER);
+          parts.push("\n");
+        }
+        parts.push("-- [generated: destroy registration]\n");
+        parts.push(DESTROY_REGISTRATION);
+        parts.push("\n");
+        return parts.join("");
+      }
+      build(opts = {}) {
+        fs.mkdirSync(this.buildDir, { recursive: true });
+        const ui = this.resolveUi(opts.ui);
+        const outputName = opts.dev ? "script.dev.lua" : opts.compat ? "script.compat.lua" : "script.lua";
+        const outputPath = path.join(this.buildDir, outputName);
+        const content = this.compile({ ...opts, ui });
+        fs.writeFileSync(outputPath, content, "utf8");
+        const lines = content.split("\n").length - 1;
+        const chars = content.length;
+        const modules = this.getLoadOrder({ ...opts, ui }).length;
+        pOk(path.relative(this.root, outputPath).replace(/\\/g, "/"), `${chars.toLocaleString()} chars`, `${lines.toLocaleString()} lines`, `${modules} modules`);
+        return outputPath;
+      }
+    };
+  }
+});
+function checkSyntax(source) {
+  try {
+    luaparse.parse(source, {
+      luaVersion: "5.1",
+      comments: false
+    });
+    return [];
+  } catch (e) {
+    return [{
+      line: e.line ?? 0,
+      column: e.column ?? 0,
+      message: (e.message ?? String(e)).replace(/^\[.*?\]:\d+:\s*/, "")
+    }];
+  }
+}
+function syntaxCheckBuild(outputPath, order, root) {
+  let source;
+  try {
+    source = fs.readFileSync(outputPath, "utf8");
+  } catch {
+    return [];
+  }
+  const errs = checkSyntax(source);
+  if (!errs.length) return [];
+  const lines = source.split("\n");
+  let currentSrc = null;
+  let srcLineOffset = 0;
+  const lineToSrc = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(/^-- \[([^\]]+)\]$/);
+    if (m && !m[1].startsWith("rb:") && !m[1].startsWith("generated:")) {
+      currentSrc = m[1];
+      srcLineOffset = i + 1;
+    }
+    lineToSrc.push({ src: currentSrc, offset: srcLineOffset });
+  }
+  return errs.map((e) => {
+    const idx = Math.max(0, Math.min(e.line - 1, lineToSrc.length - 1));
+    const info = lineToSrc[idx] ?? { src: null, offset: 0 };
+    return {
+      compiledLine: e.line,
+      src: info.src ? path.resolve(root, info.src) : null,
+      srcLine: e.line - info.offset + 1,
+      message: e.message
+    };
+  });
+}
+function handleCheckErrors(errors, root, t0) {
+  const userErrors = errors.filter((e) => {
+    if (!e.src) return false;
+    try {
+      return e.src.startsWith(root);
+    } catch {
+      return false;
+    }
+  });
+  if (!userErrors.length) return;
+  for (const err of userErrors) {
+    const rel = err.src ? path.relative(root, err.src).replace(/\\/g, "/") : "?";
+    pFail(`${rel}  line ${err.srcLine}`, err.message);
+  }
+}
+function checkLocalBudget(builds, root) {
+  for (const build of builds) {
+    try {
+      const content = fs.readFileSync(build, "utf8");
+      if (content.length > 5e5) {
+        pWarn(`${path.relative(root, build).replace(/\\/g, "/")} is large (${(content.length / 1e3).toFixed(0)} KB) \u2014 check for local variable budget issues`);
+      }
+    } catch {
+    }
+  }
+}
+var luaparse;
+var init_checker = __esm({
+  "src/checker.ts"() {
+    init_cjs_shims();
+    init_ui();
+    luaparse = __require("luaparse");
+  }
+});
+function ensureIronbrew2() {
+  const entry = path.join(IRONBREW2_DIR, "IronBrew2.lua");
+  if (fs.existsSync(entry)) return IRONBREW2_DIR;
+  pInfo("Downloading Ironbrew2 from GitHub...");
+  fs.mkdirSync(path.dirname(IRONBREW2_DIR), { recursive: true });
+  const result = child_process.spawnSync("git", ["clone", "--depth=1", IRONBREW2_REPO, IRONBREW2_DIR], {
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    pFail("Failed to clone Ironbrew2 \u2014 check internet / git install.");
+    process.exit(1);
+  }
+  pOk(`Ironbrew2 ready  ${gray(IRONBREW2_DIR)}`);
+  return IRONBREW2_DIR;
+}
+async function obfuscateSource(source, ib2Dir) {
+  const { LuaFactory } = await import('wasmoon');
+  const factory = new LuaFactory();
+  const lua = await factory.createEngine();
+  const tmpIn = path.join(os.tmpdir(), `rb_in_${Date.now()}.lua`);
+  const tmpOut = path.join(os.tmpdir(), `rb_out_${Date.now()}.lua`);
+  try {
+    fs.writeFileSync(tmpIn, source, "utf8");
+    const inPath = tmpIn.replace(/\\/g, "/");
+    const outPath = tmpOut.replace(/\\/g, "/");
+    await lua.doString(`arg = {[0]="IronBrew2.lua", [1]="${inPath}", [2]="${outPath}"}`);
+    const ib2Source = fs.readFileSync(path.join(ib2Dir, "IronBrew2.lua"), "utf8");
+    await lua.doString(ib2Source);
+    if (!fs.existsSync(tmpOut)) throw new Error("Ironbrew2 produced no output");
+    return fs.readFileSync(tmpOut, "utf8");
+  } finally {
+    lua.global.close();
+    try {
+      __require("fs").unlinkSync(tmpIn);
+    } catch {
+    }
+    try {
+      __require("fs").unlinkSync(tmpOut);
+    } catch {
+    }
+  }
+}
+async function obfuscatePipeline(builds, root) {
+  pSection("Obfuscating");
+  const ib2Dir = ensureIronbrew2();
+  const outputs = [];
+  let failed = false;
+  for (const source of builds) {
+    const outPath = source.replace(/\.lua$/, ".obf.lua");
+    try {
+      pInfo(`Obfuscating ${__require("path").relative(root, source).replace(/\\/g, "/")}`);
+      const content = fs.readFileSync(source, "utf8");
+      const result = await obfuscateSource(content, ib2Dir);
+      fs.writeFileSync(outPath, result, "utf8");
+      pOk(__require("path").relative(root, outPath).replace(/\\/g, "/"), `${result.length.toLocaleString()} chars`);
+      outputs.push(outPath);
+    } catch (e) {
+      pFail(`Ironbrew2 failed on ${__require("path").basename(source)}`);
+      pWarn(String(e?.message ?? e));
+      failed = true;
+    }
+  }
+  if (failed) process.exit(1);
+  return outputs;
+}
+function copyToClipboard(content, label = "") {
+  const clip = process.platform === "win32" ? ["clip.exe"] : process.platform === "darwin" ? ["pbcopy"] : ["xclip", "-selection", "clipboard"];
+  try {
+    const r = child_process.spawnSync(clip[0], clip.slice(1), { input: content, encoding: "utf8" });
+    if (r.status === 0) {
+      pOk(`Copied to clipboard  ${gray(label)}`, `${content.length.toLocaleString()} chars`);
+      return;
+    }
+  } catch {
+  }
+  pWarn("Could not find clipboard tool (clip.exe / pbcopy / xclip)");
+}
+var init_obfuscator = __esm({
+  "src/obfuscator.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_constants();
+  }
+});
+
+// src/commands/build.ts
+var build_exports = {};
+__export(build_exports, {
+  cmdBuild: () => cmdBuild,
+  cmdClean: () => cmdClean,
+  cmdCopy: () => cmdCopy
+});
+async function cmdBuild(args) {
+  const root = requireProjectRoot();
+  const compiler = new Compiler(root);
+  pHeader("build");
+  const t0 = Date.now();
+  pSection("Compiling");
+  const builds = [];
+  builds.push(compiler.build({ compat: false, ui: args.ui }));
+  if (!args.noCompat) builds.push(compiler.build({ compat: true, ui: args.ui }));
+  if (args.dev) builds.push(compiler.build({ dev: true, ui: args.ui }));
+  pSection("Checking");
+  let hasErrors = false;
+  for (let i = 0; i < builds.length; i++) {
+    const order = compiler.getLoadOrder({ compat: i === 1, dev: i === 2, ui: args.ui });
+    const errors = syntaxCheckBuild(builds[i], order, root);
+    if (errors.length) {
+      handleCheckErrors(errors, root);
+      hasErrors = true;
+    }
+  }
+  if (!hasErrors) {
+    const order = compiler.getLoadOrder({ compat: false, ui: args.ui });
+    pOk(`Clean  ${gray(String(order.length) + " modules")}`);
+  }
+  checkLocalBudget(builds, root);
+  if (hasErrors) {
+    pDone((Date.now() - t0) / 1e3);
+    process.exit(1);
+  }
+  if (args.noObfuscate) {
+    pDone((Date.now() - t0) / 1e3);
+    return;
+  }
+  const preset = args.preset || "Medium";
+  if (!OBFUSCATION_PRESETS.map((p) => p.toLowerCase()).includes(preset.toLowerCase())) {
+    pFail(`Unknown preset '${preset}'`, `Choose: ${OBFUSCATION_PRESETS.join(", ")}`);
+    process.exit(1);
+  }
+  const obfBuilds = builds.filter((b) => !b.includes("script.dev"));
+  const outputs = await obfuscatePipeline(obfBuilds, root);
+  pDone((Date.now() - t0) / 1e3);
+  if (args.copy && outputs.length) {
+    const { readFileSync: readFileSync12 } = await import('fs');
+    const toCopy = outputs.find((p) => !p.includes("compat")) ?? outputs[0];
+    copyToClipboard(readFileSync12(toCopy, "utf8"), __require("path").basename(toCopy));
+  }
+}
+async function cmdCopy(args) {
+  const root = requireProjectRoot();
+  const compiler = new Compiler(root);
+  pHeader("copy");
+  pSection("Compiling");
+  const output = compiler.build({ compat: args.compat });
+  const { readFileSync: readFileSync12 } = await import('fs');
+  copyToClipboard(readFileSync12(output, "utf8"), __require("path").basename(output));
+  console.log();
+}
+function cmdClean(_args) {
+  const root = requireProjectRoot();
+  const { readdirSync: readdirSync4, unlinkSync } = __require("fs");
+  const { join: join16, relative: relative6 } = __require("path");
+  pHeader("clean");
+  const buildDir = join16(root, "build");
+  if (!fs.existsSync(buildDir)) {
+    (init_ui(), __toCommonJS(ui_exports)).pInfo("Nothing to clean  (no build/ directory)");
+    console.log();
+    return;
+  }
+  const files = readdirSync4(buildDir).filter((f) => f.endsWith(".lua"));
+  if (!files.length) {
+    (init_ui(), __toCommonJS(ui_exports)).pInfo("Nothing to clean");
+    console.log();
+    return;
+  }
+  for (const f of files) {
+    unlinkSync(join16(buildDir, f));
+    (init_ui(), __toCommonJS(ui_exports)).pOk(relative6(root, join16(buildDir, f)).replace(/\\/g, "/"));
+  }
+  console.log();
+}
+var init_build = __esm({
+  "src/commands/build.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_project();
+    init_compiler();
+    init_checker();
+    init_obfuscator();
+    init_constants();
+  }
+});
+
+// src/commands/watch.ts
+var watch_exports = {};
+__export(watch_exports, {
+  cmdWatch: () => cmdWatch
+});
+function cmdWatch(args) {
+  const root = requireProjectRoot();
+  const compiler = new Compiler(root);
+  pHeader("watch");
+  pInfo(`Watching ${bold("src/")} for changes  ${dim("Ctrl+C to stop")}`);
+  console.log();
+  const rebuild = () => {
+    try {
+      pSection("Compiling");
+      compiler.build({ compat: false });
+      if (args.compat) compiler.build({ compat: true });
+      console.log();
+    } catch (e) {
+      pFail(`Build error: ${e?.message ?? e}`);
+    }
+  };
+  const srcDir = pathe.join(root, "src");
+  const watcher = chokidar__default.default.watch([
+    pathe.join(srcDir, "**", "*.lua"),
+    pathe.join(srcDir, "**", "*.rblua")
+  ], { ignoreInitial: true, persistent: true });
+  watcher.on("change", (p) => {
+    pInfo(`changed  ${gray(p.replace(root, "").replace(/\\/g, "/").replace(/^\//, ""))}`);
+    rebuild();
+  });
+  watcher.on("add", (p) => {
+    pInfo(`added  ${gray(p.replace(root, "").replace(/\\/g, "/").replace(/^\//, ""))}`);
+    rebuild();
+  });
+  watcher.on("unlink", (p) => {
+    pInfo(`removed  ${gray(p.replace(root, "").replace(/\\/g, "/").replace(/^\//, ""))}`);
+    rebuild();
+  });
+  process.on("SIGINT", () => {
+    console.log(`
+  ${dim("stopped.")}
+`);
+    process.exit(0);
+  });
+}
+var init_watch = __esm({
+  "src/commands/watch.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_project();
+    init_compiler();
+  }
+});
+
+// src/commands/check.ts
+var check_exports = {};
+__export(check_exports, {
+  cmdCheck: () => cmdCheck
+});
+function cmdCheck(args) {
+  const root = requireProjectRoot();
+  const compiler = new Compiler(root);
+  pHeader("check");
+  const t0 = Date.now();
+  const order = compiler.getLoadOrder({ compat: args.compat });
+  const variant = args.compat ? "compat" : "standard";
+  pSection(`Compiling  ${gray(`(${variant} \xB7 ${order.length} modules)`)}`);
+  const combined = compiler.compile({ compat: args.compat });
+  const lines = combined.split("\n").length - 1;
+  console.log(`       ${dim(`${combined.length.toLocaleString()} chars  \xB7  ${lines.toLocaleString()} lines`)}`);
+  pSection("Syntax  (luaparse)");
+  const errors = checkSyntax(combined);
+  if (errors.length) {
+    for (const err of errors) {
+      pFail(`line ${err.line}`, err.message);
+    }
+  } else {
+    pOk(`No errors  ${gray(`${order.length} modules \xB7 ${lines} lines`)}`);
+  }
+  const logPath = path.join(root, "build", "check.log");
+  fs.mkdirSync(path.join(root, "build"), { recursive: true });
+  const elapsed = (Date.now() - t0) / 1e3;
+  const log = [
+    `rb check \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    `variant:  ${variant}`,
+    `modules:  ${order.length}`,
+    `elapsed:  ${elapsed.toFixed(2)}s`,
+    errors.length ? `
+Errors:
+${errors.map((e) => `  line ${e.line}: ${e.message}`).join("\n")}` : "\nNo errors."
+  ].join("\n");
+  fs.writeFileSync(logPath, log, "utf8");
+  console.log();
+  pInfo(`Log \u2192 ${gray(path.relative(root, logPath).replace(/\\/g, "/"))}`);
+  console.log();
+  if (errors.length) process.exit(1);
+}
+var init_check = __esm({
+  "src/commands/check.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_project();
+    init_compiler();
+    init_checker();
+  }
+});
+function read(name) {
+  const p = path.join(DIR, name);
+  return fs.existsSync(p) ? fs.readFileSync(p, "utf8") : "";
+}
+function makeClaudeMd(name) {
+  return read("CLAUDE.md").replace(/{NAME}/g, name);
+}
+function makeAgentsMd(name) {
+  return read("AGENTS.md").replace(/{NAME}/g, name);
+}
+var DIR, TEMPLATE_GLOBALS, TEMPLATE_REMOTES, TEMPLATE_GITIGNORE, TEMPLATE_LAYOUT, TEMPLATE_PAGE_HOME, TEMPLATE_EX_SPEED, TEMPLATE_EX_FOV, TEMPLATE_EX_ESP, TEMPLATE_DEPLOY_EXAMPLE, MODULE_BOILERPLATE, MODULE_RBLUA_BOILERPLATE, REMOTE_BOILERPLATE;
+var init_templates = __esm({
+  "src/templates.ts"() {
+    init_cjs_shims();
+    DIR = path.join(__dirname, "..", "templates");
+    TEMPLATE_GLOBALS = read("globals.lua");
+    TEMPLATE_REMOTES = read("remotes.lua");
+    TEMPLATE_GITIGNORE = read("gitignore");
+    TEMPLATE_LAYOUT = read("layout.rblua");
+    TEMPLATE_PAGE_HOME = read("page_home.rblua");
+    TEMPLATE_EX_SPEED = read("example_speed.rblua");
+    TEMPLATE_EX_FOV = read("example_fov.rblua");
+    TEMPLATE_EX_ESP = read("example_esp.rblua");
+    TEMPLATE_DEPLOY_EXAMPLE = read("deploy_config.example");
+    MODULE_BOILERPLATE = read("module.lua");
+    MODULE_RBLUA_BOILERPLATE = read("module.rblua");
+    REMOTE_BOILERPLATE = read("remote.lua");
+  }
+});
+
+// src/commands/docs.ts
+var docs_exports = {};
+__export(docs_exports, {
+  cmdDocs: () => cmdDocs,
+  generateDocs: () => generateDocs
+});
+function generateDocs() {
+  const parts = [];
+  for (const name of DOC_ORDER) {
+    const p = pathe.join(DOCS_DIR, name);
+    if (fs.existsSync(p)) parts.push(fs.readFileSync(p, "utf8").trim());
+  }
+  return parts.join("\n\n---\n\n");
+}
+function cmdDocs(args) {
+  const out = args.output || "PULSE_DOCS.md";
+  if (out === "-") {
+    console.log(generateDocs());
+    return;
+  }
+  pHeader("docs");
+  const content = generateDocs();
+  let dest = pathe.resolve(out);
+  if (!out.startsWith("/") && !out.match(/^[A-Z]:/i)) {
+    const root = findProjectRoot() ?? process.cwd();
+    dest = pathe.join(root, out);
+  }
+  fs.writeFileSync(dest, content, "utf8");
+  let label = dest;
+  try {
+    label = dest.replace(process.cwd().replace(/\\/g, "/"), ".").replace(/\\/g, "/");
+  } catch {
+  }
+  pOk(label, `${content.length.toLocaleString()} chars`);
+  console.log(`
+  ${cyan("\u2192")}  add ${bold(out.split("/").pop())} to your LLM context for full Pulse reference
+`);
+}
+var DOC_ORDER, DOCS_DIR;
+var init_docs = __esm({
+  "src/commands/docs.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_project();
+    DOC_ORDER = [
+      "what-is-pulse.md",
+      "getting-started.md",
+      "components.md",
+      "signals.md",
+      "ui.md",
+      "helpers.md",
+      "syntax.md",
+      "cli.md"
+    ];
+    DOCS_DIR = pathe.join(__dirname, "..", "docs");
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  cmdInit: () => cmdInit
+});
+async function cmdInit(args) {
+  const name = args.name;
+  const dest = pathe.join(process.cwd(), name);
+  if (fs.existsSync(dest) && !args.force) {
+    pFail(`Directory '${name}' already exists`, "use --force to overwrite");
+    process.exit(1);
+  }
+  pHeader("init");
+  pSection(`Scaffolding  ${bold(name + "/")}`);
+  for (const dir of [
+    "src/misc/helpers",
+    "src/player",
+    "src/visuals",
+    "src/ui/pages",
+    "build"
+  ]) {
+    fs.mkdirSync(pathe.join(dest, dir), { recursive: true });
+  }
+  const files = [
+    ["src/misc/helpers/globals.lua", TEMPLATE_GLOBALS.replace(/{NAME}/g, name)],
+    ["src/misc/remotes.lua", TEMPLATE_REMOTES],
+    ["src/ui/layout.rblua", TEMPLATE_LAYOUT.replace(/{NAME}/g, name)],
+    ["src/ui/pages/1_Home.rblua", TEMPLATE_PAGE_HOME],
+    ["src/player/SpeedHack.rblua", TEMPLATE_EX_SPEED],
+    ["src/player/FOVChanger.rblua", TEMPLATE_EX_FOV],
+    ["src/visuals/PlayerESP.rblua", TEMPLATE_EX_ESP],
+    [".rb-deploy.example", TEMPLATE_DEPLOY_EXAMPLE],
+    [".gitignore", TEMPLATE_GITIGNORE],
+    ["CLAUDE.md", makeClaudeMd(name)],
+    ["AGENTS.md", makeAgentsMd(name)]
+  ];
+  for (const [rel, content] of files) {
+    const path = pathe.join(dest, rel);
+    fs.mkdirSync(pathe.join(path, ".."), { recursive: true });
+    fs.writeFileSync(path, content, "utf8");
+    pOk(rel);
+  }
+  try {
+    const docs = generateDocs();
+    fs.writeFileSync(pathe.join(dest, "PULSE_DOCS.md"), docs, "utf8");
+    pOk("PULSE_DOCS.md");
+  } catch {
+    pWarn("PULSE_DOCS.md  (skipped \u2014 docs not available)");
+  }
+  const pkgJson = {
+    name,
+    private: true,
+    scripts: {
+      build: "rb build",
+      watch: "rb watch",
+      check: "rb check",
+      deploy: "rb deploy",
+      lint: "rb lint"
+    },
+    devDependencies: {
+      "pulse-rb": `^${RB_VERSION}`,
+      "@rb-pulse/core": `^${RB_VERSION}`,
+      "@rb-pulse/ui": `^${RB_VERSION}`,
+      "@rb-pulse/roblox": `^${RB_VERSION}`
+    }
+  };
+  fs.writeFileSync(pathe.join(dest, "package.json"), JSON.stringify(pkgJson, null, 2) + "\n", "utf8");
+  pOk("package.json");
+  try {
+    await execa.execa("git", ["init"], { cwd: dest });
+    await execa.execa("git", ["add", "-A"], { cwd: dest });
+    await execa.execa("git", ["commit", "-m", `init: scaffold ${name}`], { cwd: dest });
+    pOk("git init");
+  } catch (e) {
+    pWarn(`git init skipped  ${gray(String(e?.message ?? "").split("\n")[0])}`);
+  }
+  try {
+    pSection("Installing dependencies");
+    await execa.execa("pnpm", ["install"], { cwd: dest, stdio: "inherit" });
+    pOk("pnpm install");
+  } catch {
+    try {
+      await execa.execa("npm", ["install"], { cwd: dest, stdio: "inherit" });
+      pOk("npm install");
+    } catch {
+      pWarn("Could not run install \u2014 run  pnpm install  manually");
+    }
+  }
+  console.log();
+  console.log(`  ${dim("Created at: " + dest)}`);
+  console.log(`  ${cyan("\u2192")}  cd ${name} && pnpm build`);
+  console.log();
+}
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_templates();
+    init_docs();
+    init_constants();
+  }
+});
+
+// src/commands/modules.ts
+var modules_exports = {};
+__export(modules_exports, {
+  cmdList: () => cmdList,
+  cmdNew: () => cmdNew,
+  cmdRemove: () => cmdRemove,
+  cmdStatus: () => cmdStatus
+});
+function toCamel(name) {
+  const stem = pathe.basename(name, pathe.extname(name));
+  if (/[_\-\s]/.test(stem)) {
+    return stem.split(/[_\-\s]+/).map((p) => p[0].toUpperCase() + p.slice(1)).join("");
+  }
+  return stem[0].toUpperCase() + stem.slice(1);
+}
+function cmdNew(args) {
+  const root = requireProjectRoot();
+  if (args.type === "module") {
+    const plain = args.plain ?? false;
+    let relPath = args.path;
+    if (plain) {
+      if (!relPath.endsWith(".lua")) relPath += ".lua";
+      const dest = pathe.join(root, "src", relPath);
+      const camel = toCamel(relPath);
+      const lower = camel[0].toLowerCase() + camel.slice(1);
+      const upper = camel.toUpperCase();
+      const content = MODULE_BOILERPLATE.replace(/{UPPER}/g, upper).replace(/{Camel}/g, camel).replace(/{lower}/g, lower);
+      if (fs.existsSync(dest)) {
+        pFail(`src/${relPath} already exists`);
+        process.exit(1);
+      }
+      fs.mkdirSync(pathe.join(dest, ".."), { recursive: true });
+      fs.writeFileSync(dest, content, "utf8");
+      pOk(`src/${relPath}`);
+      console.log();
+      pKv("File", `src/${relPath}`);
+      pKv("Tip", "add to func for shared helpers; keep private state local");
+    } else {
+      if (!relPath.endsWith(".rblua")) relPath += ".rblua";
+      const dest = pathe.join(root, "src", relPath);
+      const camel = toCamel(relPath);
+      if (fs.existsSync(dest)) {
+        pFail(`src/${relPath} already exists`);
+        process.exit(1);
+      }
+      fs.mkdirSync(pathe.join(dest, ".."), { recursive: true });
+      fs.writeFileSync(dest, MODULE_RBLUA_BOILERPLATE, "utf8");
+      pOk(`src/${relPath}`);
+      console.log();
+      pKv("Component", camel);
+      pKv("Enabled", `Components.${camel}.enabled(true)`);
+      pKv("Toggle", `Components.${camel}.Toggle()`);
+      pKv("Listen", `Components.${camel}.onEnable:connect(...)`);
+    }
+    console.log();
+  } else if (args.type === "remote") {
+    const remoteName = args.path;
+    const remotesPath = pathe.join(root, "src", "misc", "remotes.lua");
+    if (!fs.existsSync(remotesPath)) {
+      pFail("src/misc/remotes.lua not found");
+      process.exit(1);
+    }
+    const lower = remoteName[0].toLowerCase() + remoteName.slice(1);
+    const upper = remoteName.toUpperCase();
+    const stub = REMOTE_BOILERPLATE.replace(/{UPPER}/g, upper).replace(/{lower}/g, lower).replace(/{Name}/g, remoteName);
+    const existing = fs.readFileSync(remotesPath, "utf8");
+    fs.writeFileSync(remotesPath, existing.trimEnd() + "\n" + stub, "utf8");
+    pOk(`func.Remote_${remoteName}(...)  ${gray("\u2192 remotes.lua")}`);
+    console.log();
+  } else {
+    pFail(`Unknown type '${args.type}'`, "use: rb new module | rb new remote");
+    process.exit(1);
+  }
+}
+async function cmdRemove(args) {
+  const root = requireProjectRoot();
+  let relPath = args.path;
+  if (!relPath.endsWith(".lua") && !relPath.endsWith(".rblua")) relPath += ".lua";
+  const target = pathe.join(root, "src", relPath);
+  if (!fs.existsSync(target)) {
+    pFail(`src/${relPath} not found`);
+    process.exit(1);
+  }
+  const ok = await prompts.confirm({ message: `Remove src/${relPath}?` });
+  if (!ok || prompts.isCancel(ok)) {
+    pDim("aborted");
+    console.log();
+    return;
+  }
+  const { rmSync } = await import('fs');
+  rmSync(target);
+  pOk(`Removed  ${gray("src/" + relPath)}`);
+  console.log();
+}
+function cmdList(args) {
+  const root = requireProjectRoot();
+  const compiler = new Compiler(root);
+  const compat = args.compat ?? false;
+  const order = compiler.getLoadOrder({ compat });
+  const variant = compat ? "compat" : "standard";
+  pHeader("list");
+  pSection(`Load order  ${gray("(" + variant + " \xB7 " + order.length + " modules)")}`);
+  pHr();
+  for (let i = 0; i < order.length; i++) {
+    const num = gray(`${(i + 1).toString().padStart(3)}`);
+    const rel = pathe.relative(root, order[i]).replace(/\\/g, "/");
+    console.log(`    ${num}  ${rel}`);
+  }
+  console.log();
+}
+async function cmdStatus(_args) {
+  const root = requireProjectRoot();
+  const compiler = new Compiler(root);
+  pHeader("status");
+  console.log(`  ${bold(root.split("/").pop())}`);
+  pHr();
+  const order = compiler.getLoadOrder({ compat: false });
+  pKv("Root", root);
+  pKv("Modules", String(order.length));
+  const buildScript = pathe.join(root, "build", "script.lua");
+  if (fs.existsSync(buildScript)) {
+    const { statSync: statSync2 } = await import('fs');
+    const content = fs.readFileSync(buildScript, "utf8");
+    const mtime = new Date(statSync2(buildScript).mtimeMs).toISOString().slice(0, 16).replace("T", " ");
+    pKv("Last build", `${mtime}  ${gray(content.length.toLocaleString() + " chars")}`);
+  } else {
+    pKv("Last build", dim("none"));
+  }
+  try {
+    const { stdout } = await execa.execa("git", ["status", "--short"], { cwd: root });
+    const changed = stdout.trim().split("\n").filter(Boolean);
+    pSection(`Git  ${gray("(" + changed.length + " change" + (changed.length !== 1 ? "s" : "") + ")")}`);
+    for (const line of changed.slice(0, 12)) {
+      const flag = line.slice(0, 2).trim();
+      const path = line.slice(3);
+      const color = flag === "A" ? green : flag.startsWith("M") ? yellow : red;
+      console.log(`    ${color(flag.padEnd(2))}  ${path}`);
+    }
+    if (changed.length > 12) pDim(`... and ${changed.length - 12} more`);
+  } catch {
+    pKv("Git", dim("not a repository"));
+  }
+  console.log();
+}
+var init_modules = __esm({
+  "src/commands/modules.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_project();
+    init_compiler();
+    init_templates();
+  }
+});
+
+// src/commands/git.ts
+var git_exports = {};
+__export(git_exports, {
+  cmdHistory: () => cmdHistory,
+  cmdRestore: () => cmdRestore,
+  cmdSave: () => cmdSave
+});
+async function cmdSave(args) {
+  const root = requireProjectRoot();
+  pHeader("save");
+  const msg = args.message || `checkpoint: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ")}`;
+  try {
+    await execa.execa("git", ["add", "-A"], { cwd: root });
+    const { stdout } = await execa.execa("git", ["commit", "-m", msg], { cwd: root });
+    const lines = stdout.trim().split("\n");
+    pOk(lines[0] ?? msg);
+    for (const line of lines.slice(1)) pDim(line);
+  } catch (e) {
+    const out = String(e?.stdout ?? "") + String(e?.stderr ?? "");
+    pInfo(out.trim() || "nothing to commit");
+  }
+  console.log();
+}
+async function cmdHistory(args) {
+  const root = requireProjectRoot();
+  pHeader("history");
+  const n = args.n ?? 10;
+  try {
+    const { stdout } = await execa.execa("git", [
+      "log",
+      `-${n}`,
+      "--format=%h %s  %cd",
+      "--date=format:%Y-%m-%d %H:%M"
+    ], { cwd: root });
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    if (!lines.length) {
+      pInfo("No commits yet");
+    } else {
+      for (const line of lines) {
+        const [sha, ...rest] = line.split(" ");
+        console.log(`    ${gray(sha)}  ${rest.join(" ")}`);
+      }
+    }
+  } catch {
+    pFail("Not a git repository");
+  }
+  console.log();
+}
+async function cmdRestore(args) {
+  const root = requireProjectRoot();
+  const ref = args.ref;
+  const { confirm: confirm2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+  const ok = await confirm2({
+    message: `Restore to '${ref}'? Unsaved changes will be lost.`
+  });
+  if (!ok || ok === /* @__PURE__ */ Symbol.for("clack:cancel")) {
+    console.log(`
+  ${dim("aborted")}
+`);
+    return;
+  }
+  try {
+    await execa.execa("git", ["checkout", ref, "--", "."], { cwd: root });
+    pOk(`Restored to ${bold(ref)}`);
+  } catch (e) {
+    pFail(String(e?.stderr ?? e?.message ?? e).split("\n")[0]);
+    process.exit(1);
+  }
+  console.log();
+}
+var init_git = __esm({
+  "src/commands/git.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_project();
+  }
+});
+
+// src/commands/deploy.ts
+var deploy_exports = {};
+__export(deploy_exports, {
+  cmdDeploy: () => cmdDeploy
+});
+function readConfig(root) {
+  const cfgPath = pathe.join(root, CONFIG_FILE);
+  if (!fs.existsSync(cfgPath)) return {};
+  const config = {};
+  for (const line of fs.readFileSync(cfgPath, "utf8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq < 0) continue;
+    const key = trimmed.slice(0, eq).trim();
+    config[key] = trimmed.slice(eq + 1).trim();
+  }
+  return config;
+}
+function printSetupHelp(root) {
+  console.log();
+  pInfo("To set up deployment:");
+  console.log(`  ${dim("1.")} Copy  ${gray(".rb-deploy.example")}  to  ${gray(".rb-deploy")}`);
+  console.log(`  ${dim("2.")} Fill in GITHUB_TOKEN and GITHUB_REPO`);
+  console.log(`  ${dim("3.")} Run  ${cyan("rb deploy")}  again`);
+  console.log();
+}
+async function cmdDeploy(args) {
+  pHeader("deploy");
+  const root = findProjectRoot();
+  if (!root) {
+    pFail("Not inside a Pulse project (no src/ directory found)");
+    return;
+  }
+  const config = readConfig(root);
+  const token = args.token || config.GITHUB_TOKEN || "";
+  const repo = args.repo || config.GITHUB_REPO || "";
+  const file = args.file || config.GITHUB_FILE || "script.obf.lua";
+  const branch = args.branch || config.GITHUB_BRANCH || "main";
+  if (!token || token === "ghp_your_token_here") {
+    pFail("No GITHUB_TOKEN set", `Add it to ${CONFIG_FILE}`);
+    printSetupHelp();
+    return;
+  }
+  if (!repo || repo === "yourname/my-script-release") {
+    pFail("No GITHUB_REPO set", `Add it to ${CONFIG_FILE}`);
+    printSetupHelp();
+    return;
+  }
+  const scriptPath = pathe.join(root, "build", "script.obf.lua");
+  if (!fs.existsSync(scriptPath)) {
+    pInfo("build/script.obf.lua not found \u2014 run  rb build  first to produce it");
+    process.exit(1);
+  }
+  const contentB64 = Buffer.from(fs.readFileSync(scriptPath)).toString("base64");
+  const apiUrl = `https://api.github.com/repos/${repo}/contents/${file}`;
+  const headers = {
+    Authorization: `token ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "Content-Type": "application/json",
+    "User-Agent": "rb-deploy/1.0"
+  };
+  let sha;
+  try {
+    const existing = await ofetch.ofetch(`${apiUrl}?ref=${branch}`, { headers });
+    sha = existing.sha;
+  } catch {
+  }
+  pInfo(`Pushing  ${gray(file)}  \u2192  ${gray(repo)}  (${branch})`);
+  try {
+    await ofetch.ofetch(apiUrl, {
+      method: "PUT",
+      headers,
+      body: { message: "deploy: update script", content: contentB64, branch, ...sha ? { sha } : {} }
+    });
+  } catch (e) {
+    pFail(String(e?.data?.message ?? e?.message ?? e));
+    return;
+  }
+  const rawUrl = `https://raw.githubusercontent.com/${repo}/${branch}/${file}`;
+  const loadstring = `loadstring(game:HttpGet("${rawUrl}"))()`;
+  pOk(`Deployed  ${gray(repo + "/" + file)}`);
+  console.log();
+  console.log(`  ${bold("Loadstring URL:")}`);
+  console.log(`  ${cyan(loadstring)}`);
+  console.log();
+}
+var CONFIG_FILE;
+var init_deploy = __esm({
+  "src/commands/deploy.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_project();
+    CONFIG_FILE = ".rb-deploy";
+  }
+});
+
+// src/commands/lint.ts
+var lint_exports = {};
+__export(lint_exports, {
+  cmdLint: () => cmdLint
+});
+function stripStrings(src) {
+  src = src.replace(/\[=*\[[\s\S]*?\]=*\]/g, '""');
+  src = src.replace(/"(?:[^"\\]|\\.)*"/g, '""');
+  src = src.replace(/'(?:[^'\\]|\\.)*'/g, "''");
+  return src;
+}
+function stripComments(src) {
+  src = src.replace(/--\[=*\[[\s\S]*?\]=*\]/g, "");
+  src = src.replace(/--[^\n]*/g, "");
+  return src;
+}
+function clean(src) {
+  return stripStrings(stripComments(src));
+}
+function parseComp(path) {
+  const raw = fs.readFileSync(path, "utf8");
+  const cleaned = clean(raw);
+  const info = {
+    name: path.split("/").pop().replace(/\.(rblua|lua)$/, ""),
+    file: path,
+    signals: /* @__PURE__ */ new Set(),
+    uiSignals: /* @__PURE__ */ new Set(),
+    handlers: [],
+    whenGuards: /* @__PURE__ */ new Set(),
+    everyRefs: /* @__PURE__ */ new Set(),
+    funcDefs: /* @__PURE__ */ new Set(),
+    localFuncs: /* @__PURE__ */ new Set(),
+    publicFuncs: /* @__PURE__ */ new Set(),
+    raw,
+    cleaned
+  };
+  for (const m of cleaned.matchAll(/\bsignal\s+(\w+)\s*=/g)) info.signals.add(m[1]);
+  for (const m of cleaned.matchAll(/->\s+(\w+)/g)) info.uiSignals.add(m[1]);
+  for (const m of cleaned.matchAll(/\bon\s+(\w+)/g)) info.handlers.push(m[1]);
+  for (const m of cleaned.matchAll(/\bwhen\s+(\w+)\b/g)) info.whenGuards.add(m[1]);
+  for (const m of cleaned.matchAll(/\bevery\s+([A-Za-z_]\w*)\b/g)) info.everyRefs.add(m[1]);
+  for (const m of cleaned.matchAll(/\bfunc\.(\w+)\s*=\s*(?!nil\b|false\b|true\b|\d)/g))
+    info.funcDefs.add(m[1]);
+  for (const m of cleaned.matchAll(/\bfunc\s+(\w+)\s*\(/g)) {
+    const before = cleaned.slice(Math.max(0, m.index - 6), m.index);
+    if (!before.includes("local")) info.publicFuncs.add(m[1]);
+  }
+  for (const m of cleaned.matchAll(/\blocal\s+func\s+(\w+)\s*\(/g))
+    info.localFuncs.add(m[1]);
+  return info;
+}
+function countRefs(pattern, text2) {
+  return (text2.match(new RegExp(pattern, "g")) ?? []).length;
+}
+function cmdLint(_args) {
+  const root = requireProjectRoot();
+  const srcDir = pathe.join(root, "src");
+  const uiDir = pathe.join(srcDir, "ui");
+  pHeader("lint");
+  const rblua = globby.globbySync("**/*.rblua", { cwd: srcDir, absolute: true }).filter((f) => !f.startsWith(uiDir + "/") && !f.startsWith(uiDir + "\\"));
+  const components = {};
+  for (const f of rblua) {
+    const info = parseComp(f);
+    components[info.name] = info;
+  }
+  const allFiles = globby.globbySync("**/*.{rblua,lua}", { cwd: srcDir, absolute: true });
+  const allClean = allFiles.map((f) => {
+    try {
+      return clean(fs.readFileSync(f, "utf8"));
+    } catch {
+      return "";
+    }
+  }).join("\n");
+  const issues = [];
+  for (const info of Object.values(components)) {
+    for (const sig of [...info.signals].sort()) {
+      const reasons = [];
+      if (info.handlers.includes(sig)) reasons.push("on handler");
+      if (info.uiSignals.has(sig)) reasons.push("UI widget");
+      if (info.whenGuards.has(sig)) reasons.push("when guard");
+      if (info.everyRefs.has(sig)) reasons.push("every throttle");
+      if (new RegExp(`\\b${sig}\\(\\)`).test(info.cleaned)) reasons.push("signal() call");
+      if (countRefs(`\\b${sig}\\b`, info.cleaned) > 1) reasons.push("bare name in code");
+      if (new RegExp(`\\b${info.name}\\.${sig}\\b`).test(allClean)) reasons.push("cross-component read");
+      if (new RegExp(`\\bComponents\\.\\w+\\.${sig}\\b`).test(allClean)) reasons.push("Components.* read");
+      if (!reasons.length) {
+        issues.push({
+          severity: "warn",
+          kind: "dead_signal",
+          comp: info.name,
+          detail: `signal '${sig}' declared but never used`,
+          file: info.file
+        });
+      }
+    }
+  }
+  for (const info of Object.values(components)) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const h of info.handlers) {
+      if (seen.has(h) || SERVICE_EVENTS.has(h) || info.signals.has(h)) {
+        seen.add(h);
+        continue;
+      }
+      seen.add(h);
+      issues.push({
+        severity: "warn",
+        kind: "ghost_handler",
+        comp: info.name,
+        detail: `on ${h} {} \u2014 '${h}' is not a declared signal or known event`,
+        file: info.file
+      });
+    }
+  }
+  const seenGhost = /* @__PURE__ */ new Set();
+  for (const f of allFiles.filter((f2) => f2.endsWith(".rblua"))) {
+    let src;
+    try {
+      src = clean(fs.readFileSync(f, "utf8"));
+    } catch {
+      continue;
+    }
+    for (const m of src.matchAll(/\bComponents\.(\w+)\.(\w+)/g)) {
+      const [refComp, refAttr] = [m[1], m[2]];
+      const key = `${refComp}.${refAttr}`;
+      if (seenGhost.has(key)) continue;
+      if (!components[refComp]) {
+        seenGhost.add(key);
+        issues.push({
+          severity: "error",
+          kind: "ghost_ref",
+          comp: f.split("/").pop().replace(/\.(rblua|lua)$/, ""),
+          detail: `Components.${refComp}.${refAttr} \u2014 component '${refComp}' not found`,
+          file: f
+        });
+      } else {
+        const c2 = components[refComp];
+        if (!c2.signals.has(refAttr) && !c2.publicFuncs.has(refAttr) && !refAttr.startsWith("_")) {
+          seenGhost.add(key);
+          issues.push({
+            severity: "error",
+            kind: "ghost_ref",
+            comp: f.split("/").pop().replace(/\.(rblua|lua)$/, ""),
+            detail: `Components.${refComp}.${refAttr} \u2014 '${refAttr}' not a signal or func on ${refComp}`,
+            file: f
+          });
+        }
+      }
+    }
+  }
+  const allFuncDefs = {};
+  for (const f of allFiles) {
+    let src;
+    try {
+      src = clean(fs.readFileSync(f, "utf8"));
+    } catch {
+      continue;
+    }
+    for (const m of src.matchAll(/\bfunc\.(\w+)\s*=\s*(?!nil\b|false\b|true\b|\d)/g))
+      allFuncDefs[m[1]] = f;
+  }
+  for (const [fname, defFile] of Object.entries(allFuncDefs)) {
+    if (countRefs(`\\bfunc\\.${fname}\\b`, allClean) <= 1) {
+      issues.push({
+        severity: "warn",
+        kind: "orphan_func",
+        comp: defFile.split("/").pop().replace(/\.(rblua|lua)$/, ""),
+        detail: `func.${fname} is defined but never called`,
+        file: defFile
+      });
+    }
+  }
+  for (const info of Object.values(components)) {
+    for (const fname of [...info.localFuncs].sort()) {
+      if (countRefs(`\\b${fname}\\b`, info.cleaned) <= 1) {
+        issues.push({
+          severity: "warn",
+          kind: "dead_local",
+          comp: info.name,
+          detail: `local func ${fname}() defined but never called`,
+          file: info.file
+        });
+      }
+    }
+  }
+  const startup = pathe.join(srcDir, "startup.lua");
+  if (fs.existsSync(startup)) {
+    const startupClean = clean(fs.readFileSync(startup, "utf8"));
+    const seenMissing = /* @__PURE__ */ new Set();
+    for (const m of startupClean.matchAll(/\bfunc\.(\w+)\b/g)) {
+      const fname = m[1];
+      if (seenMissing.has(fname)) continue;
+      if (!allFuncDefs[fname]) {
+        seenMissing.add(fname);
+        issues.push({
+          severity: "error",
+          kind: "missing_func",
+          comp: "startup",
+          detail: `startup.lua calls func.${fname} \u2014 never defined anywhere`,
+          file: startup
+        });
+      }
+    }
+  }
+  if (!issues.length) {
+    pSection("Results");
+    pOk("No issues found", `${Object.keys(components).length} components analysed`);
+    console.log();
+    return;
+  }
+  const KIND_LABELS = {
+    dead_signal: "dead signal",
+    ghost_handler: "unknown handler",
+    ghost_ref: "ghost reference",
+    orphan_func: "orphan func.*",
+    dead_local: "dead local func",
+    missing_func: "missing func.*"
+  };
+  pSection("Issues");
+  const byComp = {};
+  for (const issue of issues) {
+    (byComp[issue.comp] ??= []).push(issue);
+  }
+  for (const compName of Object.keys(byComp).sort()) {
+    const compIssues = byComp[compName].sort((a, b) => {
+      const sa = a.severity === "error" ? 0 : 1;
+      const sb = b.severity === "error" ? 0 : 1;
+      return sa - sb || a.kind.localeCompare(b.kind) || a.detail.localeCompare(b.detail);
+    });
+    const fileTag = compIssues[0]?.file ? `  ${gray(pathe.relative(root, compIssues[0].file).replace(/\\/g, "/"))}` : "";
+    console.log(`
+    ${bold(compName)}${fileTag}`);
+    for (const issue of compIssues) {
+      const icon = issue.severity === "error" ? red("\u2717") : yellow("!");
+      const label = gray(`[${KIND_LABELS[issue.kind] ?? issue.kind}]`);
+      console.log(`       ${icon}  ${label}  ${issue.detail}`);
+    }
+  }
+  pHr();
+  const errors = issues.filter((i) => i.severity === "error").length;
+  const warns = issues.filter((i) => i.severity === "warn").length;
+  const parts = [];
+  if (errors) parts.push(red(`${errors} error${errors !== 1 ? "s" : ""}`));
+  if (warns) parts.push(yellow(`${warns} warning${warns !== 1 ? "s" : ""}`));
+  console.log(`
+    ${parts.join(", ")}  in ${Object.keys(byComp).length} component(s)
+`);
+}
+var SERVICE_EVENTS;
+var init_lint = __esm({
+  "src/commands/lint.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_project();
+    SERVICE_EVENTS = /* @__PURE__ */ new Set([
+      "Heartbeat",
+      "RenderStepped",
+      "Stepped",
+      "InputBegan",
+      "InputEnded",
+      "Respawn",
+      "CharacterAdded",
+      "CharacterRemoving"
+    ]);
+  }
+});
+
+// src/commands/obfuscate.ts
+var obfuscate_exports = {};
+__export(obfuscate_exports, {
+  cmdObfuscate: () => cmdObfuscate
+});
+async function cmdObfuscate(args) {
+  const root = requireProjectRoot();
+  const buildDir = pathe.join(root, "build");
+  pHeader("obfuscate");
+  if (!fs.existsSync(buildDir)) {
+    pFail("No build/ directory", "run  rb build --no-obfuscate  first");
+    process.exit(1);
+  }
+  const builds = fs.readdirSync(buildDir).filter((f) => f.endsWith(".lua") && !f.includes(".obf.") && !f.includes(".dev.")).map((f) => pathe.join(buildDir, f));
+  if (!builds.length) {
+    pFail("No build files found", "run  rb build --no-obfuscate  first");
+    process.exit(1);
+  }
+  pSection(`Found  ${gray(builds.map((b) => b.split("/").pop()).join(", "))}`);
+  const outputs = await obfuscatePipeline(builds, root);
+  if (args.copy && outputs.length) {
+    const toCopy = outputs.find((p) => !p.includes("compat")) ?? outputs[0];
+    copyToClipboard(fs.readFileSync(toCopy, "utf8"), toCopy.split("/").pop());
+  }
+}
+var init_obfuscate = __esm({
+  "src/commands/obfuscate.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_project();
+    init_obfuscator();
+  }
+});
+
+// src/commands/mcp.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  cmdMcp: () => cmdMcp,
+  printMcpSetup: () => printMcpSetup
+});
+async function cmdMcp(_args) {
+  let McpServer;
+  let StdioServerTransport;
+  let z;
+  try {
+    ;
+    ({ McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js'));
+    ({ StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js'));
+    ({ z } = await import('zod'));
+  } catch (e) {
+    pFail("MCP SDK not available", String(e?.message ?? ""));
+    pInfo("Run:  pnpm add @modelcontextprotocol/sdk zod");
+    process.exit(1);
+  }
+  const server = new McpServer({
+    name: "pulse-rb",
+    version: RB_VERSION
+  });
+  server.tool(
+    "build",
+    "Compile TypeScript / .rblua sources, obfuscate with Ironbrew2, output to build/.\nReturns the output file paths and a summary of errors if any.",
+    {
+      noObfuscate: z.boolean().optional().default(false).describe("Skip obfuscation \u2014 output plain Lua (faster for iteration)"),
+      noCompat: z.boolean().optional().default(false).describe("Skip the compat build (script.compat.lua)"),
+      dev: z.boolean().optional().default(false).describe("Also emit a dev build with the debug overlay (script.dev.lua)"),
+      preset: z.enum(["Low", "Medium", "Strong"]).optional().default("Medium").describe("Obfuscation strength")
+    },
+    async (args) => {
+      const { cmdBuild: cmdBuild2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+      const origLog = console.log.bind(console);
+      const origErr = console.error.bind(console);
+      const lines = [];
+      console.log = (...a) => lines.push(a.map(String).join(" "));
+      console.error = (...a) => lines.push(a.map(String).join(" "));
+      let exitCode = 0;
+      const origExit = process.exit.bind(process);
+      process.exit = (code) => {
+        exitCode = code ?? 0;
+      };
+      try {
+        await cmdBuild2({
+          noObfuscate: args.noObfuscate ?? false,
+          noCompat: args.noCompat ?? false,
+          dev: args.dev ?? false,
+          preset: args.preset ?? "Medium",
+          copy: false,
+          ui: void 0
+        });
+      } finally {
+        console.log = origLog;
+        console.error = origErr;
+        process.exit = origExit;
+      }
+      const text2 = lines.join("\n").replace(/\x1b\[[0-9;]*m/g, "");
+      return {
+        content: [{
+          type: "text",
+          text: exitCode === 0 ? `Build succeeded.
+
+${text2}` : `Build failed (exit ${exitCode}).
+
+${text2}`
+        }],
+        isError: exitCode !== 0
+      };
+    }
+  );
+  server.tool(
+    "check",
+    "Syntax-check the compiled output with luaparse without writing build files.",
+    {
+      compat: z.boolean().optional().default(false).describe("Check the compat build instead of standard")
+    },
+    async (args) => {
+      const { cmdCheck: cmdCheck2 } = await Promise.resolve().then(() => (init_check(), check_exports));
+      const lines = [];
+      const origLog = console.log.bind(console);
+      console.log = (...a) => lines.push(a.map(String).join(" "));
+      let exitCode = 0;
+      process.exit = (code) => {
+        exitCode = code ?? 0;
+      };
+      try {
+        cmdCheck2({ compat: args.compat ?? false });
+      } finally {
+        console.log = origLog;
+      }
+      const text2 = lines.join("\n").replace(/\x1b\[[0-9;]*m/g, "");
+      return {
+        content: [{ type: "text", text: text2 }],
+        isError: exitCode !== 0
+      };
+    }
+  );
+  server.tool(
+    "lint",
+    "Dead-code and connectivity analysis for .rblua component files.\nFinds: dead signals, ghost handlers, broken Components.* cross-references, orphaned func.* definitions.",
+    {},
+    async () => {
+      const { cmdLint: cmdLint2 } = await Promise.resolve().then(() => (init_lint(), lint_exports));
+      const lines = [];
+      const origLog = console.log.bind(console);
+      console.log = (...a) => lines.push(a.map(String).join(" "));
+      try {
+        cmdLint2({});
+      } finally {
+        console.log = origLog;
+      }
+      const text2 = lines.join("\n").replace(/\x1b\[[0-9;]*m/g, "");
+      return { content: [{ type: "text", text: text2 }] };
+    }
+  );
+  server.tool(
+    "status",
+    "Project summary: module count, last build size + timestamp, git status.",
+    {},
+    async () => {
+      const { cmdStatus: cmdStatus2 } = await Promise.resolve().then(() => (init_modules(), modules_exports));
+      const lines = [];
+      const origLog = console.log.bind(console);
+      console.log = (...a) => lines.push(a.map(String).join(" "));
+      try {
+        await cmdStatus2({});
+      } finally {
+        console.log = origLog;
+      }
+      const text2 = lines.join("\n").replace(/\x1b\[[0-9;]*m/g, "");
+      return { content: [{ type: "text", text: text2 }] };
+    }
+  );
+  server.tool(
+    "list",
+    "Show the module load order \u2014 the exact sequence files are concatenated into the build.",
+    {
+      compat: z.boolean().optional().default(false).describe("Show compat load order")
+    },
+    async (args) => {
+      const { cmdList: cmdList2 } = await Promise.resolve().then(() => (init_modules(), modules_exports));
+      const lines = [];
+      const origLog = console.log.bind(console);
+      console.log = (...a) => lines.push(a.map(String).join(" "));
+      try {
+        cmdList2({ compat: args.compat ?? false });
+      } finally {
+        console.log = origLog;
+      }
+      const text2 = lines.join("\n").replace(/\x1b\[[0-9;]*m/g, "");
+      return { content: [{ type: "text", text: text2 }] };
+    }
+  );
+  server.tool(
+    "new_module",
+    "Scaffold a new .rblua component file or a plain .lua helper module.",
+    {
+      path: z.string().describe('Relative path from src/ (e.g. "player/KillAura" or "misc/helpers/utils")'),
+      plain: z.boolean().optional().default(false).describe("Create a plain .lua file instead of a .rblua component")
+    },
+    async (args) => {
+      const { cmdNew: cmdNew2 } = await Promise.resolve().then(() => (init_modules(), modules_exports));
+      const lines = [];
+      const origLog = console.log.bind(console);
+      console.log = (...a) => lines.push(a.map(String).join(" "));
+      try {
+        cmdNew2({ type: "module", path: args.path, plain: args.plain ?? false });
+      } finally {
+        console.log = origLog;
+      }
+      const text2 = lines.join("\n").replace(/\x1b\[[0-9;]*m/g, "");
+      return { content: [{ type: "text", text: text2 }] };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+function printMcpSetup() {
+  pHeader("mcp \xB7 setup");
+  pSection("1 \xB7 Register with Claude Code  (once per machine)");
+  pHr();
+  console.log(`    ${cyan("claude mcp add pulse-rb -- rb mcp")}`);
+  console.log();
+  pSection("2 \xB7 Available MCP tools");
+  pHr();
+  const tools = [
+    ["build", "Compile + obfuscate \u2014 runs full rb build pipeline"],
+    ["check", "Syntax-check output with luaparse"],
+    ["lint", "Dead-code analysis on component files"],
+    ["status", "Project summary: modules, last build, git"],
+    ["list", "Show module load order"],
+    ["new_module", "Scaffold a new component or helper file"]
+  ];
+  for (const [name, desc] of tools) {
+    console.log(`    ${bold(name.padEnd(16))}${dim(desc)}`);
+  }
+  console.log();
+  pSection("3 \xB7 How Claude uses it");
+  pHr();
+  pInfo(`Claude can call ${bold("build")}, ${bold("lint")}, ${bold("status")} directly \u2014 no terminal needed.`);
+  pInfo(`Add this to ${bold("CLAUDE.md")} in your project:`);
+  console.log();
+  console.log(`    ${dim("## CLI")}`);
+  console.log(`    ${dim("Run `rb mcp` via Claude Code MCP integration.")}`);
+  console.log(`    ${dim("Claude can build, check, lint, and deploy directly.")}`);
+  console.log();
+}
+var init_mcp = __esm({
+  "src/commands/mcp.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_constants();
+  }
+});
+
+// src/commands/install.ts
+var install_exports = {};
+__export(install_exports, {
+  cmdInstall: () => cmdInstall,
+  cmdUpdate: () => cmdUpdate
+});
+function cmdInstall(_args) {
+  pHeader("install");
+  pInfo(`${bold("pulse-rb")} is now distributed via npm \u2014 no separate install step needed.`);
+  console.log();
+  console.log(`    ${dim("Global install:")}   pnpm add -g pulse-rb`);
+  console.log(`    ${dim("Project install:")}  pnpm add -D pulse-rb`);
+  console.log(`    ${dim("Zero install:")}     pnpm dlx pulse-rb init <name>`);
+  console.log();
+  pOk(`Current version  ${gray("v" + RB_VERSION)}`);
+  console.log();
+}
+async function cmdUpdate(_args) {
+  pHeader("update");
+  pInfo("Updating pulse-rb via pnpm...");
+  const isGlobal = !process.env["npm_execpath"];
+  try {
+    if (isGlobal) {
+      const { stdout } = await execa.execa("pnpm", ["add", "-g", `pulse-rb@latest`]);
+      pOk(`Updated globally  ${gray(stdout.trim().split("\n").at(-1) ?? "")}`);
+    } else {
+      const { stdout } = await execa.execa("pnpm", ["add", "-D", `pulse-rb@latest`]);
+      pOk(`Updated locally  ${gray(stdout.trim().split("\n").at(-1) ?? "")}`);
+    }
+  } catch (e) {
+    pFail("pnpm update failed", String(e?.message ?? "").split("\n")[0]);
+    pWarn("Try manually:  pnpm add -g pulse-rb@latest");
+  }
+  console.log();
+}
+var init_install = __esm({
+  "src/commands/install.ts"() {
+    init_cjs_shims();
+    init_ui();
+    init_constants();
+  }
+});
+
+// src/commands/ext.ts
+var ext_exports = {};
+__export(ext_exports, {
+  cmdExt: () => cmdExt
+});
+function vscodeExtDir() {
+  const home = process.env["USERPROFILE"] ?? process.env["HOME"] ?? __require("os").homedir();
+  return pathe.join(home, ".vscode", "extensions");
+}
+async function doInstall() {
+  pHeader("ext install");
+  pSection("Installing VS Code extension");
+  if (!fs.existsSync(EXT_SRC)) {
+    pFail("Extension source not found", EXT_SRC);
+    process.exit(1);
+  }
+  const extDir = vscodeExtDir();
+  if (!fs.existsSync(extDir)) {
+    pFail(
+      "VS Code extensions directory not found",
+      `Expected: ${extDir}  \u2014  make sure VS Code is installed.`
+    );
+    process.exit(1);
+  }
+  const oldDest = pathe.join(extDir, `rb-rblua-${EXT_VERSION}`);
+  if (fs.existsSync(oldDest)) await promises.rm(oldDest, { recursive: true, force: true });
+  const dest = pathe.join(extDir, EXT_ID);
+  if (fs.existsSync(dest)) await promises.rm(dest, { recursive: true, force: true });
+  await promises.cp(EXT_SRC, dest, { recursive: true });
+  pOk(`${bold(EXT_ID)}  \u2192  ${gray(dest)}`);
+  console.log();
+  pInfo("Reload VS Code to activate:");
+  console.log(`       Ctrl+Shift+P  \u2192  ${dim("Developer: Reload Window")}
+`);
+}
+async function cmdExt(args) {
+  if (args.sub === "install") {
+    await doInstall();
+  } else {
+    pFail("Missing subcommand", "usage:  rb ext install");
+    process.exit(1);
+  }
+}
+var EXT_SRC, EXT_VERSION, EXT_ID;
+var init_ext = __esm({
+  "src/commands/ext.ts"() {
+    init_cjs_shims();
+    init_ui();
+    EXT_SRC = pathe.join(__dirname, "..", "vscode");
+    EXT_VERSION = "1.0.0";
+    EXT_ID = `rb.rb-rblua-${EXT_VERSION}`;
+  }
+});
+
+// src/index.ts
+init_cjs_shims();
+init_constants();
+var main = citty.defineCommand({
+  meta: {
+    name: "rb",
+    version: RB_VERSION,
+    description: "rb \u2014 Pulse framework build tool for Roblox script projects"
+  },
+  subCommands: {
+    // ── build / compile ───────────────────────────────────────────────────────
+    build: citty.defineCommand({
+      meta: { description: "Compile + obfuscate script.lua and script.compat.lua" },
+      args: {
+        "no-compat": { type: "boolean", default: false, description: "Skip compat build" },
+        "no-obfuscate": { type: "boolean", default: false, description: "Skip obfuscation" },
+        preset: { type: "string", default: "Medium", description: "Obfuscation preset: Low | Medium | Strong" },
+        copy: { type: "boolean", default: false, description: "Copy standard build to clipboard after build" },
+        dev: { type: "boolean", default: false, description: "Also emit a dev build (script.dev.lua)" },
+        ui: { type: "string", description: "Override UI library (linoria | windui)" }
+      },
+      async run({ args }) {
+        const { cmdBuild: cmdBuild2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+        await cmdBuild2({
+          noCompat: Boolean(args["no-compat"]),
+          noObfuscate: Boolean(args["no-obfuscate"]),
+          preset: String(args.preset ?? "Medium"),
+          copy: Boolean(args.copy),
+          dev: Boolean(args.dev),
+          ui: args.ui ? String(args.ui) : void 0
+        });
+      }
+    }),
+    copy: citty.defineCommand({
+      meta: { description: "Compile and copy output to clipboard" },
+      args: {
+        compat: { type: "boolean", default: false, description: "Copy the compat build" }
+      },
+      async run({ args }) {
+        const { cmdCopy: cmdCopy2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+        await cmdCopy2({ compat: Boolean(args.compat) });
+      }
+    }),
+    clean: citty.defineCommand({
+      meta: { description: "Remove all built .lua files from build/" },
+      run() {
+        const { cmdClean: cmdClean2 } = (init_build(), __toCommonJS(build_exports));
+        cmdClean2({});
+      }
+    }),
+    // ── watch / check ─────────────────────────────────────────────────────────
+    watch: citty.defineCommand({
+      meta: { description: "Watch src/ and rebuild on changes  (Ctrl+C to stop)" },
+      args: {
+        compat: { type: "boolean", default: false, description: "Also rebuild compat build on every change" }
+      },
+      run({ args }) {
+        const { cmdWatch: cmdWatch2 } = (init_watch(), __toCommonJS(watch_exports));
+        cmdWatch2({ compat: Boolean(args.compat) });
+      }
+    }),
+    check: citty.defineCommand({
+      meta: { description: "Syntax-check the compiled output without writing build files" },
+      args: {
+        compat: { type: "boolean", default: false, description: "Check the compat build" }
+      },
+      run({ args }) {
+        const { cmdCheck: cmdCheck2 } = (init_check(), __toCommonJS(check_exports));
+        cmdCheck2({ compat: Boolean(args.compat) });
+      }
+    }),
+    // ── project scaffolding ───────────────────────────────────────────────────
+    init: citty.defineCommand({
+      meta: { description: "Scaffold a new Pulse project with package.json + git init" },
+      args: {
+        name: { type: "positional", required: true, description: "Project directory name" },
+        force: { type: "boolean", default: false, description: "Overwrite existing directory" }
+      },
+      async run({ args }) {
+        const { cmdInit: cmdInit2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+        await cmdInit2({ name: String(args.name), force: Boolean(args.force) });
+      }
+    }),
+    // ── module / remote management ────────────────────────────────────────────
+    new: citty.defineCommand({
+      meta: { description: "Create a new component module or remote stub" },
+      args: {
+        type: { type: "positional", required: true, description: "module | remote" },
+        path: { type: "positional", required: true, description: "Relative path (module) or name (remote)" },
+        plain: { type: "boolean", default: false, description: "Plain .lua file instead of .rblua component" }
+      },
+      run({ args }) {
+        const { cmdNew: cmdNew2 } = (init_modules(), __toCommonJS(modules_exports));
+        cmdNew2({ type: String(args.type), path: String(args.path), plain: Boolean(args.plain) });
+      }
+    }),
+    remove: citty.defineCommand({
+      meta: { description: "Interactively delete a module from src/" },
+      args: {
+        path: { type: "positional", required: true, description: "Relative path from src/" }
+      },
+      async run({ args }) {
+        const { cmdRemove: cmdRemove2 } = await Promise.resolve().then(() => (init_modules(), modules_exports));
+        await cmdRemove2({ path: String(args.path) });
+      }
+    }),
+    list: citty.defineCommand({
+      meta: { description: "Print the full module load order" },
+      args: {
+        compat: { type: "boolean", default: false, description: "Show compat load order" }
+      },
+      run({ args }) {
+        const { cmdList: cmdList2 } = (init_modules(), __toCommonJS(modules_exports));
+        cmdList2({ compat: Boolean(args.compat) });
+      }
+    }),
+    status: citty.defineCommand({
+      meta: { description: "Project summary: module count, last build, git status" },
+      async run() {
+        const { cmdStatus: cmdStatus2 } = await Promise.resolve().then(() => (init_modules(), modules_exports));
+        await cmdStatus2({});
+      }
+    }),
+    // ── git helpers ───────────────────────────────────────────────────────────
+    save: citty.defineCommand({
+      meta: { description: "git add -A && git commit (alias for quick checkpoints)" },
+      args: {
+        message: { type: "positional", required: false, description: "Commit message (defaults to timestamp)" }
+      },
+      async run({ args }) {
+        const { cmdSave: cmdSave2 } = await Promise.resolve().then(() => (init_git(), git_exports));
+        await cmdSave2({ message: args.message ? String(args.message) : void 0 });
+      }
+    }),
+    history: citty.defineCommand({
+      meta: { description: "Show recent git commits" },
+      args: {
+        n: { type: "string", default: "10", description: "Number of commits to show" }
+      },
+      async run({ args }) {
+        const { cmdHistory: cmdHistory2 } = await Promise.resolve().then(() => (init_git(), git_exports));
+        await cmdHistory2({ n: parseInt(String(args.n ?? "10"), 10) });
+      }
+    }),
+    restore: citty.defineCommand({
+      meta: { description: "git checkout <ref> -- .  (restore files to a past commit)" },
+      args: {
+        ref: { type: "positional", required: true, description: "Git ref: commit hash, tag, or branch" }
+      },
+      async run({ args }) {
+        const { cmdRestore: cmdRestore2 } = await Promise.resolve().then(() => (init_git(), git_exports));
+        await cmdRestore2({ ref: String(args.ref) });
+      }
+    }),
+    // ── deploy ────────────────────────────────────────────────────────────────
+    deploy: citty.defineCommand({
+      meta: { description: "Push script.obf.lua to GitHub and print the loadstring URL" },
+      args: {
+        token: { type: "string", description: "GitHub PAT (or set GITHUB_TOKEN in .rb-deploy)" },
+        repo: { type: "string", description: "GitHub repo e.g. user/my-release" },
+        file: { type: "string", description: "Filename in repo (default: script.obf.lua)" },
+        branch: { type: "string", description: "Branch (default: main)" }
+      },
+      async run({ args }) {
+        const { cmdDeploy: cmdDeploy2 } = await Promise.resolve().then(() => (init_deploy(), deploy_exports));
+        await cmdDeploy2({
+          token: args.token ? String(args.token) : void 0,
+          repo: args.repo ? String(args.repo) : void 0,
+          file: args.file ? String(args.file) : void 0,
+          branch: args.branch ? String(args.branch) : void 0
+        });
+      }
+    }),
+    // ── analysis ──────────────────────────────────────────────────────────────
+    lint: citty.defineCommand({
+      meta: { description: "Dead-code and connectivity analysis for .rblua component files" },
+      run() {
+        const { cmdLint: cmdLint2 } = (init_lint(), __toCommonJS(lint_exports));
+        cmdLint2({});
+      }
+    }),
+    // ── obfuscation ───────────────────────────────────────────────────────────
+    obfuscate: citty.defineCommand({
+      meta: { description: "Obfuscate existing build files without recompiling" },
+      args: {
+        copy: { type: "boolean", default: false, description: "Copy standard obfuscated build to clipboard" }
+      },
+      async run({ args }) {
+        const { cmdObfuscate: cmdObfuscate2 } = await Promise.resolve().then(() => (init_obfuscate(), obfuscate_exports));
+        await cmdObfuscate2({ copy: Boolean(args.copy) });
+      }
+    }),
+    // ── docs / ai ─────────────────────────────────────────────────────────────
+    docs: citty.defineCommand({
+      meta: { description: "Generate PULSE_DOCS.md \u2014 full framework reference for LLMs" },
+      args: {
+        output: { type: "string", description: "Output path (default: PULSE_DOCS.md, use - for stdout)" }
+      },
+      run({ args }) {
+        const { cmdDocs: cmdDocs2 } = (init_docs(), __toCommonJS(docs_exports));
+        cmdDocs2({ output: args.output ? String(args.output) : void 0 });
+      }
+    }),
+    mcp: citty.defineCommand({
+      meta: { description: "Start MCP server (used by Claude Code) or print setup instructions" },
+      args: {
+        setup: { type: "boolean", default: false, description: "Print setup instructions instead of starting the server" }
+      },
+      async run({ args }) {
+        if (args.setup) {
+          const { printMcpSetup: printMcpSetup2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+          printMcpSetup2();
+        } else {
+          const { cmdMcp: cmdMcp2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+          await cmdMcp2({});
+        }
+      }
+    }),
+    // ── publish (R2 CDN) ──────────────────────────────────────────────────────
+    publish: citty.defineCommand({
+      meta: { description: "Upload Pulse runtime files to Cloudflare R2 (enables --cdn builds)" },
+      async run() {
+        const { cmdPublish: cmdPublish2 } = await Promise.resolve().then(() => (init_publish(), publish_exports));
+        await cmdPublish2({});
+      }
+    }),
+    // ── toolchain ─────────────────────────────────────────────────────────────
+    install: citty.defineCommand({
+      meta: { description: "Show npm install instructions (pulse-rb is distributed via npm)" },
+      run() {
+        const { cmdInstall: cmdInstall2 } = (init_install(), __toCommonJS(install_exports));
+        cmdInstall2({});
+      }
+    }),
+    update: citty.defineCommand({
+      meta: { description: "Update pulse-rb to the latest version via pnpm" },
+      async run() {
+        const { cmdUpdate: cmdUpdate2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+        await cmdUpdate2({});
+      }
+    }),
+    ext: citty.defineCommand({
+      meta: { description: "Install the rb VS Code extension (.rblua syntax highlighting)" },
+      subCommands: {
+        install: citty.defineCommand({
+          meta: { description: "Copy extension to ~/.vscode/extensions/" },
+          async run() {
+            const { cmdExt: cmdExt2 } = await Promise.resolve().then(() => (init_ext(), ext_exports));
+            await cmdExt2({ sub: "install" });
+          }
+        })
+      }
+    })
+  }
+});
+citty.runMain(main);