@iroaxel/arcena 4.3.157

package/dist/chunk-YKKUCYNE.js

@@ -0,0 +1,2305 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-YNWFCUMR.js";
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+init_esm_shims();
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+init_esm_shims();
+import process2 from "process";
+import os from "os";
+import tty from "tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+init_esm_shims();
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// ../gg-pixel/dist/index.js
+init_esm_shims();
+import { createRequire } from "module";
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  writeFileSync,
+  appendFileSync,
+  mkdirSync as mkdirSync2,
+  readdirSync
+} from "fs";
+import { createRequire as createRequire2 } from "module";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2, relative, resolve, sep } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import { spawn as nodeSpawn } from "child_process";
+import { writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { randomBytes } from "crypto";
+var requireBSQ = createRequire(import.meta.url);
+var nodeRequire = createRequire2(import.meta.url);
+var DEFAULT_INGEST_URL = "https://gg-pixel-server.buzzbeamaustralia.workers.dev";
+async function install(opts = {}) {
+  const cwd = resolve(opts.cwd ?? process.cwd());
+  const ingestUrl = (opts.ingestUrl ?? DEFAULT_INGEST_URL).replace(/\/+$/, "");
+  const fetchFn = opts.fetchFn ?? fetch;
+  const home = opts.homeDir ?? homedir2();
+  const nodeRoot = findProjectRoot(cwd);
+  const pythonRoot = findPythonProjectRoot(cwd);
+  const goRoot = findGoProjectRoot(cwd);
+  const rubyRoot = findRubyProjectRoot(cwd);
+  if (!nodeRoot && !pythonRoot && !goRoot && !rubyRoot) {
+    throw new Error(
+      `No project found at ${cwd}: looked for package.json, pyproject.toml/setup.py/requirements.txt/Pipfile, go.mod, Gemfile/*.gemspec.`
+    );
+  }
+  const closestRoot = pickClosestRoot([nodeRoot, pythonRoot, goRoot, rubyRoot]);
+  if (closestRoot === goRoot && goRoot) {
+    return installGo({ projectRoot: goRoot, opts, ingestUrl, fetchFn, home });
+  }
+  if (closestRoot === rubyRoot && rubyRoot) {
+    return installRuby({ projectRoot: rubyRoot, opts, ingestUrl, fetchFn, home });
+  }
+  if (closestRoot === pythonRoot && pythonRoot) {
+    return installPython({ projectRoot: pythonRoot, opts, ingestUrl, fetchFn, home });
+  }
+  if (!nodeRoot) {
+    throw new Error("Internal: closest root is Node but nodeRoot is null");
+  }
+  const pkgPath = join2(nodeRoot, "package.json");
+  const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+  const projectName = opts.projectName ?? pkg.name ?? nodeRoot.split("/").pop() ?? "unnamed";
+  const kind = detectJsProjectKind(pkg, nodeRoot);
+  const projectsJsonPath = join2(home, ".gg", "projects.json");
+  const envFilePath = join2(nodeRoot, ".env");
+  const existing = findMappingByPath(projectsJsonPath, nodeRoot);
+  const existingKey = readEnvKey(envFilePath, "GG_PIXEL_KEY");
+  let created;
+  let reused = false;
+  if (existing && existing.secret && existingKey) {
+    created = { id: existing.id, key: existingKey, secret: existing.secret };
+    reused = true;
+  } else {
+    created = await createProject(fetchFn, ingestUrl, projectName);
+  }
+  const pm = detectPackageManager(nodeRoot);
+  const packageInstalled = opts.skipPackageInstall ? false : runInstall(nodeRoot, pm, "@iroaxel/gg-pixel");
+  const wired = wireFramework({
+    kind,
+    projectRoot: nodeRoot,
+    pkg,
+    projectKey: created.key,
+    ingestUrl
+  });
+  if (kind !== "browser" && kind !== "tauri") {
+    writeEnvKey(envFilePath, "GG_PIXEL_KEY", created.key);
+  }
+  writeProjectsMapping(projectsJsonPath, created.id, projectName, nodeRoot, created.secret);
+  return {
+    projectId: created.id,
+    projectKey: created.key,
+    projectSecret: created.secret,
+    projectName,
+    projectKind: kind,
+    projectRoot: nodeRoot,
+    initFilePath: wired.primaryInitPath,
+    envFilePath,
+    projectsJsonPath,
+    packageManager: pm,
+    packageInstalled,
+    entryWiring: wired.entryWiring,
+    reused,
+    secondaryInit: wired.secondaryInit,
+    warnings: wired.warnings
+  };
+}
+function findMappingByPath(projectsJsonPath, projectRoot) {
+  if (!existsSync2(projectsJsonPath)) return null;
+  let map;
+  try {
+    map = JSON.parse(readFileSync2(projectsJsonPath, "utf8"));
+  } catch {
+    return null;
+  }
+  let fallback = null;
+  for (const [id, entry] of Object.entries(map)) {
+    if (entry.path !== projectRoot) continue;
+    if (entry.secret) return { id, ...entry };
+    if (!fallback) fallback = { id, ...entry };
+  }
+  return fallback;
+}
+function readEnvKey(envPath, key) {
+  if (!existsSync2(envPath)) return null;
+  try {
+    const content = readFileSync2(envPath, "utf8");
+    const match = new RegExp(`^${key}=(.+)$`, "m").exec(content);
+    return match?.[1]?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+function findProjectRoot(start) {
+  let dir = start;
+  for (let i = 0; i < 20; i++) {
+    if (existsSync2(join2(dir, "package.json"))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+async function createProject(fetchFn, ingestUrl, name) {
+  const res = await fetchFn(`${ingestUrl}/api/projects`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ name })
+  });
+  if (!res.ok) {
+    throw new Error(`POST /api/projects failed: ${res.status} ${await safeText(res)}`);
+  }
+  const body = await res.json();
+  if (!body.id || !body.key || !body.secret) {
+    throw new Error("response missing id/key/secret");
+  }
+  return { id: body.id, key: body.key, secret: body.secret };
+}
+async function safeText(r) {
+  try {
+    return await r.text();
+  } catch {
+    return "";
+  }
+}
+function detectPackageManager(projectRoot) {
+  if (existsSync2(join2(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join2(projectRoot, "bun.lock")) || existsSync2(join2(projectRoot, "bun.lockb"))) {
+    return "bun";
+  }
+  if (existsSync2(join2(projectRoot, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function runInstall(projectRoot, pm, pkg) {
+  const cmd = pm;
+  const args = pm === "npm" ? ["install", pkg, "--no-audit", "--no-fund"] : ["add", pkg];
+  const result = spawnSync2(cmd, args, { cwd: projectRoot, stdio: "inherit" });
+  return result.status === 0;
+}
+function renderInitFile(ingestUrl, projectKey) {
+  const fallback = projectKey ? ` || ${JSON.stringify(projectKey)}` : "";
+  return `import { initPixel } from "@iroaxel/gg-pixel";
+
+const key = process.env.GG_PIXEL_KEY${fallback};
+if (key) {
+  initPixel({
+    projectKey: key,
+    sink: { kind: "http", ingestUrl: ${JSON.stringify(`${ingestUrl}/ingest`)} },
+  });
+}
+`;
+}
+function renderInitFileCjs(ingestUrl, projectKey) {
+  const fallback = projectKey ? ` || ${JSON.stringify(projectKey)}` : "";
+  return `const { initPixel } = require("@iroaxel/gg-pixel");
+
+const key = process.env.GG_PIXEL_KEY${fallback};
+if (key) {
+  initPixel({
+    projectKey: key,
+    sink: { kind: "http", ingestUrl: ${JSON.stringify(`${ingestUrl}/ingest`)} },
+  });
+}
+`;
+}
+function writeEnvKey(envPath, key, value) {
+  if (existsSync2(envPath)) {
+    const current = readFileSync2(envPath, "utf8");
+    const lineRegex = new RegExp(`^${key}=.*$`, "m");
+    if (lineRegex.test(current)) {
+      writeFileSync(envPath, current.replace(lineRegex, `${key}=${value}`), "utf8");
+      return;
+    }
+    const sep2 = current.endsWith("\n") || current.length === 0 ? "" : "\n";
+    appendFileSync(envPath, `${sep2}${key}=${value}
+`, "utf8");
+    return;
+  }
+  writeFileSync(envPath, `${key}=${value}
+`, "utf8");
+}
+function wireEntryFile(projectRoot, initFilePath, pkg) {
+  const entryPath = findEntryFile(projectRoot, pkg);
+  if (!entryPath) return { kind: "no_entry_found" };
+  let content;
+  try {
+    content = readFileSync2(entryPath, "utf8");
+  } catch (err) {
+    return { kind: "skipped", reason: `unreadable: ${err.message}` };
+  }
+  if (content.includes("gg-pixel.init")) {
+    return { kind: "already_present", entryPath };
+  }
+  const fromDir = dirname2(entryPath);
+  let spec = relative(fromDir, initFilePath).split(sep).join("/");
+  if (!spec.startsWith(".")) spec = "./" + spec;
+  const isCjs = isCommonJsEntry(entryPath, pkg);
+  const importLine = isCjs ? `require(${JSON.stringify(spec)});` : `import ${JSON.stringify(spec)};`;
+  const lines = content.split("\n");
+  let insertAt = 0;
+  if (lines[0]?.startsWith("#!")) insertAt = 1;
+  while (insertAt < lines.length && /^\s*(?:["']use strict["']|\/\/|\/\*)/.test(lines[insertAt] ?? "")) {
+    insertAt++;
+  }
+  const updated = [...lines.slice(0, insertAt), importLine, ...lines.slice(insertAt)].join("\n");
+  writeFileSync(entryPath, updated, "utf8");
+  return { kind: "injected", entryPath };
+}
+function findEntryFile(projectRoot, pkg) {
+  const tryPath = (rel) => {
+    const p = join2(projectRoot, rel);
+    if (existsSync2(p)) return p;
+    if (rel.endsWith(".js")) {
+      const ts = join2(projectRoot, rel.replace(/\.js$/, ".ts"));
+      if (existsSync2(ts)) return ts;
+    }
+    return null;
+  };
+  if (typeof pkg.bin === "string") {
+    const found = tryPath(pkg.bin);
+    if (found) return found;
+  }
+  if (pkg.bin && typeof pkg.bin === "object") {
+    for (const value of Object.values(pkg.bin)) {
+      if (typeof value === "string") {
+        const found = tryPath(value);
+        if (found) return found;
+      }
+    }
+  }
+  if (pkg.main) {
+    const found = tryPath(pkg.main);
+    if (found) return found;
+  }
+  if (pkg.module) {
+    const found = tryPath(pkg.module);
+    if (found) return found;
+  }
+  const candidates = [
+    "src/index.ts",
+    "src/index.tsx",
+    "src/index.js",
+    "src/index.mjs",
+    "src/main.ts",
+    "src/main.tsx",
+    "src/main.js",
+    "src/server.ts",
+    "src/server.js",
+    "src/app.ts",
+    "src/app.js",
+    "src/cli.ts",
+    "src/cli.js",
+    "index.ts",
+    "index.tsx",
+    "index.js",
+    "index.mjs",
+    "main.ts",
+    "main.js",
+    "server.ts",
+    "server.js",
+    "app.ts",
+    "app.js"
+  ];
+  for (const c of candidates) {
+    const found = tryPath(c);
+    if (found) return found;
+  }
+  return null;
+}
+function isCommonJsEntry(entryPath, pkg) {
+  if (entryPath.endsWith(".cjs")) return true;
+  if (entryPath.endsWith(".mjs")) return false;
+  if (entryPath.endsWith(".ts") || entryPath.endsWith(".tsx")) return false;
+  return pkg.type !== "module";
+}
+function detectJsProjectKind(pkg, projectRoot) {
+  const all = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  if (existsSync2(join2(projectRoot, "wrangler.toml")) || existsSync2(join2(projectRoot, "wrangler.jsonc")) || existsSync2(join2(projectRoot, "wrangler.json"))) {
+    return "cloudflare-workers";
+  }
+  if ("electron" in all) return "electron";
+  if (existsSync2(join2(projectRoot, "src-tauri")) || "@tauri-apps/api" in all) return "tauri";
+  if ("react-native" in all) return "react-native";
+  if ("next" in all) return "nextjs";
+  if ("@sveltejs/kit" in all) return "sveltekit";
+  if ("nuxt" in all || "nuxt3" in all) return "nuxt";
+  if ("@remix-run/react" in all || "@remix-run/node" in all) return "remix";
+  if (isBrowserProject(pkg, projectRoot)) return "browser";
+  return "node";
+}
+function wireFramework(w) {
+  switch (w.kind) {
+    case "node":
+      return wireNode(w);
+    case "browser":
+      return wireBrowser(w);
+    case "nextjs":
+      return wireNextjs(w);
+    case "sveltekit":
+      return wireSveltekit(w);
+    case "nuxt":
+      return wireNuxt(w);
+    case "remix":
+      return wireRemix(w);
+    case "electron":
+      return wireElectron(w);
+    case "tauri":
+      return wireTauri(w);
+    case "react-native":
+      return wireReactNative(w);
+    case "cloudflare-workers":
+      return wireWorkers(w);
+    case "python":
+    case "go":
+    case "ruby":
+      throw new Error(`Internal: ${w.kind} should have been handled earlier`);
+  }
+}
+function wireNode({ projectRoot, pkg, projectKey, ingestUrl }) {
+  const initPath = join2(projectRoot, "gg-pixel.init.mjs");
+  writeFileSync(initPath, renderInitFile(ingestUrl, projectKey), "utf8");
+  return {
+    primaryInitPath: initPath,
+    entryWiring: wireEntryFile(projectRoot, initPath, pkg),
+    warnings: []
+  };
+}
+function wireBrowser({ projectRoot, pkg, projectKey, ingestUrl }) {
+  const initPath = join2(projectRoot, "gg-pixel.init.mjs");
+  writeFileSync(initPath, renderBrowserInitFile(ingestUrl, projectKey), "utf8");
+  return {
+    primaryInitPath: initPath,
+    entryWiring: wireEntryFile(projectRoot, initPath, pkg),
+    warnings: []
+  };
+}
+function wireNextjs({ projectRoot, projectKey, ingestUrl }) {
+  const warnings = [];
+  const serverInitPath = pickPath(projectRoot, ["instrumentation.ts", "instrumentation.js"]);
+  const finalServerPath = serverInitPath ?? join2(projectRoot, "instrumentation.ts");
+  writeNextInstrumentation(finalServerPath, ingestUrl, projectKey);
+  patchNextConfig(projectRoot);
+  const clientInitPath = join2(projectRoot, "gg-pixel.client.tsx");
+  writeFileSync(clientInitPath, renderNextClientComponent(ingestUrl, projectKey), "utf8");
+  const layoutPath = findNextLayout(projectRoot);
+  let entryWiring;
+  if (!layoutPath) {
+    warnings.push(
+      'Could not auto-wire the Next.js client init \u2014 no app/layout.{tsx,jsx} or pages/_app.{tsx,jsx} found. Add `<GGPixelClient />` from "./gg-pixel.client" to your root layout/_app.'
+    );
+    entryWiring = { kind: "no_entry_found" };
+  } else {
+    entryWiring = injectNextClientComponent(layoutPath, clientInitPath);
+  }
+  return {
+    primaryInitPath: clientInitPath,
+    entryWiring,
+    secondaryInit: {
+      path: finalServerPath,
+      description: "Next.js server instrumentation (auto-loaded by Next runtime)"
+    },
+    warnings
+  };
+}
+function writeNextInstrumentation(path, ingestUrl, projectKey) {
+  const existing = existsSync2(path) ? readFileSync2(path, "utf8") : "";
+  const cleaned = stripLegacyPixelContent(existing);
+  const block = nextInstrumentationBlock(ingestUrl, projectKey);
+  const next = upsertPixelBlock(cleaned, block);
+  if (next !== existing) writeFileSync(path, next, "utf8");
+}
+function nextInstrumentationBlock(ingestUrl, projectKey) {
+  const fallback = projectKey ? ` ?? ${JSON.stringify(projectKey)}` : "";
+  return `// Next.js auto-loads this file on server start. Pixel hooks the
+// uncaughtExceptionMonitor + unhandledRejection events for API routes,
+// Server Components, and route handlers.
+export async function register() {
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    const { initPixel } = await import("@iroaxel/gg-pixel");
+    initPixel({
+      projectKey: process.env.GG_PIXEL_KEY${fallback},
+      sink: { kind: "http", ingestUrl: ${JSON.stringify(`${ingestUrl}/ingest`)} },
+    });
+  }
+}`;
+}
+function findNextLayout(projectRoot) {
+  const candidates = [
+    "app/layout.tsx",
+    "app/layout.jsx",
+    "app/layout.ts",
+    "src/app/layout.tsx",
+    "src/app/layout.jsx",
+    "pages/_app.tsx",
+    "pages/_app.jsx",
+    "src/pages/_app.tsx",
+    "src/pages/_app.jsx"
+  ];
+  for (const c of candidates) {
+    const p = join2(projectRoot, c);
+    if (existsSync2(p)) return p;
+  }
+  return null;
+}
+function renderNextClientComponent(ingestUrl, projectKey) {
+  return `"use client";
+// Client-only pixel init. Rendered from the root layout. The "use client"
+// directive guarantees this module never executes during server-side
+// rendering \u2014 \`window.onerror\` references would otherwise crash builds.
+import { useEffect } from "react";
+import { initPixel } from "@iroaxel/gg-pixel/browser";
+
+let inited = false;
+
+export default function GGPixelClient() {
+  useEffect(() => {
+    if (inited) return;
+    inited = true;
+    initPixel({
+      projectKey: ${JSON.stringify(projectKey)},
+      ingestUrl: ${JSON.stringify(ingestUrl)},
+    });
+  }, []);
+  return null;
+}
+`;
+}
+function injectNextClientComponent(layoutPath, clientInitPath) {
+  let content;
+  try {
+    content = readFileSync2(layoutPath, "utf8");
+  } catch (err) {
+    return { kind: "skipped", reason: `unreadable: ${err.message}` };
+  }
+  if (content.includes("GGPixelClient") || content.includes("@iroaxel/gg-pixel")) {
+    return { kind: "already_present", entryPath: layoutPath };
+  }
+  const fromDir = dirname2(layoutPath);
+  let spec = relative(fromDir, clientInitPath).split(sep).join("/");
+  if (!spec.startsWith(".")) spec = "./" + spec;
+  spec = spec.replace(/\.tsx$/, "");
+  const astResult = injectClientComponentViaAst(layoutPath, content, spec);
+  if (astResult) return astResult;
+  return injectClientComponentViaRegex(layoutPath, content, spec);
+}
+function injectClientComponentViaAst(layoutPath, content, importSpec) {
+  let recast;
+  let bp;
+  let bt;
+  try {
+    recast = nodeRequire("recast");
+    bp = nodeRequire("@babel/parser");
+    bt = nodeRequire("@babel/types");
+  } catch {
+    return null;
+  }
+  let ast;
+  try {
+    ast = recast.parse(content, {
+      parser: {
+        parse: (src) => bp.parse(src, {
+          sourceType: "module",
+          plugins: ["jsx", "typescript"],
+          allowImportExportEverywhere: true,
+          tokens: true
+        })
+      }
+    });
+  } catch {
+    return null;
+  }
+  const program = ast.program;
+  if (!program || !Array.isArray(program.body)) return null;
+  const bodyEl = findFirstJsxElementByName(ast, "body");
+  if (!bodyEl) return null;
+  const newComponent = bt.jsxElement(
+    bt.jsxOpeningElement(bt.jsxIdentifier("GGPixelClient"), [], true),
+    null,
+    [],
+    true
+  );
+  const leadingText = bt.jsxText("\n        ");
+  const trailingText = bt.jsxText("\n        ");
+  bodyEl.children = [leadingText, newComponent, trailingText, ...bodyEl.children];
+  const importDecl = bt.importDeclaration(
+    [bt.importDefaultSpecifier(bt.identifier("GGPixelClient"))],
+    bt.stringLiteral(importSpec)
+  );
+  const body = program.body;
+  let insertAt = 0;
+  for (let i = 0; i < body.length; i++) {
+    if (body[i]?.type === "ImportDeclaration") insertAt = i + 1;
+  }
+  body.splice(insertAt, 0, importDecl);
+  let out;
+  try {
+    out = recast.print(ast).code;
+  } catch {
+    return null;
+  }
+  writeFileSync(layoutPath, out, "utf8");
+  return { kind: "injected", entryPath: layoutPath };
+}
+function findFirstJsxElementByName(ast, name) {
+  let found = null;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const MAX_DEPTH = 500;
+  const SKIP_KEYS = /* @__PURE__ */ new Set([
+    "loc",
+    "tokens",
+    "original",
+    "comments",
+    "leadingComments",
+    "trailingComments",
+    "innerComments",
+    "range",
+    "start",
+    "end"
+  ]);
+  function walk(node, depth) {
+    if (found || !node || typeof node !== "object") return;
+    if (depth > MAX_DEPTH) return;
+    if (seen.has(node)) return;
+    seen.add(node);
+    if (Array.isArray(node)) {
+      for (const c of node) walk(c, depth + 1);
+      return;
+    }
+    const n = node;
+    if (n.type === "JSXElement") {
+      const opening = n.openingElement;
+      if (opening?.type === "JSXOpeningElement" && opening.name) {
+        const namedNode = opening.name;
+        if (namedNode.type === "JSXIdentifier" && namedNode.name === name) {
+          found = n;
+          return;
+        }
+      }
+    }
+    for (const key of Object.keys(n)) {
+      if (SKIP_KEYS.has(key)) continue;
+      walk(n[key], depth + 1);
+    }
+  }
+  walk(ast, 0);
+  return found;
+}
+function injectClientComponentViaRegex(layoutPath, content, spec) {
+  const importLine = `import GGPixelClient from ${JSON.stringify(spec)};`;
+  const lines = content.split("\n");
+  let insertImportAt = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^\s*import\s/.test(lines[i] ?? "")) insertImportAt = i + 1;
+  }
+  lines.splice(insertImportAt, 0, importLine);
+  const updated = lines.join("\n");
+  const childrenIdx = updated.lastIndexOf("{children}");
+  if (childrenIdx === -1) {
+    writeFileSync(layoutPath, updated, "utf8");
+    return {
+      kind: "skipped",
+      reason: "added import but couldn't find {children} to render <GGPixelClient />"
+    };
+  }
+  const before = updated.slice(0, childrenIdx);
+  const after = updated.slice(childrenIdx);
+  const finalContent = before + "<GGPixelClient />\n        " + after;
+  writeFileSync(layoutPath, finalContent, "utf8");
+  return { kind: "injected", entryPath: layoutPath };
+}
+function patchNextConfig(projectRoot) {
+  const candidates = ["next.config.ts", "next.config.mjs", "next.config.js", "next.config.cjs"];
+  let configPath = null;
+  for (const c of candidates) {
+    const p = join2(projectRoot, c);
+    if (existsSync2(p)) {
+      configPath = p;
+      break;
+    }
+  }
+  if (!configPath) {
+    configPath = join2(projectRoot, "next.config.ts");
+    writeFileSync(
+      configPath,
+      `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  // Keeps Next's bundler from trying to compile better-sqlite3 (native dep).
+  serverExternalPackages: ["@iroaxel/gg-pixel"],
+};
+
+export default nextConfig;
+`,
+      "utf8"
+    );
+    return;
+  }
+  patchNextConfigViaAst(configPath);
+}
+var PIXEL_PKG = "@iroaxel/gg-pixel";
+function patchNextConfigViaAst(configPath) {
+  const original = readFileSync2(configPath, "utf8");
+  if (original.includes(PIXEL_PKG)) return;
+  let parseModule;
+  let generateCode;
+  try {
+    const mod = nodeRequire("magicast");
+    parseModule = mod.parseModule;
+    generateCode = mod.generateCode;
+  } catch {
+    return patchNextConfigViaRegex(configPath, original);
+  }
+  let module_;
+  try {
+    module_ = parseModule(original);
+  } catch {
+    return patchNextConfigViaRegex(configPath, original);
+  }
+  const cfg = resolveNextConfigObject(module_);
+  if (!cfg) {
+    return patchNextConfigViaRegex(configPath, original);
+  }
+  const existing = cfg.serverExternalPackages;
+  const isArrayLike = Array.isArray(existing) || typeof existing === "object" && existing !== null && existing.$type === "array";
+  if (isArrayLike) {
+    const arr = existing;
+    if (arr.includes(PIXEL_PKG)) return;
+    arr.push(PIXEL_PKG);
+  } else {
+    cfg.serverExternalPackages = [PIXEL_PKG];
+  }
+  const out = generateCode(module_).code;
+  if (out !== original) writeFileSync(configPath, out, "utf8");
+}
+function resolveNextConfigObject(mod) {
+  const root = mod.exports.default ?? mod.exports;
+  if (!root) return null;
+  return unwrapWrappers(root);
+}
+function unwrapWrappers(node) {
+  let cur = node;
+  for (let i = 0; i < 6; i++) {
+    if (cur.$type === "function-call") {
+      const args = cur.$args ?? [];
+      const objArg = args.find(
+        (a) => typeof a === "object" && a !== null && a.$type !== "function-call"
+      );
+      if (!objArg) return null;
+      cur = objArg;
+      continue;
+    }
+    if (cur.$type === "object" || cur.$type === void 0) return cur;
+    return null;
+  }
+  return null;
+}
+function patchNextConfigViaRegex(configPath, content) {
+  if (content.includes(PIXEL_PKG)) return;
+  if (content.includes("serverExternalPackages")) {
+    const updated = content.replace(
+      /serverExternalPackages\s*:\s*\[([^\]]*)\]/,
+      (_match, inside) => {
+        const trimmed = inside.trim();
+        const sep2 = trimmed.length > 0 ? ", " : "";
+        return `serverExternalPackages: [${trimmed}${sep2}${JSON.stringify(PIXEL_PKG)}]`;
+      }
+    );
+    if (updated !== content) writeFileSync(configPath, updated, "utf8");
+    return;
+  }
+  const objStart = /(const\s+\w+\s*(?::\s*\w+)?\s*=\s*\{|module\.exports\s*=\s*\{|export\s+default\s*\{)/;
+  const m = objStart.exec(content);
+  if (m) {
+    const insertAt = m.index + m[0].length;
+    const updated = content.slice(0, insertAt) + `
+  serverExternalPackages: [${JSON.stringify(PIXEL_PKG)}],` + content.slice(insertAt);
+    writeFileSync(configPath, updated, "utf8");
+  }
+}
+function wireSveltekit({ projectRoot, projectKey, ingestUrl }) {
+  const serverPath = join2(projectRoot, "src/hooks.server.ts");
+  const clientPath = join2(projectRoot, "src/hooks.client.ts");
+  if (!existsSync2(dirname2(serverPath))) mkdirSync2(dirname2(serverPath), { recursive: true });
+  upsertPixelBlockInFile(
+    serverPath,
+    `import { initPixel } from "@iroaxel/gg-pixel";
+initPixel({
+  projectKey: process.env.GG_PIXEL_KEY ?? ${JSON.stringify(projectKey)},
+  sink: { kind: "http", ingestUrl: ${JSON.stringify(`${ingestUrl}/ingest`)} },
+});`
+  );
+  upsertPixelBlockInFile(
+    clientPath,
+    `import { initPixel } from "@iroaxel/gg-pixel/browser";
+initPixel({
+  projectKey: ${JSON.stringify(projectKey)},
+  ingestUrl: ${JSON.stringify(ingestUrl)},
+});`
+  );
+  return {
+    primaryInitPath: clientPath,
+    entryWiring: { kind: "injected", entryPath: clientPath },
+    secondaryInit: {
+      path: serverPath,
+      description: "SvelteKit server hooks (auto-loaded)"
+    },
+    warnings: []
+  };
+}
+function wireNuxt({ projectRoot, projectKey, ingestUrl }) {
+  const pluginsDir = join2(projectRoot, "plugins");
+  mkdirSync2(pluginsDir, { recursive: true });
+  const serverPath = join2(pluginsDir, "gg-pixel.server.ts");
+  const clientPath = join2(pluginsDir, "gg-pixel.client.ts");
+  writeFileSync(
+    serverPath,
+    `import { initPixel } from "@iroaxel/gg-pixel";
+export default defineNuxtPlugin(() => {
+  initPixel({
+    projectKey: process.env.GG_PIXEL_KEY ?? ${JSON.stringify(projectKey)},
+    sink: { kind: "http", ingestUrl: ${JSON.stringify(`${ingestUrl}/ingest`)} },
+  });
+});
+`,
+    "utf8"
+  );
+  writeFileSync(
+    clientPath,
+    `import { initPixel } from "@iroaxel/gg-pixel/browser";
+export default defineNuxtPlugin(() => {
+  initPixel({
+    projectKey: ${JSON.stringify(projectKey)},
+    ingestUrl: ${JSON.stringify(ingestUrl)},
+  });
+});
+`,
+    "utf8"
+  );
+  return {
+    primaryInitPath: clientPath,
+    entryWiring: { kind: "injected", entryPath: clientPath },
+    secondaryInit: { path: serverPath, description: "Nuxt server plugin (auto-loaded)" },
+    warnings: []
+  };
+}
+function wireRemix({ projectRoot, projectKey, ingestUrl }) {
+  const serverPath = pickPath(projectRoot, ["app/entry.server.tsx", "app/entry.server.jsx"]);
+  const clientPath = pickPath(projectRoot, ["app/entry.client.tsx", "app/entry.client.jsx"]);
+  const warnings = [];
+  const clientInitPath = join2(projectRoot, "gg-pixel.client.mjs");
+  writeFileSync(clientInitPath, renderBrowserInitFile(ingestUrl, projectKey), "utf8");
+  if (clientPath) {
+    injectImport(clientPath, clientInitPath);
+  } else {
+    warnings.push(
+      "No app/entry.client.tsx found. Run `npx remix reveal` then re-run pixel install."
+    );
+  }
+  const serverInitPath = join2(projectRoot, "gg-pixel.server.mjs");
+  writeFileSync(serverInitPath, renderInitFile(ingestUrl), "utf8");
+  let serverEntry = { kind: "no_entry_found" };
+  if (serverPath) {
+    serverEntry = injectImport(serverPath, serverInitPath);
+  } else {
+    warnings.push(
+      "No app/entry.server.tsx found. Run `npx remix reveal` then re-run pixel install."
+    );
+  }
+  void serverEntry;
+  return {
+    primaryInitPath: clientInitPath,
+    entryWiring: clientPath ? { kind: "injected", entryPath: clientPath } : { kind: "no_entry_found" },
+    secondaryInit: { path: serverInitPath, description: "Remix server init" },
+    warnings
+  };
+}
+function wireElectron({ projectRoot, pkg, projectKey, ingestUrl }) {
+  const warnings = [];
+  const isMainEsm = pkg.type === "module";
+  const mainInitPath = isMainEsm ? join2(projectRoot, "gg-pixel.main.mjs") : join2(projectRoot, "gg-pixel.main.cjs");
+  writeFileSync(
+    mainInitPath,
+    isMainEsm ? renderInitFile(ingestUrl, projectKey) : renderInitFileCjs(ingestUrl, projectKey),
+    "utf8"
+  );
+  const mainEntry = resolveMainEntryFromPkg(projectRoot, pkg);
+  let mainWiring = { kind: "no_entry_found" };
+  if (mainEntry && existsSync2(mainEntry)) {
+    mainWiring = injectImport(mainEntry, mainInitPath);
+  }
+  const htmlFiles = findRendererHtmlFiles(projectRoot);
+  let rendererInitPath;
+  if (htmlFiles.length > 0) {
+    const rendererDir = dirname2(htmlFiles[0]);
+    rendererInitPath = join2(rendererDir, "gg-pixel.browser.iife.js");
+    if (!copyIifeBundle(projectRoot, rendererInitPath)) {
+      warnings.push(
+        "Could not copy gg-pixel browser IIFE bundle \u2014 install @iroaxel/gg-pixel and re-run."
+      );
+    }
+    let wiredAny = false;
+    for (const html of htmlFiles) {
+      const r = patchRendererHtml(html, rendererInitPath, projectKey, ingestUrl);
+      if (r === "patched" || r === "already") wiredAny = true;
+    }
+    if (!wiredAny) {
+      warnings.push(
+        `Found HTML files in ${rendererDir} but couldn't patch any \u2014 they may have unusual CSP or no <head>.`
+      );
+    }
+  } else {
+    rendererInitPath = join2(projectRoot, "gg-pixel.renderer.mjs");
+    writeFileSync(rendererInitPath, renderBrowserInitFile(ingestUrl, projectKey), "utf8");
+    const rendererEntry = pickPath(projectRoot, [
+      "src/renderer/index.ts",
+      "src/renderer/index.tsx",
+      "src/renderer/index.js",
+      "src/renderer/main.ts",
+      "src/renderer/main.tsx",
+      "src/renderer/main.js",
+      "renderer/index.ts",
+      "renderer/index.tsx",
+      "renderer/index.js",
+      "renderer.ts",
+      "renderer.tsx",
+      "renderer.js",
+      // `src/renderer.{ts,tsx,js}` is the convention used by multi-window
+      // Electron apps that keep all renderer entries in src/.
+      "src/renderer.ts",
+      "src/renderer.tsx",
+      "src/renderer.js",
+      "src/index.tsx",
+      "src/index.jsx",
+      "src/main.tsx",
+      "src/main.jsx"
+    ]);
+    if (rendererEntry) injectImport(rendererEntry, rendererInitPath);
+    else
+      warnings.push(
+        'Could not auto-detect the Electron renderer entry. Add `import "./gg-pixel.renderer.mjs";` to the top of your renderer entry file.'
+      );
+  }
+  return {
+    primaryInitPath: rendererInitPath,
+    entryWiring: { kind: "injected", entryPath: rendererInitPath },
+    secondaryInit: {
+      path: mainInitPath,
+      description: "Electron main-process init" + (mainWiring.kind === "injected" ? ` (wired into ${mainEntry})` : "")
+    },
+    warnings
+  };
+}
+function resolveMainEntryFromPkg(projectRoot, pkg) {
+  if (pkg.main) {
+    const sourceCandidates = [];
+    const main = pkg.main;
+    if (/^(dist|build|\.next|out)\//.test(main)) {
+      const swap = main.replace(/^(dist|build|\.next|out)\//, "src/");
+      if (swap.endsWith(".js")) {
+        sourceCandidates.push(swap.replace(/\.js$/, ".ts"));
+        sourceCandidates.push(swap.replace(/\.js$/, ".tsx"));
+      }
+      sourceCandidates.push(swap);
+    }
+    if (main.endsWith(".js")) {
+      sourceCandidates.push(main.replace(/\.js$/, ".ts"));
+      sourceCandidates.push(main.replace(/\.js$/, ".tsx"));
+    }
+    for (const c of sourceCandidates) {
+      const p = join2(projectRoot, c);
+      if (existsSync2(p)) return p;
+    }
+    const literal = join2(projectRoot, main);
+    if (existsSync2(literal)) return literal;
+  }
+  return pickPath(projectRoot, [
+    "main.js",
+    "main.ts",
+    "src/main.js",
+    "src/main.ts",
+    "src/main/index.ts",
+    "src/main/index.js",
+    "electron/main.js",
+    "electron/main.ts"
+  ]);
+}
+var RENDERER_HTML_DIRS = ["ui", "renderer", "src/renderer", "src", "public", "static"];
+function findRendererHtmlFiles(projectRoot) {
+  for (const dir of RENDERER_HTML_DIRS) {
+    const root = join2(projectRoot, dir);
+    if (!existsSync2(root)) continue;
+    const html = [];
+    let entries;
+    try {
+      entries = readdirSync(root);
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (!e.endsWith(".html")) continue;
+      const p = join2(root, e);
+      try {
+        const c = readFileSync2(p, "utf8");
+        if (/<meta[^>]+content-security-policy/i.test(c) || /<script[\s>]/i.test(c)) {
+          html.push(p);
+        }
+      } catch {
+      }
+    }
+    if (html.length > 0) return html;
+  }
+  return [];
+}
+function copyIifeBundle(projectRoot, dest) {
+  const candidates = [
+    join2(projectRoot, "node_modules/@iroaxel/gg-pixel/dist/browser.iife.global.js"),
+    join2(projectRoot, "node_modules/@iroaxel/gg-pixel/dist/browser.iife.js")
+  ];
+  for (const c of candidates) {
+    if (existsSync2(c)) {
+      try {
+        writeFileSync(dest, readFileSync2(c, "utf8"), "utf8");
+        return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+var PIXEL_HTML_MARKER = "<!-- gg-pixel: auto-wired by arcicoder pixel install -->";
+function patchRendererHtml(htmlPath, iifePath, projectKey, ingestUrl) {
+  let content;
+  try {
+    content = readFileSync2(htmlPath, "utf8");
+  } catch {
+    return "not-applicable";
+  }
+  const original = content;
+  const markerIdx = content.indexOf(PIXEL_HTML_MARKER);
+  if (markerIdx !== -1) {
+    const firstScriptEnd = content.indexOf("</script>", markerIdx);
+    const secondScriptEnd = firstScriptEnd !== -1 ? content.indexOf("</script>", firstScriptEnd + "</script>".length) : -1;
+    if (secondScriptEnd !== -1) {
+      let stripEnd = secondScriptEnd + "</script>".length;
+      while (stripEnd < content.length && /\s/.test(content[stripEnd])) stripEnd++;
+      let stripStart = markerIdx;
+      while (stripStart > 0 && /[ \t]/.test(content[stripStart - 1])) stripStart--;
+      if (stripStart > 0 && content[stripStart - 1] === "\n") stripStart--;
+      content = content.slice(0, stripStart) + content.slice(stripEnd);
+    }
+  }
+  const ingestOrigin = new URL(ingestUrl).origin;
+  content = content.replace(
+    /(<meta[^>]+http-equiv=["']?content-security-policy["']?[^>]*content=)("([^"]+)"|'([^']+)')/i,
+    (_match, before, _all, dq, sq) => {
+      const quote = dq !== void 0 ? '"' : "'";
+      const csp = dq !== void 0 ? dq : sq;
+      let updated = csp;
+      if (/connect-src\s/i.test(csp)) {
+        if (!csp.includes(ingestOrigin)) {
+          updated = csp.replace(/(connect-src[^;]*)/i, `$1 ${ingestOrigin}`);
+        }
+      } else {
+        updated = csp.trim().replace(/;?$/, `; connect-src 'self' ${ingestOrigin};`);
+      }
+      return before + quote + updated + quote;
+    }
+  );
+  const relScript = relative(dirname2(htmlPath), iifePath).split(sep).join("/");
+  const inject = `
+  ${PIXEL_HTML_MARKER}
+  <script src="${relScript}"></script>
+  <script>
+    if (window.GGPixel) GGPixel.initPixel({ projectKey: ${JSON.stringify(projectKey)}, ingestUrl: ${JSON.stringify(ingestUrl)} });
+  </script>
+`;
+  if (/<head[^>]*>/i.test(content)) {
+    content = content.replace(/(<head[^>]*>)/i, `$1${inject}`);
+  } else if (/<html[^>]*>/i.test(content)) {
+    content = content.replace(/(<html[^>]*>)/i, `$1<head>${inject}</head>`);
+  } else {
+    return "not-applicable";
+  }
+  if (content === original) return "already";
+  writeFileSync(htmlPath, content, "utf8");
+  return "patched";
+}
+function wireTauri({ projectRoot, pkg, projectKey, ingestUrl }) {
+  const initPath = join2(projectRoot, "gg-pixel.init.mjs");
+  writeFileSync(initPath, renderBrowserInitFile(ingestUrl, projectKey), "utf8");
+  const entryWiring = wireEntryFile(projectRoot, initPath, pkg);
+  return {
+    primaryInitPath: initPath,
+    entryWiring,
+    warnings: [
+      "Tauri Rust backend is not instrumented \u2014 no Rust SDK exists yet. Frontend errors are captured."
+    ]
+  };
+}
+function wireWorkers({ projectRoot, projectKey, ingestUrl }) {
+  const initPath = join2(projectRoot, "gg-pixel.workers.snippet.ts");
+  writeFileSync(
+    initPath,
+    `// gg-pixel \u2014 Cloudflare Workers wiring snippet.
+// Auto-generated by arcicoder pixel install. Wrap your default export with
+// withPixel(...) so any throw in your handler is auto-reported. Example:
+//
+//   import { withPixel } from "@iroaxel/gg-pixel/workers";
+//
+//   export default withPixel(
+//     { projectKey: ${JSON.stringify(projectKey)} },
+//     {
+//       async fetch(req, env, ctx) { /* your code */ },
+//       async scheduled(evt, env, ctx) { /* your code */ },
+//     },
+//   );
+//
+// For manual reports inside a handler:
+//
+//   import { reportPixel } from "@iroaxel/gg-pixel/workers";
+//   reportPixel(ctx, { projectKey: ${JSON.stringify(projectKey)} }, {
+//     message: "user clicked the broken button",
+//   });
+//
+// Your project_key is publishable \u2014 safe to commit.
+
+import { withPixel, reportPixel } from "@iroaxel/gg-pixel/workers";
+export const PIXEL_KEY = ${JSON.stringify(projectKey)};
+export const PIXEL_INGEST = ${JSON.stringify(ingestUrl)};
+export { withPixel, reportPixel };
+`,
+    "utf8"
+  );
+  return {
+    primaryInitPath: initPath,
+    entryWiring: { kind: "no_entry_found" },
+    warnings: [
+      `Cloudflare Workers default exports can't be auto-wrapped safely. Open ${initPath} for a 3-line snippet you can paste into your worker.`
+    ]
+  };
+}
+function wireReactNative({ projectRoot }) {
+  return {
+    primaryInitPath: join2(projectRoot, "(not-installed)"),
+    entryWiring: { kind: "skipped", reason: "react-native SDK not built yet" },
+    warnings: [
+      "React Native is not yet supported \u2014 its JS runtime is neither browser nor Node.",
+      "A dedicated React Native SDK will be a future slice."
+    ]
+  };
+}
+function pickPath(root, candidates) {
+  for (const c of candidates) {
+    const p = join2(root, c);
+    if (existsSync2(p)) return p;
+  }
+  return null;
+}
+var PIXEL_MARK_BEGIN = "// >>> gg-pixel auto-generated \u2014 do not edit between these markers <<<";
+var PIXEL_MARK_END = "// >>> /gg-pixel <<<";
+function wrapPixelBlock(content) {
+  return `${PIXEL_MARK_BEGIN}
+${content.replace(/\s+$/, "")}
+${PIXEL_MARK_END}
+`;
+}
+function upsertPixelBlock(existing, block) {
+  const wrapped = wrapPixelBlock(block);
+  const beginIdx = existing.indexOf(PIXEL_MARK_BEGIN);
+  if (beginIdx !== -1) {
+    const endIdx = existing.indexOf(PIXEL_MARK_END, beginIdx);
+    if (endIdx !== -1) {
+      const after = endIdx + PIXEL_MARK_END.length;
+      const trailNL = existing[after] === "\n" ? 1 : 0;
+      return existing.slice(0, beginIdx) + wrapped + existing.slice(after + trailNL);
+    }
+  }
+  if (existing.length === 0) return wrapped;
+  const sep2 = existing.endsWith("\n") ? "" : "\n";
+  return existing + sep2 + "\n" + wrapped;
+}
+function upsertPixelBlockInFile(filePath, block) {
+  const existing = existsSync2(filePath) ? readFileSync2(filePath, "utf8") : "";
+  const cleaned = stripLegacyPixelContent(existing);
+  const next = upsertPixelBlock(cleaned, block);
+  if (next !== existing) writeFileSync(filePath, next, "utf8");
+}
+function stripLegacyPixelContent(content) {
+  if (!content.includes("@iroaxel/gg-pixel")) return content;
+  const beginIdx = content.indexOf(PIXEL_MARK_BEGIN);
+  const endIdx = beginIdx === -1 ? -1 : content.indexOf(PIXEL_MARK_END, beginIdx);
+  const insideMarkers = (start, end) => beginIdx !== -1 && endIdx !== -1 && start >= beginIdx && end <= endIdx + PIXEL_MARK_END.length;
+  const ranges = [];
+  const registerRe = /(?:^|\n)((?:[ \t]*\/\/[^\n]*\n)*)[ \t]*export\s+async\s+function\s+register\s*\(\s*\)\s*\{/g;
+  let m;
+  while ((m = registerRe.exec(content)) !== null) {
+    const blockStart = m.index + (content[m.index] === "\n" ? 1 : 0);
+    const openBraceIdx = m.index + m[0].length - 1;
+    let depth = 1;
+    let i = openBraceIdx + 1;
+    while (i < content.length && depth > 0) {
+      const ch = content[i];
+      if (ch === "{") depth++;
+      else if (ch === "}") depth--;
+      i++;
+    }
+    if (depth !== 0) continue;
+    const blockEnd = i;
+    const blockText = content.slice(blockStart, blockEnd);
+    if (!blockText.includes("@iroaxel/gg-pixel")) continue;
+    if (insideMarkers(blockStart, blockEnd)) continue;
+    const trailingNL = content[blockEnd] === "\n" ? 1 : 0;
+    ranges.push({ start: blockStart, end: blockEnd + trailingNL });
+  }
+  const importRe = /(?:^|\n)((?:[ \t]*\/\/[^\n]*\n)*)[ \t]*import\s*\{\s*initPixel[^}]*\}\s*from\s*"@iroaxel\/gg-pixel(?:\/[\w-]+)?"\s*;?\s*\n/g;
+  while ((m = importRe.exec(content)) !== null) {
+    const blockStart = m.index + (content[m.index] === "\n" ? 1 : 0);
+    const callIdx = content.indexOf("initPixel(", importRe.lastIndex);
+    if (callIdx === -1 || callIdx - importRe.lastIndex > 2048) continue;
+    const openParen = content.indexOf("(", callIdx);
+    let depth = 1;
+    let i = openParen + 1;
+    while (i < content.length && depth > 0) {
+      const ch = content[i];
+      if (ch === "(" || ch === "{") depth++;
+      else if (ch === ")" || ch === "}") depth--;
+      i++;
+    }
+    if (depth !== 0) continue;
+    while (i < content.length && (content[i] === ";" || content[i] === " ")) i++;
+    const trailingNL = content[i] === "\n" ? 1 : 0;
+    const blockEnd = i + trailingNL;
+    if (insideMarkers(blockStart, blockEnd)) continue;
+    ranges.push({ start: blockStart, end: blockEnd });
+  }
+  if (ranges.length === 0) return content;
+  ranges.sort((a, b) => b.start - a.start);
+  let out = content;
+  for (const r of ranges) out = out.slice(0, r.start) + out.slice(r.end);
+  return out.replace(/\n{3,}/g, "\n\n");
+}
+function injectImport(entryPath, initFilePath) {
+  let content;
+  try {
+    content = readFileSync2(entryPath, "utf8");
+  } catch (err) {
+    return { kind: "skipped", reason: `unreadable: ${err.message}` };
+  }
+  const initBasename = initFilePath.split(sep).pop() ?? "gg-pixel.init.mjs";
+  if (content.includes(initBasename) || content.includes("@iroaxel/gg-pixel")) {
+    return { kind: "already_present", entryPath };
+  }
+  const fromDir = dirname2(entryPath);
+  let spec = relative(fromDir, initFilePath).split(sep).join("/");
+  if (!spec.startsWith(".")) spec = "./" + spec;
+  const isCjs = entryPath.endsWith(".cjs") || entryPath.endsWith(".js") && /\brequire\s*\(/.test(content) && !/\bimport\s+/.test(content) && !/\bexport\s+/.test(content);
+  const importLine = isCjs ? `require(${JSON.stringify(spec)});` : `import ${JSON.stringify(spec)};`;
+  const lines = content.split("\n");
+  let insertAt = 0;
+  if (lines[0]?.startsWith("#!")) insertAt = 1;
+  while (insertAt < lines.length && /^\s*(?:["']use strict["']|\/\/|\/\*)/.test(lines[insertAt] ?? "")) {
+    insertAt++;
+  }
+  const updated = [...lines.slice(0, insertAt), importLine, ...lines.slice(insertAt)].join("\n");
+  writeFileSync(entryPath, updated, "utf8");
+  return { kind: "injected", entryPath };
+}
+function isBrowserProject(pkg, projectRoot) {
+  const all = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  const browserishDeps = [
+    "react",
+    "react-dom",
+    "vue",
+    "@vue/runtime-core",
+    "svelte",
+    "next",
+    "vite",
+    "@vitejs/plugin-react",
+    "@angular/core",
+    "solid-js",
+    "preact",
+    "@remix-run/react",
+    "astro",
+    "qwik",
+    "@sveltejs/kit",
+    "expo"
+  ];
+  if (browserishDeps.some((d) => d in all)) return true;
+  if (pkg.browser !== void 0) return true;
+  if (existsSync2(join2(projectRoot, "index.html"))) return true;
+  if (existsSync2(join2(projectRoot, "public", "index.html"))) return true;
+  return false;
+}
+function renderBrowserInitFile(ingestUrl, projectKey) {
+  return `// gg-pixel init \u2014 auto-generated by arcicoder pixel install.
+// The project_key is publishable (designed to live in browser bundles).
+import { initPixel } from "@iroaxel/gg-pixel/browser";
+
+initPixel({
+  projectKey: ${JSON.stringify(projectKey)},
+  ingestUrl: ${JSON.stringify(ingestUrl)},
+});
+`;
+}
+var PYTHON_MARKERS = ["pyproject.toml", "setup.py", "requirements.txt", "Pipfile"];
+function findPythonProjectRoot(start) {
+  let dir = start;
+  for (let i = 0; i < 20; i++) {
+    if (PYTHON_MARKERS.some((m) => existsSync2(join2(dir, m)))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+function detectPythonPackageManager(projectRoot) {
+  if (existsSync2(join2(projectRoot, "uv.lock"))) return "uv";
+  if (existsSync2(join2(projectRoot, "poetry.lock"))) return "poetry";
+  if (existsSync2(join2(projectRoot, "Pipfile.lock"))) return "pipenv";
+  return "pip";
+}
+function pickClosestRoot(roots) {
+  let best = null;
+  for (const r of roots) {
+    if (!r) continue;
+    if (!best || r.length > best.length) best = r;
+  }
+  return best;
+}
+var GO_MARKER = "go.mod";
+var RUBY_MARKERS = ["Gemfile"];
+function findGoProjectRoot(start) {
+  let dir = start;
+  for (let i = 0; i < 20; i++) {
+    if (existsSync2(join2(dir, GO_MARKER))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+function findRubyProjectRoot(start) {
+  let dir = start;
+  for (let i = 0; i < 20; i++) {
+    for (const m of RUBY_MARKERS) {
+      if (existsSync2(join2(dir, m))) return dir;
+    }
+    try {
+      const entries = readdirSync(dir);
+      if (entries.some((e) => e.endsWith(".gemspec"))) return dir;
+    } catch {
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+async function installGo(ctx) {
+  const { projectRoot, opts, ingestUrl, fetchFn, home } = ctx;
+  const projectName = opts.projectName ?? readGoModuleName(projectRoot) ?? projectRoot.split("/").pop() ?? "unnamed";
+  const projectsJsonPath = join2(home, ".gg", "projects.json");
+  const envFilePath = join2(projectRoot, ".env");
+  const existing = findMappingByPath(projectsJsonPath, projectRoot);
+  const existingKey = readEnvKey(envFilePath, "GG_PIXEL_KEY");
+  let created;
+  let reused = false;
+  if (existing && existing.secret && existingKey) {
+    created = { id: existing.id, key: existingKey, secret: existing.secret };
+    reused = true;
+  } else {
+    created = await createProject(fetchFn, ingestUrl, projectName);
+  }
+  const packageInstalled = opts.skipPackageInstall ? false : runGoGet(projectRoot);
+  const initFilePath = join2(projectRoot, "gg_pixel_init.go");
+  writeFileSync(
+    initFilePath,
+    `// gg-pixel init \u2014 auto-generated by arcicoder pixel install.
+package main
+
+import (
+	"os"
+	gg "github.com/kenkaiiii/gg-pixel-go"
+)
+
+func init() {
+	key := os.Getenv("GG_PIXEL_KEY")
+	if key == "" {
+		key = ${JSON.stringify(created.key)}
+	}
+	_ = gg.Init(gg.Options{ProjectKey: key, IngestURL: ${JSON.stringify(`${ingestUrl}/ingest`)}})
+}
+`,
+    "utf8"
+  );
+  writeEnvKey(envFilePath, "GG_PIXEL_KEY", created.key);
+  writeProjectsMapping(projectsJsonPath, created.id, projectName, projectRoot, created.secret);
+  return {
+    projectId: created.id,
+    projectKey: created.key,
+    projectSecret: created.secret,
+    projectName,
+    projectKind: "go",
+    projectRoot,
+    initFilePath,
+    envFilePath,
+    projectsJsonPath,
+    packageManager: "pip",
+    packageInstalled,
+    entryWiring: { kind: "no_entry_found" },
+    reused,
+    warnings: [
+      "Add `defer ggpixel.Recover()` near the top of your main() so panics are captured before the process exits."
+    ]
+  };
+}
+function readGoModuleName(projectRoot) {
+  try {
+    const content = readFileSync2(join2(projectRoot, "go.mod"), "utf8");
+    const match = /^\s*module\s+(\S+)\s*$/m.exec(content);
+    if (!match) return null;
+    return match[1].split("/").pop() ?? null;
+  } catch {
+    return null;
+  }
+}
+function runGoGet(projectRoot) {
+  const result = spawnSync2("go", ["get", "github.com/kenkaiiii/gg-pixel-go@latest"], {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+  return result.status === 0;
+}
+async function installRuby(ctx) {
+  const { projectRoot, opts, ingestUrl, fetchFn, home } = ctx;
+  const projectName = opts.projectName ?? readRubyAppName(projectRoot) ?? projectRoot.split("/").pop() ?? "unnamed";
+  const projectsJsonPath = join2(home, ".gg", "projects.json");
+  const envFilePath = join2(projectRoot, ".env");
+  const existing = findMappingByPath(projectsJsonPath, projectRoot);
+  const existingKey = readEnvKey(envFilePath, "GG_PIXEL_KEY");
+  let created;
+  let reused = false;
+  if (existing && existing.secret && existingKey) {
+    created = { id: existing.id, key: existingKey, secret: existing.secret };
+    reused = true;
+  } else {
+    created = await createProject(fetchFn, ingestUrl, projectName);
+  }
+  const packageInstalled = opts.skipPackageInstall ? false : runRubyInstall(projectRoot);
+  const initFilePath = join2(projectRoot, "gg_pixel_init.rb");
+  writeFileSync(
+    initFilePath,
+    `# gg-pixel init \u2014 auto-generated by arcicoder pixel install.
+require "gg_pixel"
+GGPixel.init(
+  project_key: ENV["GG_PIXEL_KEY"] || ${JSON.stringify(created.key)},
+  ingest_url: ${JSON.stringify(`${ingestUrl}/ingest`)},
+)
+`,
+    "utf8"
+  );
+  writeEnvKey(envFilePath, "GG_PIXEL_KEY", created.key);
+  writeProjectsMapping(projectsJsonPath, created.id, projectName, projectRoot, created.secret);
+  return {
+    projectId: created.id,
+    projectKey: created.key,
+    projectSecret: created.secret,
+    projectName,
+    projectKind: "ruby",
+    projectRoot,
+    initFilePath,
+    envFilePath,
+    projectsJsonPath,
+    packageManager: "pip",
+    packageInstalled,
+    entryWiring: { kind: "no_entry_found" },
+    reused,
+    warnings: [
+      `Add \`require "./gg_pixel_init"\` at the top of your entry script (often \`config/application.rb\` for Rails, \`app.rb\` for Sinatra, or your main file).`
+    ]
+  };
+}
+function readRubyAppName(projectRoot) {
+  try {
+    const entries = readdirSync(projectRoot);
+    const gemspec = entries.find((e) => e.endsWith(".gemspec"));
+    if (!gemspec) return null;
+    return gemspec.replace(/\.gemspec$/, "");
+  } catch {
+    return null;
+  }
+}
+function runRubyInstall(projectRoot) {
+  if (existsSync2(join2(projectRoot, "Gemfile"))) {
+    try {
+      const content = readFileSync2(join2(projectRoot, "Gemfile"), "utf8");
+      if (!content.includes("gg_pixel")) {
+        writeFileSync(
+          join2(projectRoot, "Gemfile"),
+          content + (content.endsWith("\n") ? "" : "\n") + 'gem "gg_pixel"\n',
+          "utf8"
+        );
+      }
+    } catch {
+    }
+    const r = spawnSync2("bundle", ["install"], { cwd: projectRoot, stdio: "inherit" });
+    if (r.status === 0) return true;
+  }
+  const r2 = spawnSync2("gem", ["install", "gg_pixel"], { cwd: projectRoot, stdio: "inherit" });
+  return r2.status === 0;
+}
+async function installPython(ctx) {
+  const { projectRoot, opts, ingestUrl, fetchFn, home } = ctx;
+  const projectName = opts.projectName ?? readPyprojectName(projectRoot) ?? projectRoot.split("/").pop() ?? "unnamed";
+  const projectsJsonPath = join2(home, ".gg", "projects.json");
+  const envFilePath = join2(projectRoot, ".env");
+  const existing = findMappingByPath(projectsJsonPath, projectRoot);
+  const existingKey = readEnvKey(envFilePath, "GG_PIXEL_KEY");
+  let created;
+  let reused = false;
+  if (existing && existing.secret && existingKey) {
+    created = { id: existing.id, key: existingKey, secret: existing.secret };
+    reused = true;
+  } else {
+    created = await createProject(fetchFn, ingestUrl, projectName);
+  }
+  const pm = detectPythonPackageManager(projectRoot);
+  const packageInstalled = opts.skipPackageInstall ? false : runPythonInstall(projectRoot, pm);
+  const initFilePath = join2(projectRoot, "gg_pixel_init.py");
+  writeFileSync(initFilePath, renderPythonInitFile(ingestUrl, created.key), "utf8");
+  writeEnvKey(envFilePath, "GG_PIXEL_KEY", created.key);
+  writeProjectsMapping(projectsJsonPath, created.id, projectName, projectRoot, created.secret);
+  const entryWiring = wirePythonEntry(projectRoot, initFilePath);
+  return {
+    projectId: created.id,
+    projectKey: created.key,
+    projectSecret: created.secret,
+    projectName,
+    projectKind: "python",
+    projectRoot,
+    initFilePath,
+    envFilePath,
+    projectsJsonPath,
+    packageManager: pm,
+    packageInstalled,
+    entryWiring,
+    reused,
+    warnings: []
+  };
+}
+function readPyprojectName(projectRoot) {
+  const path = join2(projectRoot, "pyproject.toml");
+  if (!existsSync2(path)) return null;
+  try {
+    const content = readFileSync2(path, "utf8");
+    const match = /^\s*name\s*=\s*["']([^"']+)["']/m.exec(content);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+function runPythonInstall(projectRoot, pm) {
+  const cmd = pm === "uv" ? ["uv", ["add", "gg-pixel"]] : pm === "poetry" ? ["poetry", ["add", "gg-pixel"]] : pm === "pipenv" ? ["pipenv", ["install", "gg-pixel"]] : ["pip", ["install", "gg-pixel"]];
+  const result = spawnSync2(cmd[0], cmd[1], {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+  if (result.status === 0) return true;
+  if (pm === "pip") {
+    const r2 = spawnSync2("pip3", ["install", "gg-pixel"], {
+      cwd: projectRoot,
+      stdio: "inherit"
+    });
+    if (r2.status === 0) return true;
+    const r3 = spawnSync2("python3", ["-m", "pip", "install", "gg-pixel"], {
+      cwd: projectRoot,
+      stdio: "inherit"
+    });
+    return r3.status === 0;
+  }
+  return false;
+}
+function renderPythonInitFile(ingestUrl, projectKey) {
+  return `"""gg-pixel init \u2014 auto-generated by arcicoder pixel install.
+
+This file initializes error tracking. Importing it (which the install step
+wires into your entry file) registers the global Python error handlers.
+"""
+import os
+
+import gg_pixel
+
+gg_pixel.init_pixel(
+    project_key=os.environ.get("GG_PIXEL_KEY") or ${JSON.stringify(projectKey)},
+    ingest_url=${JSON.stringify(`${ingestUrl}/ingest`)},
+)
+`;
+}
+function wirePythonEntry(projectRoot, initFilePath) {
+  const entryPath = findPythonEntryFile(projectRoot);
+  if (!entryPath) return { kind: "no_entry_found" };
+  let content;
+  try {
+    content = readFileSync2(entryPath, "utf8");
+  } catch (err) {
+    return { kind: "skipped", reason: `unreadable: ${err.message}` };
+  }
+  if (content.includes("gg_pixel_init")) {
+    return { kind: "already_present", entryPath };
+  }
+  const fromDir = dirname2(entryPath);
+  const rel = relative(fromDir, initFilePath).split(sep).join("/");
+  let moduleSpec;
+  if (rel === "gg_pixel_init.py") {
+    moduleSpec = "gg_pixel_init";
+  } else if (rel.startsWith("../")) {
+    moduleSpec = "gg_pixel_init";
+  } else {
+    moduleSpec = rel.replace(/\.py$/, "").replace(/\//g, ".");
+  }
+  const importLine = `import ${moduleSpec}  # noqa: F401, E402  -- gg-pixel`;
+  const lines = content.split("\n");
+  let insertAt = 0;
+  if (lines[0]?.startsWith("#!")) insertAt = 1;
+  while (insertAt < lines.length && /^\s*(?:#.*coding[:=]|["']{3}|#)/.test(lines[insertAt] ?? "")) {
+    insertAt++;
+  }
+  const updated = [...lines.slice(0, insertAt), importLine, ...lines.slice(insertAt)].join("\n");
+  writeFileSync(entryPath, updated, "utf8");
+  return { kind: "injected", entryPath };
+}
+function findPythonEntryFile(projectRoot) {
+  const tryPath = (rel) => {
+    const p = join2(projectRoot, rel);
+    return existsSync2(p) ? p : null;
+  };
+  const candidates = [
+    "main.py",
+    "app.py",
+    "server.py",
+    "manage.py",
+    "wsgi.py",
+    "asgi.py",
+    "__main__.py",
+    "src/main.py",
+    "src/app.py",
+    "src/server.py",
+    "src/__main__.py"
+  ];
+  for (const c of candidates) {
+    const found = tryPath(c);
+    if (found) return found;
+  }
+  return null;
+}
+function writeProjectsMapping(projectsJsonPath, projectId, name, path, secret) {
+  mkdirSync2(dirname2(projectsJsonPath), { recursive: true });
+  let map = {};
+  if (existsSync2(projectsJsonPath)) {
+    try {
+      map = JSON.parse(readFileSync2(projectsJsonPath, "utf8"));
+    } catch {
+    }
+  }
+  const entry = { name, path };
+  if (secret) entry.secret = secret;
+  map[projectId] = entry;
+  writeFileSync(projectsJsonPath, `${JSON.stringify(map, null, 2)}
+`, "utf8");
+}
+var PROBE_FINGERPRINT_PREFIX = "__pixel_install_probe__";
+function isInstallProbeFingerprint(fingerprint2) {
+  return typeof fingerprint2 === "string" && fingerprint2.startsWith(PROBE_FINGERPRINT_PREFIX);
+}
+async function verifyInstall(opts) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const spawnFn = opts.spawnFn ?? nodeSpawn;
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const ingest = opts.ingestUrl.replace(/\/+$/, "");
+  const fingerprint2 = `${PROBE_FINGERPRINT_PREFIX}${randomBytes(6).toString("hex")}`;
+  const start = Date.now();
+  let method;
+  let probeError = null;
+  if (opts.skipChildProbe) {
+    try {
+      await postDirectIngest({
+        ingestUrl: ingest,
+        projectKey: opts.projectKey,
+        fingerprint: fingerprint2,
+        fetchFn
+      });
+      method = "direct_ingest";
+    } catch (err) {
+      return {
+        kind: "failed",
+        reason: "Direct ingest failed",
+        hint: err.message
+      };
+    }
+  } else {
+    try {
+      await runChildProbe({
+        projectRoot: opts.projectRoot,
+        ingestUrl: ingest,
+        projectKey: opts.projectKey,
+        fingerprint: fingerprint2,
+        spawnFn
+      });
+      method = "child_process";
+    } catch (err) {
+      probeError = err.message;
+      try {
+        await postDirectIngest({
+          ingestUrl: ingest,
+          projectKey: opts.projectKey,
+          fingerprint: fingerprint2,
+          fetchFn
+        });
+        method = "direct_ingest";
+      } catch (err2) {
+        return {
+          kind: "failed",
+          reason: "Could not deliver probe event",
+          hint: `child-process: ${probeError}; direct ingest: ${err2.message}`
+        };
+      }
+    }
+  }
+  const probeRow = await pollForFingerprint({
+    ingestUrl: ingest,
+    projectId: opts.projectId,
+    projectSecret: opts.projectSecret,
+    fingerprint: fingerprint2,
+    timeoutMs,
+    fetchFn
+  });
+  if (!probeRow) {
+    return {
+      kind: "failed",
+      reason: `Probe sent (${method}) but didn't appear in /api/projects/${opts.projectId}/errors within ${timeoutMs}ms`,
+      hint: probeError ?? void 0
+    };
+  }
+  try {
+    await fetchFn(`${ingest}/api/errors/${probeRow.id}`, {
+      method: "DELETE",
+      headers: { authorization: `Bearer ${opts.projectSecret}` }
+    });
+  } catch {
+  }
+  return {
+    kind: "ok",
+    method,
+    latencyMs: Date.now() - start
+  };
+}
+async function runChildProbe(args) {
+  const ggDir = join3(args.projectRoot, ".gg");
+  if (!existsSync3(ggDir)) mkdirSync3(ggDir, { recursive: true });
+  const probePath = join3(ggDir, `pixel-probe-${randomBytes(4).toString("hex")}.mjs`);
+  const script = `import "@iroaxel/gg-pixel";
+const body = ${JSON.stringify({
+    project_key: args.projectKey,
+    fingerprint: args.fingerprint,
+    type: "InstallProbe",
+    message: "Install verification probe \u2014 auto-generated, safe to delete",
+    stack: [],
+    code_context: null,
+    runtime: "",
+    manual_report: true,
+    level: "error"
+  })};
+body.event_id = "evt_probe_" + crypto.randomUUID();
+body.runtime = "installer-node-" + process.versions.node;
+body.occurred_at = new Date().toISOString();
+const res = await fetch(${JSON.stringify(args.ingestUrl + "/ingest")}, {
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify(body),
+});
+if (!res.ok) {
+  const txt = await res.text().catch(() => "");
+  console.error("probe ingest failed: status=" + res.status + " body=" + txt.slice(0, 200));
+  process.exit(1);
+}
+`;
+  writeFileSync2(probePath, script, "utf8");
+  try {
+    await new Promise((resolve2, reject) => {
+      const opts = { cwd: args.projectRoot, stdio: "pipe" };
+      const child = args.spawnFn("node", [probePath], opts);
+      let stderr = "";
+      child.stderr?.on("data", (b) => {
+        stderr += b.toString();
+      });
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        reject(new Error("Probe child timed out after 10s"));
+      }, 1e4);
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+      child.on("exit", (code) => {
+        clearTimeout(timer);
+        if (code === 0) resolve2();
+        else reject(new Error(`Probe exited code=${code}; stderr: ${stderr.trim().slice(0, 400)}`));
+      });
+    });
+  } finally {
+    try {
+      unlinkSync(probePath);
+    } catch {
+    }
+  }
+}
+async function postDirectIngest(args) {
+  const res = await args.fetchFn(`${args.ingestUrl}/ingest`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      event_id: `evt_probe_${randomBytes(8).toString("hex")}`,
+      project_key: args.projectKey,
+      fingerprint: args.fingerprint,
+      type: "InstallProbe",
+      message: "Install verification probe",
+      stack: [],
+      code_context: null,
+      runtime: `installer-node-${process.versions.node}`,
+      manual_report: true,
+      level: "error",
+      occurred_at: (/* @__PURE__ */ new Date()).toISOString()
+    })
+  });
+  if (!res.ok) {
+    let body = "";
+    try {
+      body = await res.text();
+    } catch {
+    }
+    throw new Error(`POST /ingest \u2192 ${res.status} ${body.slice(0, 200)}`);
+  }
+}
+async function pollForFingerprint(args) {
+  const deadline = Date.now() + args.timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const res = await args.fetchFn(`${args.ingestUrl}/api/projects/${args.projectId}/errors`, {
+        headers: { authorization: `Bearer ${args.projectSecret}` }
+      });
+      if (res.ok) {
+        const body = await res.json();
+        const match = body.errors.find((e) => e.fingerprint === args.fingerprint);
+        if (match) return { id: match.id };
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return null;
+}
+
+export {
+  source_default,
+  DEFAULT_INGEST_URL,
+  install,
+  isInstallProbeFingerprint,
+  verifyInstall
+};
+//# sourceMappingURL=chunk-YKKUCYNE.js.map