@thinkingai/ae-cli 1.0.30 → 6.0.16

package/dist/index.js

@@ -1,22 +1,28 @@
 import {
   TeAgentApiError,
   TeAgentCredentialsError
-} from "./chunk-VJFUB3H3.js";
+} from "./chunk-I5CRVM2S.js";
 import {
   printError,
   printOutput
-} from "./chunk-CLJF7MQA.js";
+} from "./chunk-2DUEAXV3.js";
+import {
+  httpGet
+} from "./chunk-BJX3GXWC.js";
 import {
   PermissionError
 } from "./chunk-NOO24N7W.js";
 import {
-  SecureStoreAuthError
-} from "./chunk-JM34JPCO.js";
+  SecureStoreAuthError,
+  getToken,
+  resolveHost
+} from "./chunk-RSHMZ3LG.js";
 import {
   getActiveHost,
+  getConfigDir,
   logger,
   safeJsonParse
-} from "./chunk-SRJIAOBN.js";
+} from "./chunk-6W4QOZAL.js";
 
 // src/index.ts
 import { Command as CommanderCommand } from "commander";
@@ -41,6 +47,20 @@ async function runCommand(cmd, opts, globalOpts) {
     if (cmd.validate) {
       cmd.validate(ctx);
     }
+    const LIMIT_FLAG_PATTERNS = [/limit/i, /page_size/i, /pagesize/i, /row_limit/i, /block_limit/i, /top[-_]?k/i];
+    for (const flag of cmd.flags) {
+      const isLimitFlag = LIMIT_FLAG_PATTERNS.some((p) => p.test(flag.name));
+      if (isLimitFlag && flag.type === "number") {
+        const val = opts[camelCase(flag.name)];
+        if (val !== void 0 && val !== null) {
+          const num = Number(val);
+          if (!Number.isInteger(num) || num < 1 || num > 1e4) {
+            printError("validation", `--${flag.name} must be an integer between 1 and 10000 (got: ${val})`);
+            process.exit(1);
+          }
+        }
+      }
+    }
     if (globalOpts.dryRun) {
       if (cmd.dryRun) {
         const dryResult = cmd.dryRun(ctx);
@@ -93,7 +113,7 @@ function createRuntimeContext(cmd, opts, globalOpts) {
   let _clientModule = null;
   async function getClient() {
     if (!_clientModule) {
-      _clientModule = await import("./client-IN42F223.js");
+      _clientModule = await import("./client-2UJ63MVQ.js");
     }
     return _clientModule;
   }
@@ -119,12 +139,12 @@ function createRuntimeContext(cmd, opts, globalOpts) {
         process.exit(1);
       }
     },
-    async api(method, path2, params, data) {
+    async api(method, path5, params, data) {
       const client = await getClient();
       if (method.toUpperCase() === "GET") {
-        return client.httpGet(path2, params, ctx.host());
+        return client.httpGet(path5, params, ctx.host());
       } else {
-        return client.httpRequest(method, path2, params, data, ctx.host());
+        return client.httpRequest(method, path5, params, data, ctx.host());
       }
     },
     async querySql(projectId, sql) {
@@ -136,8 +156,8 @@ function createRuntimeContext(cmd, opts, globalOpts) {
       return client.queryReportData(projectId, reportId, qp, eventModel, options, ctx.host());
     },
     async token() {
-      const { getToken } = await import("./auth-U25QJU5D.js");
-      return getToken(ctx.host());
+      const { getToken: getToken2 } = await import("./auth-DYC2BGLM.js");
+      return getToken2(ctx.host());
     },
     host() {
       if (globalOpts.host) return globalOpts.host;
@@ -160,10 +180,10 @@ function camelCase(str) {
 }
 async function confirm(message) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(`${message} [y/N] `, (answer) => {
       rl.close();
-      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
@@ -376,6 +396,2483 @@ function notifyIfUpdateAvailable(pkg2) {
   });
 }
 
+// src/commands/tracking/plan.ts
+import { readFile, writeFile, cp } from "fs/promises";
+import path3, { resolve } from "path";
+
+// src/tracking/xlsx/write.ts
+import ExcelJS from "exceljs";
+
+// src/tracking/i18n/locale.ts
+var VALID_LOCALES = /* @__PURE__ */ new Set(["zh", "en", "ja", "ko"]);
+function normalize(raw) {
+  const lower = raw.trim().toLowerCase();
+  if (lower.startsWith("zh") || lower.startsWith("cn")) return "zh";
+  if (lower.startsWith("ja") || lower.startsWith("jp")) return "ja";
+  if (lower.startsWith("ko") || lower.startsWith("kr")) return "ko";
+  if (lower.startsWith("en")) return "en";
+  if (VALID_LOCALES.has(lower)) return lower;
+  return "en";
+}
+var _cliLocale;
+function detectCliLocale() {
+  if (_cliLocale) return _cliLocale;
+  if (process.env.AE_LANG) {
+    _cliLocale = normalize(process.env.AE_LANG);
+    return _cliLocale;
+  }
+  const sys = (process.env.LANG || process.env.LC_ALL || process.env.LANGUAGE || "").toLowerCase();
+  if (sys) {
+    _cliLocale = normalize(sys);
+    return _cliLocale;
+  }
+  _cliLocale = "en";
+  return _cliLocale;
+}
+
+// src/tracking/i18n/resources/xlsx/sheets.ts
+var SHEET_NAMES = {
+  event_data: {
+    zh: "#\u4E8B\u4EF6\u6570\u636E",
+    en: "#event data",
+    ja: "#\u30A4\u30D9\u30F3\u30C8\u30C7\u30FC\u30BF",
+    ko: "#\uC774\uBCA4\uD2B8 \uB370\uC774\uD130"
+  },
+  common_props: {
+    zh: "#\u516C\u5171\u4E8B\u4EF6\u5C5E\u6027",
+    en: "#super property",
+    ja: "#\u30D1\u30D6\u30EA\u30C3\u30AF\u30A4\u30D9\u30F3\u30C8\u30D7\u30ED\u30D1\u30C6\u30A3",
+    ko: "#\uACF5\uD1B5 \uC774\uBCA4\uD2B8 \uC18D\uC131"
+  },
+  user_data: {
+    zh: "#\u7528\u6237\u6570\u636E",
+    en: "#user data",
+    ja: "#\u30E6\u30FC\u30B6\u30FC\u30C7\u30FC\u30BF",
+    ko: "#\uC720\uC800 \uB370\uC774\uD130"
+  },
+  user_id: {
+    zh: "#\u7528\u6237ID\u4F53\u7CFB",
+    en: "#ID mapping rule",
+    ja: "#\u30E6\u30FC\u30B6\u30FCID\u30B7\u30B9\u30C6\u30E0",
+    ko: "#\uC720\uC800 ID \uCCB4\uACC4"
+  }
+};
+function sheetName(key, locale) {
+  return SHEET_NAMES[key][locale];
+}
+function allSheetNames(key) {
+  return Object.values(SHEET_NAMES[key]);
+}
+
+// src/tracking/i18n/resources/xlsx/headers.ts
+var HEADERS = {
+  // === #事件数据 (9 列) ===
+  event_name: {
+    zh: "\u4E8B\u4EF6\u540D\uFF08\u5FC5\u586B\uFF09",
+    en: "Event Name",
+    ja: "\u30A4\u30D9\u30F3\u30C8\u540D\uFF08\u5FC5\u9808\uFF09",
+    ko: "\uC774\uBCA4\uD2B8 \uC774\uB984 (\uD544\uC218)"
+  },
+  event_display_name: {
+    zh: "\u4E8B\u4EF6\u663E\u793A\u540D",
+    en: "Event Display Name",
+    ja: "\u30A4\u30D9\u30F3\u30C8\u8868\u793A\u540D",
+    ko: "\uC774\uBCA4\uD2B8 \uD45C\uC2DC \uC774\uB984"
+  },
+  event_desc: {
+    zh: "\u4E8B\u4EF6\u8BF4\u660E",
+    en: "Event Description",
+    ja: "\u30A4\u30D9\u30F3\u30C8\u8AAC\u660E",
+    ko: "\uC774\uBCA4\uD2B8 \uC124\uBA85"
+  },
+  event_tag: {
+    zh: "\u4E8B\u4EF6\u6807\u7B7E",
+    en: "Event Tag",
+    ja: "\u30AB\u30C6\u30B4\u30EA",
+    ko: "\uC774\uBCA4\uD2B8 \uD0DC\uADF8"
+  },
+  platform: {
+    zh: "\u91C7\u96C6\u7AEF",
+    en: "Platform",
+    ja: "\u30D7\u30E9\u30C3\u30C8\u30D5\u30A9\u30FC\u30E0",
+    ko: "\uD50C\uB7AB\uD3FC"
+  },
+  prop_name: {
+    zh: "\u5C5E\u6027\u540D\uFF08\u5FC5\u586B\uFF09",
+    en: "Property Name",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u540D\uFF08\u5FC5\u9808\uFF09",
+    ko: "\uC18D\uC131 \uC774\uB984 (\uD544\uC218)"
+  },
+  prop_display_name: {
+    zh: "\u5C5E\u6027\u663E\u793A\u540D",
+    en: "Property Display Name",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u8868\u793A\u540D",
+    ko: "\uC18D\uC131 \uD45C\uC2DC \uC774\uB984"
+  },
+  prop_type: {
+    zh: "\u5C5E\u6027\u7C7B\u578B\uFF08\u5FC5\u586B\uFF09",
+    en: "Data Type",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u30BF\u30A4\u30D7\uFF08\u5FC5\u9808\uFF09",
+    ko: "\uC18D\uC131 \uC720\uD615 (\uD544\uC218)"
+  },
+  prop_desc: {
+    zh: "\u5C5E\u6027\u8BF4\u660E",
+    en: "Property Description",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u8AAC\u660E",
+    ko: "\uC18D\uC131 \uC124\uBA85"
+  },
+  // === #公共事件属性 (4 列) ===
+  common_prop_name: {
+    zh: "\u5C5E\u6027\u540D\uFF08\u5FC5\u586B\uFF09",
+    en: "Property Name",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u540D\uFF08\u5FC5\u9808\uFF09",
+    ko: "\uC18D\uC131 \uC774\uB984 (\uD544\uC218)"
+  },
+  common_prop_display_name: {
+    zh: "\u5C5E\u6027\u663E\u793A\u540D",
+    en: "Property Display Name",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u8868\u793A\u540D",
+    ko: "\uC18D\uC131 \uD45C\uC2DC \uC774\uB984"
+  },
+  common_prop_type: {
+    zh: "\u5C5E\u6027\u7C7B\u578B\uFF08\u5FC5\u586B\uFF09",
+    en: "Data Type",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u30BF\u30A4\u30D7\uFF08\u5FC5\u9808\uFF09",
+    ko: "\uC18D\uC131 \uC720\uD615 (\uD544\uC218)"
+  },
+  common_prop_desc: {
+    zh: "\u5C5E\u6027\u8BF4\u660E",
+    en: "Property Description",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u8AAC\u660E",
+    ko: "\uC18D\uC131 \uC124\uBA85"
+  },
+  // === #用户数据 (6 列) ===
+  user_prop_name: {
+    zh: "\u5C5E\u6027\u540D\uFF08\u5FC5\u586B\uFF09",
+    en: "Property Name",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u540D\uFF08\u5FC5\u9808\uFF09",
+    ko: "\uC18D\uC131 \uC774\uB984 (\uD544\uC218)"
+  },
+  user_prop_display_name: {
+    zh: "\u5C5E\u6027\u663E\u793A\u540D",
+    en: "Property Display Name",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u8868\u793A\u540D",
+    ko: "\uC18D\uC131 \uD45C\uC2DC \uC774\uB984"
+  },
+  user_prop_type: {
+    zh: "\u5C5E\u6027\u7C7B\u578B\uFF08\u5FC5\u586B\uFF09",
+    en: "Data Type",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u30BF\u30A4\u30D7\uFF08\u5FC5\u9808\uFF09",
+    ko: "\uC18D\uC131 \uC720\uD615 (\uD544\uC218)"
+  },
+  update_type: {
+    zh: "\u66F4\u65B0\u65B9\u5F0F",
+    en: "Update Type",
+    ja: "\u66F4\u65B0\u65B9\u6CD5",
+    ko: "\uC5C5\uB370\uC774\uD2B8 \uBC29\uC2DD"
+  },
+  user_prop_desc: {
+    zh: "\u5C5E\u6027\u8BF4\u660E",
+    en: "Property Description",
+    ja: "\u30D7\u30ED\u30D1\u30C6\u30A3\u8AAC\u660E",
+    ko: "\uC18D\uC131 \uC124\uBA85"
+  },
+  prop_tag: {
+    zh: "\u5C5E\u6027\u6807\u7B7E",
+    en: "Property Tag",
+    ja: "\u30AB\u30C6\u30B4\u30EA",
+    ko: "\uC18D\uC131 \uD0DC\uADF8"
+  },
+  // === #用户ID体系 (4 列，不含"游戏类型"前置列) ===
+  user_id_prop_name: {
+    zh: "\u5C5E\u6027\u540D",
+    en: "Property",
+    ja: "\u5C5E\u6027\u540D",
+    ko: "\uC18D\uC131 \uC774\uB984"
+  },
+  user_id_display_name: {
+    zh: "\u5C5E\u6027\u663E\u793A\u540D",
+    en: "Display Name",
+    ja: "\u5C5E\u6027\u8868\u793A\u540D",
+    ko: "\uC18D\uC131 \uD45C\uC2DC \uC774\uB984"
+  },
+  user_id_desc: {
+    zh: "\u5C5E\u6027\u8BF4\u660E",
+    en: "Description",
+    ja: "\u5C5E\u6027\u8AAC\u660E",
+    ko: "\uC18D\uC131 \uC124\uBA85"
+  },
+  user_id_value_desc: {
+    zh: "\u8D4B\u503C\u8BF4\u660E",
+    en: "Value Description",
+    ja: "\u4EE3\u5165\u8AAC\u660E",
+    ko: "\uAC12 \uC124\uBA85"
+  }
+};
+function headerName(key, locale) {
+  return HEADERS[key][locale];
+}
+function allHeaderNames(key) {
+  return Object.values(HEADERS[key]);
+}
+
+// src/tracking/i18n/resources/xlsx/types.ts
+var PROP_TYPE_DISPLAY = {
+  string: { zh: "\u6587\u672C", en: "string", ja: "\u30B9\u30C8\u30EA\u30F3\u30B0", ko: "string" },
+  number: { zh: "\u6570\u503C", en: "number", ja: "\u6570\u5024", ko: "number" },
+  bool: { zh: "\u5E03\u5C14", en: "boolean", ja: "\u30D6\u30FC\u30EB\u5024", ko: "boolean" },
+  datetime: { zh: "\u65F6\u95F4", en: "datetime", ja: "\u6642\u9593", ko: "time" },
+  object: { zh: "\u5BF9\u8C61", en: "object", ja: "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8", ko: "object" },
+  array_row: { zh: "\u5BF9\u8C61\u7EC4", en: "object[]", ja: "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u914D\u5217", ko: "object_array" },
+  array_string: { zh: "\u5217\u8868", en: "string[]", ja: "\u914D\u5217", ko: "string_array" }
+};
+function typeToDisplay(type, locale) {
+  return PROP_TYPE_DISPLAY[type][locale];
+}
+var ALL_DISPLAY_TO_TYPE = {};
+for (const [canonical, locales] of Object.entries(PROP_TYPE_DISPLAY)) {
+  for (const val of Object.values(locales)) {
+    ALL_DISPLAY_TO_TYPE[val] = canonical;
+  }
+}
+var ALIASES = {
+  // zh alias（行业模板）
+  "\u5B57\u7B26\u4E32": "string",
+  "\u5BF9\u8C61": "object",
+  // en alias
+  "String": "string",
+  "Number": "number",
+  "Boolean": "bool",
+  "Bool": "bool",
+  "DateTime": "datetime",
+  "Time": "datetime",
+  "Object": "object",
+  "Row": "object",
+  "Object Array": "array_row",
+  "List": "array_string",
+  "String Array": "array_string",
+  // ja alias
+  "\u6587\u5B57\u5217": "string",
+  "\u30C6\u30AD\u30B9\u30C8": "string",
+  "\u30D6\u30FC\u30EB": "bool",
+  "\u65E5\u6642": "datetime",
+  // ko alias
+  "\uD14D\uC2A4\uD2B8": "string",
+  "\uBB38\uC790\uC5F4": "string",
+  "\uC22B\uC790": "number",
+  "\uBD80\uC6B8": "bool",
+  "\uB0A0\uC9DC\uC2DC\uAC04": "datetime",
+  "\uAC1D\uCCB4 \uBC30\uC5F4": "array_row",
+  "\uB9AC\uC2A4\uD2B8": "array_string"
+};
+Object.assign(ALL_DISPLAY_TO_TYPE, ALIASES);
+function displayToType(raw) {
+  const trimmed = raw.trim();
+  return ALL_DISPLAY_TO_TYPE[trimmed] ?? null;
+}
+
+// src/tracking/i18n/translate.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/tracking/paths.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function getPackageRoot() {
+  let cur = dirname(fileURLToPath(import.meta.url));
+  while (cur !== dirname(cur)) {
+    const pj = join(cur, "package.json");
+    if (existsSync(pj)) {
+      try {
+        const pkg2 = JSON.parse(readFileSync(pj, "utf8"));
+        if (pkg2.name === "@tant/ae-cli") return cur;
+      } catch {
+      }
+    }
+    cur = dirname(cur);
+  }
+  throw new Error("Could not locate ae-cli package root");
+}
+
+// src/tracking/i18n/translate.ts
+var loaded = /* @__PURE__ */ new Map();
+function i18nFile(locale) {
+  const root = getPackageRoot();
+  const candidates = [
+    join2(root, "dist", "tracking", "i18n", "resources", "cli", `${locale}.json`),
+    join2(root, "src", "tracking", "i18n", "resources", "cli", `${locale}.json`)
+  ];
+  for (const p of candidates) {
+    if (existsSync2(p)) return p;
+  }
+  return candidates[candidates.length - 1];
+}
+function loadSync(locale) {
+  if (loaded.has(locale)) return loaded.get(locale);
+  try {
+    const raw = readFileSync2(i18nFile(locale), "utf8");
+    const tree = JSON.parse(raw);
+    loaded.set(locale, tree);
+    return tree;
+  } catch {
+    if (locale !== "en") {
+      return loadSync("en");
+    }
+    loaded.set("en", {});
+    return {};
+  }
+}
+function t(key, params, locale) {
+  const loc = locale ?? detectCliLocale();
+  const tree = loadSync(loc);
+  const parts = key.split(".");
+  let node = tree;
+  for (const part of parts) {
+    if (typeof node !== "object" || node === null) return key;
+    node = node[part];
+  }
+  if (typeof node !== "string") return key;
+  if (params) {
+    return node.replace(/\{(\w+)\}/g, (_, name) => String(params[name] ?? `{${name}}`));
+  }
+  return node;
+}
+
+// src/tracking/xlsx/write.ts
+var PLATFORM_TO_XLSX = {
+  "client": "client",
+  "server": "server",
+  "both": "client,server"
+};
+var VALID_PROP_TYPES = /* @__PURE__ */ new Set(["string", "number", "bool", "datetime", "object", "array_row", "array_string"]);
+var VALID_UPDATE_TYPES = /* @__PURE__ */ new Set(["user_set", "user_setOnce", "user_add"]);
+var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*$/;
+var PROP_NAME_RE = /^[a-zA-Z#][a-zA-Z0-9_.]*$/;
+function validateDraft(d) {
+  const errors = [];
+  const eventNames = /* @__PURE__ */ new Set();
+  for (const evt of d.events) {
+    if (!SNAKE_CASE_RE.test(evt.event_name)) {
+      errors.push(`Event name "${evt.event_name}" does not match snake_case pattern`);
+    }
+    if (eventNames.has(evt.event_name)) {
+      errors.push(`Duplicate event_name: "${evt.event_name}"`);
+    }
+    eventNames.add(evt.event_name);
+  }
+  const eventProps = d.event_properties ?? d.common_properties ?? [];
+  const eventPropNames = /* @__PURE__ */ new Set();
+  const compositeProps = new Set(
+    eventProps.filter((p) => p.type === "array_row" || p.type === "object").map((p) => p.name)
+  );
+  for (const prop of eventProps) {
+    if (!PROP_NAME_RE.test(prop.name)) {
+      errors.push(`Event property name "${prop.name}" has invalid characters`);
+    }
+    if (prop.name.includes(".")) {
+      const parent = prop.name.split(".")[0];
+      if (!compositeProps.has(parent)) {
+        errors.push(`Nested property "${prop.name}" references non-composite parent "${parent}"`);
+      }
+    }
+    if (!VALID_PROP_TYPES.has(prop.type)) {
+      errors.push(`Event property "${prop.name}" has invalid type: "${prop.type}"`);
+    }
+    if (eventPropNames.has(prop.name)) {
+      errors.push(`Duplicate event property name: "${prop.name}"`);
+    }
+    eventPropNames.add(prop.name);
+  }
+  const commonProps = d.common_event_properties ?? d.common_properties ?? [];
+  const commonPropNames = /* @__PURE__ */ new Set();
+  for (const prop of commonProps) {
+    if (!VALID_PROP_TYPES.has(prop.type)) {
+      errors.push(`Common event property "${prop.name}" has invalid type: "${prop.type}"`);
+    }
+    if (commonPropNames.has(prop.name)) {
+      errors.push(`Duplicate common event property name: "${prop.name}"`);
+    }
+    commonPropNames.add(prop.name);
+  }
+  const userPropNames = /* @__PURE__ */ new Set();
+  for (const prop of d.user_properties) {
+    if (!VALID_PROP_TYPES.has(prop.type)) {
+      errors.push(`User property "${prop.name}" has invalid type: "${prop.type}"`);
+    }
+    if (prop.update_type && !VALID_UPDATE_TYPES.has(prop.update_type)) {
+      errors.push(`User property "${prop.name}" has invalid update_type: "${prop.update_type}"`);
+    }
+    if (userPropNames.has(prop.name)) {
+      errors.push(`Duplicate user property name: "${prop.name}"`);
+    }
+    userPropNames.add(prop.name);
+  }
+  for (const evt of d.events) {
+    if (!evt.prop_names) continue;
+    for (const propName of evt.prop_names) {
+      if (propName.startsWith("#")) continue;
+      if (!eventPropNames.has(propName)) {
+        errors.push(`Event "${evt.event_name}" references unknown event property "${propName}"`);
+      }
+    }
+  }
+  const eventDisplayNames = /* @__PURE__ */ new Map();
+  for (const prop of eventProps) {
+    if (prop.display_name) {
+      const names = eventDisplayNames.get(prop.display_name) || [];
+      names.push(prop.name);
+      eventDisplayNames.set(prop.display_name, names);
+    }
+  }
+  for (const [displayName, names] of eventDisplayNames) {
+    if (names.length > 1) {
+      errors.push(`Display name "${displayName}" is used by multiple event properties: ${names.join(", ")}`);
+    }
+  }
+  const commonDisplayNames = /* @__PURE__ */ new Map();
+  for (const prop of commonProps) {
+    if (prop.display_name) {
+      const names = commonDisplayNames.get(prop.display_name) || [];
+      names.push(prop.name);
+      commonDisplayNames.set(prop.display_name, names);
+    }
+  }
+  for (const [displayName, names] of commonDisplayNames) {
+    if (names.length > 1) {
+      errors.push(`Display name "${displayName}" is used by multiple common properties: ${names.join(", ")}`);
+    }
+  }
+  const userDisplayNames = /* @__PURE__ */ new Map();
+  for (const prop of d.user_properties) {
+    if (prop.display_name) {
+      const names = userDisplayNames.get(prop.display_name) || [];
+      names.push(prop.name);
+      userDisplayNames.set(prop.display_name, names);
+    }
+  }
+  for (const [displayName, names] of userDisplayNames) {
+    if (names.length > 1) {
+      errors.push(`Display name "${displayName}" is used by multiple user properties: ${names.join(", ")}`);
+    }
+  }
+  const compositeChildren = /* @__PURE__ */ new Map();
+  for (const prop of eventProps) {
+    if (prop.type === "array_row" || prop.type === "object") {
+      compositeChildren.set(prop.name, /* @__PURE__ */ new Set());
+    }
+  }
+  for (const prop of eventProps) {
+    if (prop.name.includes(".")) {
+      const parent = prop.name.split(".")[0];
+      const children = compositeChildren.get(parent);
+      if (children) {
+        children.add(prop.name);
+      }
+    }
+  }
+  for (const evt of d.events) {
+    if (!evt.prop_names) continue;
+    for (const parentName of compositeProps) {
+      if (evt.prop_names.includes(parentName)) {
+        const eventChildren = evt.prop_names.filter((p) => p.startsWith(parentName + "."));
+        const expectedChildren = compositeChildren.get(parentName);
+        if (expectedChildren && eventChildren.length > 0) {
+          for (const child of expectedChildren) {
+            if (!eventChildren.includes(child)) {
+              errors.push(`Event "${evt.event_name}" uses "${parentName}" but missing child "${child}"`);
+            }
+          }
+        }
+      }
+    }
+  }
+  const childPropTypes = /* @__PURE__ */ new Map();
+  for (const prop of eventProps) {
+    if (prop.name.includes(".")) {
+      const childName = prop.name;
+      const existing = childPropTypes.get(childName);
+      if (existing) {
+        if (existing.type !== prop.type) {
+          errors.push(`Child property "${childName}" has inconsistent types: "${existing.type}" vs "${prop.type}" (used in events: ${existing.events.join(", ")})`);
+        }
+      } else {
+        childPropTypes.set(childName, { type: prop.type, events: [] });
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`Draft validation failed:
+${errors.map((e) => "  - " + e).join("\n")}`);
+  }
+}
+async function writeDraftXlsx(d, outPath, locale = "zh") {
+  validateDraft(d);
+  const workbook = new ExcelJS.Workbook();
+  const eventSheet = workbook.addWorksheet(sheetName("event_data", locale));
+  eventSheet.addRow([
+    headerName("event_name", locale),
+    headerName("event_display_name", locale),
+    headerName("event_desc", locale),
+    headerName("event_tag", locale),
+    headerName("platform", locale),
+    headerName("prop_name", locale),
+    headerName("prop_display_name", locale),
+    headerName("prop_type", locale),
+    headerName("prop_desc", locale)
+  ]);
+  const propByName = new Map(d.event_properties.map((p) => [p.name, p]));
+  for (const evt of d.events) {
+    const startRow = eventSheet.rowCount + 1;
+    const platformStr = evt.platform ? PLATFORM_TO_XLSX[evt.platform] : "";
+    if (evt.prop_names.length === 0) {
+      eventSheet.addRow([
+        evt.event_name,
+        evt.display_name ?? "",
+        evt.event_desc ?? "",
+        evt.event_tag ?? "",
+        platformStr,
+        "",
+        "",
+        "",
+        ""
+      ]);
+    } else {
+      for (const propName of evt.prop_names) {
+        const prop = propByName.get(propName);
+        eventSheet.addRow([
+          evt.event_name,
+          evt.display_name ?? "",
+          evt.event_desc ?? "",
+          evt.event_tag ?? "",
+          platformStr,
+          prop?.name ?? propName,
+          prop?.display_name ?? "",
+          prop ? typeToDisplay(prop.type, locale) : "",
+          prop?.desc ?? ""
+        ]);
+      }
+      const endRow = eventSheet.rowCount;
+      if (endRow > startRow) {
+        for (const col of ["A", "B", "C", "D", "E"]) {
+          eventSheet.mergeCells(`${col}${startRow}:${col}${endRow}`);
+        }
+      }
+    }
+  }
+  const commonSheet = workbook.addWorksheet(sheetName("common_props", locale));
+  commonSheet.addRow([
+    headerName("common_prop_name", locale),
+    headerName("common_prop_display_name", locale),
+    headerName("common_prop_type", locale),
+    headerName("common_prop_desc", locale)
+  ]);
+  for (const prop of d.common_event_properties) {
+    commonSheet.addRow([
+      prop.name,
+      prop.display_name ?? "",
+      typeToDisplay(prop.type, locale),
+      prop.desc ?? ""
+    ]);
+  }
+  const userSheet = workbook.addWorksheet(sheetName("user_data", locale));
+  userSheet.addRow([
+    headerName("user_prop_name", locale),
+    headerName("user_prop_display_name", locale),
+    headerName("user_prop_type", locale),
+    headerName("update_type", locale),
+    headerName("user_prop_desc", locale),
+    headerName("prop_tag", locale)
+  ]);
+  for (const prop of d.user_properties) {
+    userSheet.addRow([
+      prop.name,
+      prop.display_name ?? "",
+      typeToDisplay(prop.type, locale),
+      prop.update_type ?? "user_set",
+      // 默认 user_set
+      prop.desc ?? "",
+      prop.prop_tag ?? ""
+    ]);
+  }
+  const userIdSheet = workbook.addWorksheet(sheetName("user_id", locale));
+  userIdSheet.addRow([
+    headerName("user_id_prop_name", locale),
+    headerName("user_id_display_name", locale),
+    headerName("user_id_desc", locale),
+    headerName("user_id_value_desc", locale)
+  ]);
+  userIdSheet.addRow(["#account_id", t("user_id.account_id_display", {}, locale), t("user_id.system_property", {}, locale), t("user_id.set_to", { field: d.meta.user_identity?.account_id_field ?? "account ID" }, locale)]);
+  userIdSheet.addRow(["#distinct_id", t("user_id.distinct_id_display", {}, locale), t("user_id.system_property", {}, locale), t("user_id.auto_generated", {}, locale)]);
+  await workbook.xlsx.writeFile(outPath);
+}
+
+// src/tracking/i18n/ae-locale.ts
+function aeLocaleToCli(raw) {
+  const normalized = raw.trim().replace("-", "_").toLowerCase();
+  if (normalized.startsWith("zh")) return "zh";
+  if (normalized.startsWith("en")) return "en";
+  if (normalized.startsWith("ja")) return "ja";
+  if (normalized.startsWith("ko")) return "ko";
+  return null;
+}
+function cliLocaleToAE(locale) {
+  switch (locale) {
+    case "zh":
+      return "zh_CN";
+    case "en":
+      return "en_US";
+    case "ja":
+      return "ja_JP";
+    case "ko":
+      return "ko_KR";
+  }
+}
+
+// src/core/tracking-client.ts
+var DEBUG_BASE = "/v1/ta/bury/manage/debug";
+function buildUrl(host, modulePath, params = {}) {
+  const base = host.replace(/\/$/, "");
+  const p = modulePath.startsWith("/") ? modulePath : `/${modulePath}`;
+  const url = new URL(`${base}${p}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+  }
+  return url.toString();
+}
+function extractLangFromConfig(data) {
+  if (!data) return null;
+  const raw = typeof data.lang === "string" && data.lang || typeof data.umi_locale === "string" && data.umi_locale || typeof data.locale === "string" && data.locale || null;
+  return raw ? aeLocaleToCli(raw) : null;
+}
+var TrackingClient = class {
+  constructor(host, token) {
+    this.host = host;
+    this.token = token;
+  }
+  host;
+  token;
+  async resolveToken() {
+    return this.token ?? getToken(this.host);
+  }
+  async getProgram(projectId) {
+    const data = await httpGet(
+      "/v1/ta/bury/manage/program/query",
+      { projectId, "@t": Date.now() },
+      this.host
+    );
+    return data ?? null;
+  }
+  async deleteProgram(projectId) {
+    const token = await this.resolveToken();
+    const url = buildUrl(this.host, "/v1/ta/bury/manage/program/delete", {
+      projectId,
+      "@t": Date.now()
+    });
+    const resp = await fetch(url, {
+      method: "GET",
+      headers: {
+        authorization: `bearer ${token}`,
+        accept: "application/json"
+      }
+    });
+    const env = safeJsonParse(await resp.text());
+    if (env.return_code !== 0) {
+      throw new Error(env.return_message || `AE API error (code: ${env.return_code})`);
+    }
+    return { return_code: env.return_code, return_message: env.return_message };
+  }
+  async uploadProgramExcel(args) {
+    const token = await this.resolveToken();
+    const form = new FormData();
+    form.append(
+      "file",
+      new Blob([new Uint8Array(args.file)], {
+        type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+      }),
+      args.filename
+    );
+    form.append("projectId", String(args.projectId));
+    form.append("access_token", token);
+    const url = buildUrl(this.host, "/v1/ta/bury/manage/program/excel-save");
+    const resp = await fetch(url, { method: "POST", body: form });
+    const env = safeJsonParse(await resp.text());
+    if (env.return_code !== 0 && env.return_code !== void 0 && !env.data?.eventErrorMap && !env.data?.userErrorMap) {
+      logger.error(`Upload failed: ${env.return_message || `AE API error (code: ${env.return_code})`}`);
+    }
+    return env;
+  }
+  async getUserAutoConfig() {
+    const data = await httpGet(
+      "/v1/ta/auto/config/getUserAutoConfig",
+      { "@t": Date.now() },
+      this.host
+    );
+    if (data && typeof data === "object") {
+      return data;
+    }
+    return null;
+  }
+  async getServerLang() {
+    const config = await this.getUserAutoConfig();
+    return extractLangFromConfig(config);
+  }
+  /** lang format: zh_CN, en_US, ja_JP, ko_KR */
+  async saveUserAutoConfig(langCode) {
+    await httpGet("/v1/ta/auto/config/getUserAutoConfig", { "@t": Date.now(), lang: langCode }, this.host);
+  }
+  async debugGet(path5, params) {
+    const data = await httpGet(`${DEBUG_BASE}${path5}`, { ...params, "@t": Date.now() }, this.host);
+    return data;
+  }
+  async listDevice(projectId) {
+    const data = await this.debugGet("/listDevice", { projectId });
+    return data?.deviceList ?? [];
+  }
+  async addDevice(projectId, deviceId, deviceName) {
+    await this.debugGet("/saveDevice", { deviceId, deviceName, projectId });
+  }
+  async selectDevice(projectId, deviceId) {
+    await this.debugGet("/chooseDevice", { deviceId, projectId });
+  }
+  async removeDevice(projectId, deviceId) {
+    await this.debugGet("/deleteDevice", { deviceId, projectId });
+  }
+  async listDeviceData(projectId, deviceId, startTime) {
+    const data = await this.debugGet("/listDeviceData", {
+      deviceID: deviceId,
+      projectId,
+      startTime
+    });
+    return data ?? { eventList: [], deviceDataList: [] };
+  }
+};
+async function createTrackingClient(host) {
+  const token = await getToken(host);
+  return new TrackingClient(host, token);
+}
+
+// src/tracking/te-plan/fetch.ts
+async function fetchPlan({ projectId, host }) {
+  const client = await createTrackingClient(host);
+  const data = await client.getProgram(projectId);
+  if (!data) {
+    throw new Error(t("error.fetch_no_data", { host }));
+  }
+  return normalize2(data);
+}
+function normalize2(data) {
+  return {
+    meta: { app_type: "unknown", sdk_integration_mode: "client_only", plan_name: "from-te" },
+    events: (data.events ?? []).map((e) => ({
+      event_name: e.eventName,
+      display_name: e.displayName,
+      event_tag: e.eventTag,
+      event_desc: e.eventDesc,
+      source: "chat",
+      prop_names: e.props ?? []
+    })),
+    event_properties: (data.eventProps ?? []).map((p) => ({
+      name: p.name,
+      display_name: p.displayName,
+      type: p.type?.toLowerCase() ?? "string",
+      desc: p.desc,
+      source: "chat"
+    })),
+    common_event_properties: (data.commonEventProps ?? []).map((p) => ({
+      name: p.name,
+      display_name: p.displayName,
+      type: p.type?.toLowerCase() ?? "string",
+      desc: p.desc,
+      source: "chat"
+    })),
+    user_properties: (data.userProps ?? []).map((p) => ({
+      name: p.name,
+      display_name: p.displayName,
+      type: p.type?.toLowerCase() ?? "string",
+      desc: p.desc,
+      update_type: p.updateType ?? "user_set",
+      prop_tag: p.propTag,
+      source: "chat"
+    }))
+  };
+}
+
+// src/tracking/plan/draft.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/tracking/plan/autotrack.ts
+var TAG = {
+  zh: "\u7CFB\u7EDF\u4E8B\u4EF6",
+  en: "System Event",
+  ja: "\u30B7\u30B9\u30C6\u30E0\u30A4\u30D9\u30F3\u30C8",
+  ko: "\uC2DC\uC2A4\uD15C \uC774\uBCA4\uD2B8"
+};
+var AUTOTRACK_I18N = {
+  // --- Android/iOS 通用 ---
+  ta_app_install: {
+    display_name: { zh: "APP \u5B89\u88C5", en: "App Install", ja: "\u30A2\u30D7\u30EA\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB", ko: "\uC571 \uC124\uCE58" },
+    desc: { zh: "APP \u9996\u6B21\u5B89\u88C5\u65F6\u4E0A\u62A5\uFF0C\u5347\u7EA7\u4E0D\u89E6\u53D1\uFF0C\u5220\u9664\u91CD\u88C5\u4F1A\u89E6\u53D1", en: "Triggered on first app install; not on upgrade; re-triggered on reinstall", ja: "\u30A2\u30D7\u30EA\u521D\u56DE\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u6642\u306B\u5831\u544A\u3002\u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9\u3067\u306F\u767A\u751F\u305B\u305A\u3001\u518D\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3067\u518D\u767A\u751F", ko: "\uC571 \uCD5C\uCD08 \uC124\uCE58 \uC2DC \uBCF4\uACE0\uB429\uB2C8\uB2E4. \uC5C5\uADF8\uB808\uC774\uB4DC \uC2DC\uC5D0\uB294 \uBC1C\uC0DD\uD558\uC9C0 \uC54A\uC73C\uBA70 \uC7AC\uC124\uCE58 \uC2DC \uB2E4\uC2DC \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_app_start: {
+    display_name: { zh: "APP \u542F\u52A8", en: "App Start", ja: "\u30A2\u30D7\u30EA\u8D77\u52D5", ko: "\uC571 \uC2DC\uC791" },
+    desc: { zh: "\u7528\u6237\u5F00\u542F APP \u6216\u4ECE\u540E\u53F0\u5524\u9192\u65F6\u89E6\u53D1", en: "Triggered when user opens the app or brings it from background", ja: "\u30E6\u30FC\u30B6\u30FC\u304C\u30A2\u30D7\u30EA\u3092\u958B\u304F\u304B\u3001\u30D0\u30C3\u30AF\u30B0\u30E9\u30A6\u30F3\u30C9\u304B\u3089\u5FA9\u5E30\u3057\u305F\u6642\u306B\u767A\u751F", ko: "\uC0AC\uC6A9\uC790\uAC00 \uC571\uC744 \uC5F4\uAC70\uB098 \uBC31\uADF8\uB77C\uC6B4\uB4DC\uC5D0\uC11C \uAC00\uC838\uC62C \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_app_end: {
+    display_name: { zh: "APP \u5173\u95ED", en: "App End", ja: "\u30A2\u30D7\u30EA\u7D42\u4E86", ko: "\uC571 \uC885\uB8CC" },
+    desc: { zh: "\u7528\u6237\u5173\u95ED APP \u6216\u5C06 APP \u8C03\u81F3\u540E\u53F0\u65F6\u89E6\u53D1", en: "Triggered when user closes the app or moves it to background", ja: "\u30E6\u30FC\u30B6\u30FC\u304C\u30A2\u30D7\u30EA\u3092\u9589\u3058\u308B\u304B\u3001\u30D0\u30C3\u30AF\u30B0\u30E9\u30A6\u30F3\u30C9\u306B\u79FB\u52D5\u3057\u305F\u6642\u306B\u767A\u751F", ko: "\uC0AC\uC6A9\uC790\uAC00 \uC571\uC744 \uB2EB\uAC70\uB098 \uBC31\uADF8\uB77C\uC6B4\uB4DC\uB85C \uC774\uB3D9\uD560 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_app_view: {
+    display_name: { zh: "APP \u9875\u9762\u6D4F\u89C8", en: "App Page View", ja: "\u30A2\u30D7\u30EA\u30DA\u30FC\u30B8\u30D3\u30E5\u30FC", ko: "\uC571 \uD398\uC774\uC9C0 \uC870\uD68C" },
+    desc: { zh: "\u7528\u6237\u6D4F\u89C8\u9875\u9762\uFF08Activity/ViewController\uFF09\u65F6\u89E6\u53D1", en: "Triggered when user views a page (Activity/ViewController)", ja: "\u30E6\u30FC\u30B6\u30FC\u304C\u30DA\u30FC\u30B8\uFF08Activity/ViewController\uFF09\u3092\u95B2\u89A7\u3057\u305F\u6642\u306B\u767A\u751F", ko: "\uC0AC\uC6A9\uC790\uAC00 \uD398\uC774\uC9C0(Activity/ViewController)\uB97C \uC870\uD68C\uD560 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_app_click: {
+    display_name: { zh: "APP \u63A7\u4EF6\u70B9\u51FB", en: "App Control Click", ja: "\u30A2\u30D7\u30EA\u30B3\u30F3\u30C8\u30ED\u30FC\u30EB\u30AF\u30EA\u30C3\u30AF", ko: "\uC571 \uCEE8\uD2B8\uB864 \uD074\uB9AD" },
+    desc: { zh: "\u7528\u6237\u70B9\u51FB\u63A7\u4EF6\u65F6\u89E6\u53D1", en: "Triggered when user clicks a UI control", ja: "\u30E6\u30FC\u30B6\u30FC\u304CUI\u30B3\u30F3\u30C8\u30ED\u30FC\u30EB\u3092\u30AF\u30EA\u30C3\u30AF\u3057\u305F\u6642\u306B\u767A\u751F", ko: "\uC0AC\uC6A9\uC790\uAC00 UI \uCEE8\uD2B8\uB864\uC744 \uD074\uB9AD\uD560 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_app_crash: {
+    display_name: { zh: "APP \u5D29\u6E83", en: "App Crash", ja: "\u30A2\u30D7\u30EA\u30AF\u30E9\u30C3\u30B7\u30E5", ko: "\uC571 \uCDA9\uB3CC" },
+    desc: { zh: "APP \u51FA\u73B0\u672A\u6355\u83B7\u5F02\u5E38\u65F6\u4E0A\u62A5", en: "Reported when the app encounters an uncaught exception", ja: "\u30A2\u30D7\u30EA\u304C\u30AD\u30E3\u30C3\u30C1\u3055\u308C\u306A\u3044\u4F8B\u5916\u306B\u906D\u9047\u3057\u305F\u6642\u306B\u5831\u544A", ko: "\uC571\uC774 \uCC98\uB9AC\uB418\uC9C0 \uC54A\uC740 \uC608\uC678\uB97C \uB9CC\uB0AC\uC744 \uB54C \uBCF4\uACE0\uB429\uB2C8\uB2E4" }
+  },
+  // --- JavaScript (Web/H5) ---
+  ta_pageview: {
+    display_name: { zh: "\u9875\u9762\u6D4F\u89C8", en: "Page View", ja: "\u30DA\u30FC\u30B8\u30D3\u30E5\u30FC", ko: "\uD398\uC774\uC9C0 \uC870\uD68C" },
+    desc: { zh: '\u8C03\u7528 ta.quick("autoTrack") \u65F6\u4E0A\u62A5', en: 'Reported when ta.quick("autoTrack") is called', ja: 'ta.quick("autoTrack") \u547C\u3073\u51FA\u3057\u6642\u306B\u5831\u544A', ko: 'ta.quick("autoTrack") \uD638\uCD9C \uC2DC \uBCF4\uACE0\uB429\uB2C8\uB2E4' }
+  },
+  ta_page_show: {
+    display_name: { zh: "\u9875\u9762\u663E\u793A", en: "Page Show", ja: "\u30DA\u30FC\u30B8\u8868\u793A", ko: "\uD398\uC774\uC9C0 \uD45C\uC2DC" },
+    desc: { zh: "\u9875\u9762\u663E\u793A\u65F6\u89E6\u53D1\uFF08\u9700\u5F00\u542F\u914D\u7F6E\uFF09", en: "Triggered when page is shown (requires config)", ja: "\u30DA\u30FC\u30B8\u8868\u793A\u6642\u306B\u767A\u751F\uFF08\u8A2D\u5B9A\u304C\u5FC5\u8981\uFF09", ko: "\uD398\uC774\uC9C0\uAC00 \uD45C\uC2DC\uB420 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4 (\uC124\uC815 \uD544\uC694)" }
+  },
+  ta_page_hide: {
+    display_name: { zh: "\u9875\u9762\u9690\u85CF", en: "Page Hide", ja: "\u30DA\u30FC\u30B8\u975E\u8868\u793A", ko: "\uD398\uC774\uC9C0 \uC228\uAE40" },
+    desc: { zh: "\u9875\u9762\u9690\u85CF\u65F6\u89E6\u53D1\uFF08\u9700\u5F00\u542F\u914D\u7F6E\uFF09", en: "Triggered when page is hidden (requires config)", ja: "\u30DA\u30FC\u30B8\u975E\u8868\u793A\u6642\u306B\u767A\u751F\uFF08\u8A2D\u5B9A\u304C\u5FC5\u8981\uFF09", ko: "\uD398\uC774\uC9C0\uAC00 \uC228\uACA8\uC9C8 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4 (\uC124\uC815 \uD544\uC694)" }
+  },
+  // --- 微信小程序 ---
+  ta_mp_launch: {
+    display_name: { zh: "\u5C0F\u7A0B\u5E8F\u521D\u59CB\u5316", en: "Mini Program Launch", ja: "\u30DF\u30CB\u30D7\u30ED\u30B0\u30E9\u30E0\u521D\u671F\u5316", ko: "\uBBF8\uB2C8\uD504\uB85C\uADF8\uB7A8 \uCD08\uAE30\uD654" },
+    desc: { zh: "\u5C0F\u7A0B\u5E8F\u88AB\u9996\u6B21\u6253\u5F00\u65F6\u89E6\u53D1\uFF0C\u8FDB\u7A0B\u751F\u547D\u5468\u671F\u5185\u53EA\u89E6\u53D1\u4E00\u6B21", en: "Triggered on first launch of mini program; only once per process lifecycle", ja: "\u30DF\u30CB\u30D7\u30ED\u30B0\u30E9\u30E0\u521D\u56DE\u8D77\u52D5\u6642\u306B\u767A\u751F\u3002\u30D7\u30ED\u30BB\u30B9\u30E9\u30A4\u30D5\u30B5\u30A4\u30AF\u30EB\u5185\u30671\u56DE\u306E\u307F", ko: "\uBBF8\uB2C8\uD504\uB85C\uADF8\uB7A8 \uCD5C\uCD08 \uC2E4\uD589 \uC2DC \uBC1C\uC0DD\uD569\uB2C8\uB2E4. \uD504\uB85C\uC138\uC2A4 \uC218\uBA85 \uC8FC\uAE30 \uB0B4 \uD55C \uBC88\uB9CC \uBC1C\uC0DD" }
+  },
+  ta_mp_show: {
+    display_name: { zh: "\u5C0F\u7A0B\u5E8F\u542F\u52A8", en: "Mini Program Show", ja: "\u30DF\u30CB\u30D7\u30ED\u30B0\u30E9\u30E0\u8D77\u52D5", ko: "\uBBF8\uB2C8\uD504\uB85C\uADF8\uB7A8 \uC2DC\uC791" },
+    desc: { zh: "\u5C0F\u7A0B\u5E8F\u88AB\u542F\u52A8\u6216\u4ECE\u540E\u53F0\u8C03\u56DE\u524D\u53F0\u65F6\u89E6\u53D1", en: "Triggered when mini program is launched or brought to foreground", ja: "\u30DF\u30CB\u30D7\u30ED\u30B0\u30E9\u30E0\u304C\u8D77\u52D5\u307E\u305F\u306F\u30D0\u30C3\u30AF\u30B0\u30E9\u30A6\u30F3\u30C9\u304B\u3089\u30D5\u30A9\u30A2\u30B0\u30E9\u30A6\u30F3\u30C9\u306B\u5FA9\u5E30\u3057\u305F\u6642\u306B\u767A\u751F", ko: "\uBBF8\uB2C8\uD504\uB85C\uADF8\uB7A8\uC774 \uC2DC\uC791\uB418\uAC70\uB098 \uBC31\uADF8\uB77C\uC6B4\uB4DC\uC5D0\uC11C \uD3EC\uADF8\uB77C\uC6B4\uB4DC\uB85C \uC804\uD658\uB420 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_mp_hide: {
+    display_name: { zh: "\u5C0F\u7A0B\u5E8F\u9690\u85CF", en: "Mini Program Hide", ja: "\u30DF\u30CB\u30D7\u30ED\u30B0\u30E9\u30E0\u975E\u8868\u793A", ko: "\uBBF8\uB2C8\uD504\uB85C\uADF8\uB7A8 \uC228\uAE40" },
+    desc: { zh: "\u5C0F\u7A0B\u5E8F\u88AB\u8C03\u5165\u540E\u53F0\u65F6\u89E6\u53D1", en: "Triggered when mini program is moved to background", ja: "\u30DF\u30CB\u30D7\u30ED\u30B0\u30E9\u30E0\u304C\u30D0\u30C3\u30AF\u30B0\u30E9\u30A6\u30F3\u30C9\u306B\u79FB\u52D5\u3057\u305F\u6642\u306B\u767A\u751F", ko: "\uBBF8\uB2C8\uD504\uB85C\uADF8\uB7A8\uC774 \uBC31\uADF8\uB77C\uC6B4\uB4DC\uB85C \uC774\uB3D9\uD560 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_mp_view: {
+    display_name: { zh: "\u5C0F\u7A0B\u5E8F\u9875\u9762\u6D4F\u89C8", en: "Mini Program Page View", ja: "\u30DF\u30CB\u30D7\u30ED\u30B0\u30E9\u30E0\u30DA\u30FC\u30B8\u30D3\u30E5\u30FC", ko: "\uBBF8\uB2C8\uD504\uB85C\uADF8\uB7A8 \uD398\uC774\uC9C0 \uC870\uD68C" },
+    desc: { zh: "\u9875\u9762\u88AB\u6253\u5F00\u6216\u4ECE\u540E\u53F0\u8C03\u56DE\u524D\u53F0\u65F6\u89E6\u53D1", en: "Triggered when page is opened or brought to foreground", ja: "\u30DA\u30FC\u30B8\u304C\u958B\u304B\u308C\u308B\u304B\u3001\u30D0\u30C3\u30AF\u30B0\u30E9\u30A6\u30F3\u30C9\u304B\u3089\u30D5\u30A9\u30A2\u30B0\u30E9\u30A6\u30F3\u30C9\u306B\u5FA9\u5E30\u3057\u305F\u6642\u306B\u767A\u751F", ko: "\uD398\uC774\uC9C0\uAC00 \uC5F4\uB9AC\uAC70\uB098 \uBC31\uADF8\uB77C\uC6B4\uB4DC\uC5D0\uC11C \uD3EC\uADF8\uB77C\uC6B4\uB4DC\uB85C \uC804\uD658\uB420 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_mp_share: {
+    display_name: { zh: "\u5C0F\u7A0B\u5E8F\u8F6C\u53D1\u5206\u4EAB", en: "Mini Program Share", ja: "\u30DF\u30CB\u30D7\u30ED\u30B0\u30E9\u30E0\u5171\u6709", ko: "\uBBF8\uB2C8\uD504\uB85C\uADF8\uB7A8 \uACF5\uC720" },
+    desc: { zh: "\u8F6C\u53D1\u6309\u94AE\u88AB\u70B9\u51FB\u65F6\u89E6\u53D1", en: "Triggered when the share button is clicked", ja: "\u5171\u6709\u30DC\u30BF\u30F3\u304C\u30AF\u30EA\u30C3\u30AF\u3055\u308C\u305F\u6642\u306B\u767A\u751F", ko: "\uACF5\uC720 \uBC84\uD2BC\uC774 \uD074\uB9AD\uB420 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_page_leave: {
+    display_name: { zh: "\u5C0F\u7A0B\u5E8F\u9875\u9762\u5378\u8F7D", en: "Mini Program Page Unload", ja: "\u30DF\u30CB\u30D7\u30ED\u30B0\u30E9\u30E0\u30DA\u30FC\u30B8\u30A2\u30F3\u30ED\u30FC\u30C9", ko: "\uBBF8\uB2C8\uD504\uB85C\uADF8\uB7A8 \uD398\uC774\uC9C0 \uC5B8\uB85C\uB4DC" },
+    desc: { zh: "\u9875\u9762\u5378\u8F7D\u65F6\u89E6\u53D1", en: "Triggered when the page is unloaded", ja: "\u30DA\u30FC\u30B8\u304C\u30A2\u30F3\u30ED\u30FC\u30C9\u3055\u308C\u305F\u6642\u306B\u767A\u751F", ko: "\uD398\uC774\uC9C0\uAC00 \uC5B8\uB85C\uB4DC\uB420 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_add_favorite: {
+    display_name: { zh: "\u5C0F\u7A0B\u5E8F\u9875\u9762\u6536\u85CF", en: "Mini Program Favorite", ja: "\u30DF\u30CB\u30D7\u30ED\u30B0\u30E9\u30E0\u304A\u6C17\u306B\u5165\u308A", ko: "\uBBF8\uB2C8\uD504\uB85C\uADF8\uB7A8 \uC990\uACA8\uCC3E\uAE30" },
+    desc: { zh: "\u9875\u9762\u88AB\u6536\u85CF\u65F6\u89E6\u53D1", en: "Triggered when the page is bookmarked", ja: "\u30DA\u30FC\u30B8\u304C\u30D6\u30C3\u30AF\u30DE\u30FC\u30AF\u3055\u308C\u305F\u6642\u306B\u767A\u751F", ko: "\uD398\uC774\uC9C0\uAC00 \uC990\uACA8\uCC3E\uAE30\uC5D0 \uCD94\uAC00\uB420 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_mp_click: {
+    display_name: { zh: "\u5C0F\u7A0B\u5E8F\u5143\u7D20\u70B9\u51FB", en: "Mini Program Element Click", ja: "\u30DF\u30CB\u30D7\u30ED\u30B0\u30E9\u30E0\u8981\u7D20\u30AF\u30EA\u30C3\u30AF", ko: "\uBBF8\uB2C8\uD504\uB85C\uADF8\uB7A8 \uC694\uC18C \uD074\uB9AD" },
+    desc: { zh: "\u9875\u9762\u5143\u7D20\u88AB\u70B9\u51FB\u65F6\u89E6\u53D1", en: "Triggered when a page element is clicked", ja: "\u30DA\u30FC\u30B8\u8981\u7D20\u304C\u30AF\u30EA\u30C3\u30AF\u3055\u308C\u305F\u6642\u306B\u767A\u751F", ko: "\uD398\uC774\uC9C0 \uC694\uC18C\uAC00 \uD074\uB9AD\uB420 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  // --- Unity 微信小游戏 ---
+  ta_mg_launch: {
+    display_name: { zh: "\u5C0F\u6E38\u620F\u521D\u59CB\u5316", en: "Mini Game Launch", ja: "\u30DF\u30CB\u30B2\u30FC\u30E0\u521D\u671F\u5316", ko: "\uBBF8\uB2C8\uAC8C\uC784 \uCD08\uAE30\uD654" },
+    desc: { zh: "\u5C0F\u6E38\u620F\u9996\u6B21\u6253\u5F00\u65F6\u89E6\u53D1", en: "Triggered on first launch of mini game", ja: "\u30DF\u30CB\u30B2\u30FC\u30E0\u521D\u56DE\u8D77\u52D5\u6642\u306B\u767A\u751F", ko: "\uBBF8\uB2C8\uAC8C\uC784 \uCD5C\uCD08 \uC2E4\uD589 \uC2DC \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_mg_show: {
+    display_name: { zh: "\u5C0F\u6E38\u620F\u542F\u52A8", en: "Mini Game Show", ja: "\u30DF\u30CB\u30B2\u30FC\u30E0\u8D77\u52D5", ko: "\uBBF8\uB2C8\uAC8C\uC784 \uC2DC\uC791" },
+    desc: { zh: "\u5C0F\u6E38\u620F\u8FDB\u5165\u524D\u53F0\u65F6\u89E6\u53D1", en: "Triggered when mini game enters foreground", ja: "\u30DF\u30CB\u30B2\u30FC\u30E0\u304C\u30D5\u30A9\u30A2\u30B0\u30E9\u30A6\u30F3\u30C9\u306B\u5165\u3063\u305F\u6642\u306B\u767A\u751F", ko: "\uBBF8\uB2C8\uAC8C\uC784\uC774 \uD3EC\uADF8\uB77C\uC6B4\uB4DC\uB85C \uC9C4\uC785\uD560 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_mg_hide: {
+    display_name: { zh: "\u5C0F\u6E38\u620F\u9690\u85CF", en: "Mini Game Hide", ja: "\u30DF\u30CB\u30B2\u30FC\u30E0\u975E\u8868\u793A", ko: "\uBBF8\uB2C8\uAC8C\uC784 \uC228\uAE40" },
+    desc: { zh: "\u5C0F\u6E38\u620F\u8FDB\u5165\u540E\u53F0\u65F6\u89E6\u53D1", en: "Triggered when mini game enters background", ja: "\u30DF\u30CB\u30B2\u30FC\u30E0\u304C\u30D0\u30C3\u30AF\u30B0\u30E9\u30A6\u30F3\u30C9\u306B\u5165\u3063\u305F\u6642\u306B\u767A\u751F", ko: "\uBBF8\uB2C8\uAC8C\uC784\uC774 \uBC31\uADF8\uB77C\uC6B4\uB4DC\uB85C \uC9C4\uC785\uD560 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  // --- Unity 场景事件（optional） ---
+  ta_scene_loaded: {
+    display_name: { zh: "\u573A\u666F\u52A0\u8F7D", en: "Scene Load", ja: "\u30B7\u30FC\u30F3\u30ED\u30FC\u30C9", ko: "\uC52C \uB85C\uB4DC" },
+    desc: { zh: "\u6E38\u620F\u573A\u666F\uFF08Scene\uFF09\u52A0\u8F7D\u65F6\u89E6\u53D1", en: "Triggered when a game scene is loaded", ja: "\u30B2\u30FC\u30E0\u30B7\u30FC\u30F3\uFF08Scene\uFF09\u306E\u30ED\u30FC\u30C9\u6642\u306B\u767A\u751F", ko: "\uAC8C\uC784 \uC52C(Scene)\uC774 \uB85C\uB4DC\uB420 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  },
+  ta_scene_unloaded: {
+    display_name: { zh: "\u573A\u666F\u5378\u8F7D", en: "Scene Unload", ja: "\u30B7\u30FC\u30F3\u30A2\u30F3\u30ED\u30FC\u30C9", ko: "\uC52C \uC5B8\uB85C\uB4DC" },
+    desc: { zh: "\u6E38\u620F\u573A\u666F\uFF08Scene\uFF09\u5378\u8F7D\u65F6\u89E6\u53D1", en: "Triggered when a game scene is unloaded", ja: "\u30B2\u30FC\u30E0\u30B7\u30FC\u30F3\uFF08Scene\uFF09\u306E\u30A2\u30F3\u30ED\u30FC\u30C9\u6642\u306B\u767A\u751F", ko: "\uAC8C\uC784 \uC52C(Scene)\uC774 \uC5B8\uB85C\uB4DC\uB420 \uB54C \uBC1C\uC0DD\uD569\uB2C8\uB2E4" }
+  }
+};
+function makeAutotrackEvent(eventName, locale) {
+  const i18n = AUTOTRACK_I18N[eventName];
+  return {
+    event_name: eventName,
+    display_name: i18n?.display_name[locale] ?? eventName,
+    event_tag: TAG[locale],
+    event_desc: i18n?.desc[locale] ?? "",
+    source: "autotrack",
+    prop_names: []
+  };
+}
+var SDK_RECOMMENDED = {
+  nativeApp: ["ta_app_install", "ta_app_start", "ta_app_end"],
+  js: ["ta_page_show", "ta_page_hide"],
+  wechatMp: ["ta_mp_launch", "ta_mp_show", "ta_mp_hide", "ta_mp_view", "ta_mp_share"],
+  wechatMg: ["ta_mp_launch", "ta_mp_show", "ta_mp_hide"],
+  unity: ["ta_app_install", "ta_app_start", "ta_app_end"],
+  unityWxmg: ["ta_mg_launch", "ta_mg_show", "ta_mg_hide"],
+  gameEngine: ["ta_app_install", "ta_app_start", "ta_app_end"]
+};
+function getAutotrackEvents(sdkType, locale = "zh") {
+  let group;
+  switch (sdkType) {
+    case "android":
+    case "ios":
+    case "react_native":
+    case "flutter":
+    case "uniapp_app":
+      group = "nativeApp";
+      break;
+    case "javascript":
+    case "uniapp_h5":
+      group = "js";
+      break;
+    case "wechat_mp":
+    case "douyin_mp":
+    case "alipay_mp":
+    case "other_mp":
+    case "uniapp_mp":
+      group = "wechatMp";
+      break;
+    case "wechat_mg":
+      group = "wechatMg";
+      break;
+    case "unity":
+      group = "unity";
+      break;
+    case "unity_wxmg":
+      group = "unityWxmg";
+      break;
+    case "cocos2dx":
+    case "cocoscreator":
+    case "layaair":
+    case "unreal":
+      group = "gameEngine";
+      break;
+    default:
+      return [];
+  }
+  return (SDK_RECOMMENDED[group] ?? []).map((name) => makeAutotrackEvent(name, locale));
+}
+
+// src/tracking/plan/draft.ts
+function injectAutotrackEvents(draft, locale = "zh") {
+  const mode = draft.meta.sdk_integration_mode;
+  if (mode === "server_only") {
+    return draft;
+  }
+  const platforms = draft.meta.client_platforms;
+  const sdkType = draft.meta.client_sdk_type || draft.meta.sdk_type;
+  if (!platforms?.length && !sdkType) {
+    return draft;
+  }
+  let autotrackEvents = [];
+  const sdkTypeOrPlatforms = platforms && platforms.length >= 2 ? platforms : sdkType || platforms;
+  if (Array.isArray(sdkTypeOrPlatforms)) {
+    const allEvents = sdkTypeOrPlatforms.map((t2) => getAutotrackEvents(t2, locale)).flat();
+    const seen = /* @__PURE__ */ new Set();
+    autotrackEvents = allEvents.filter((e) => {
+      if (seen.has(e.event_name)) return false;
+      seen.add(e.event_name);
+      return true;
+    });
+  } else {
+    autotrackEvents = getAutotrackEvents(sdkTypeOrPlatforms, locale);
+  }
+  const existingNames = new Set(draft.events.map((e) => e.event_name));
+  const newEvents = autotrackEvents.filter((e) => !existingNames.has(e.event_name));
+  const eventsWithPlatform = newEvents.map((e) => ({
+    ...e,
+    platform: "client"
+  }));
+  draft.events.push(...eventsWithPlatform);
+  return draft;
+}
+
+// src/tracking/plan/fix.ts
+function extractErrors(response) {
+  const errors = [];
+  if (response.data?.eventErrorMap) {
+    for (const [errorType, items] of Object.entries(response.data.eventErrorMap)) {
+      for (const item of items) {
+        errors.push({ ...item, errorType });
+      }
+    }
+  }
+  if (response.data?.userErrorMap) {
+    for (const [errorType, items] of Object.entries(response.data.userErrorMap)) {
+      for (const item of items) {
+        errors.push({ ...item, errorType });
+      }
+    }
+  }
+  return errors;
+}
+function fixDisplayDuplicate(draft, errors) {
+  const duplicateDisplayNames = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    if (error.errorType === "event_prop_display_duplicate") {
+      const names = duplicateDisplayNames.get(error.value) || [];
+      names.push(error.value);
+      duplicateDisplayNames.set(error.value, names);
+    }
+  }
+  for (const prop of draft.event_properties) {
+    if (duplicateDisplayNames.has(prop.display_name || "")) {
+      const eventsUsingProp = draft.events.filter((e) => e.prop_names.includes(prop.name));
+      if (prop.name.includes(".")) {
+        prop.display_name = `\u660E\u7EC6${prop.display_name}`;
+      } else if (eventsUsingProp.length > 0) {
+        prop.display_name = `${prop.display_name}${t("fix.detail_suffix")}`;
+      }
+    }
+  }
+}
+function fixArrayRowConsistency(draft, errors) {
+  const compositeChildren = /* @__PURE__ */ new Map();
+  const evProps = draft.event_properties ?? draft.common_properties ?? [];
+  for (const prop of evProps) {
+    if (prop.type === "array_row" || prop.type === "object") {
+      compositeChildren.set(prop.name, []);
+    }
+  }
+  for (const prop of evProps) {
+    if (prop.name.includes(".")) {
+      const parent = prop.name.split(".")[0];
+      const children = compositeChildren.get(parent);
+      if (children) {
+        children.push(prop.name);
+      }
+    }
+  }
+  for (const event of draft.events) {
+    if (!event.prop_names) continue;
+    const propNamesSet = new Set(event.prop_names);
+    for (const [parentName, children] of compositeChildren) {
+      if (propNamesSet.has(parentName)) {
+        for (const child of children) {
+          if (!propNamesSet.has(child)) {
+            event.prop_names.push(child);
+          }
+        }
+        const parentProps = event.prop_names.filter(
+          (p) => p === parentName || p.startsWith(parentName + ".")
+        );
+        const sorted = [parentName, ...children.filter((c) => event.prop_names.includes(c))];
+        event.prop_names = event.prop_names.filter(
+          (p) => !p.startsWith(parentName) || p === parentName
+        );
+        const idx = event.prop_names.indexOf(parentName);
+        if (idx >= 0) {
+          event.prop_names.splice(idx, 1, ...sorted);
+        }
+      }
+    }
+  }
+}
+function fixUnknownPropRefs(draft) {
+  const fixed = [];
+  const props = draft.event_properties ?? draft.common_properties ?? [];
+  const eventPropNames = new Set(props.map((p) => p.name));
+  for (const event of draft.events) {
+    if (!event.prop_names) continue;
+    const removed = [];
+    event.prop_names = event.prop_names.filter((pn) => {
+      if (pn.startsWith("#")) return true;
+      if (eventPropNames.has(pn)) return true;
+      removed.push(pn);
+      return false;
+    });
+    if (removed.length > 0) {
+      fixed.push(...removed.map((r) => `Removed unknown prop "${r}" from event "${event.event_name}"`));
+    }
+  }
+  return fixed;
+}
+function fixDisplayNameDuplicates(draft) {
+  const fixed = [];
+  const pools = [
+    { name: "event_properties", items: draft.event_properties ?? draft.common_properties ?? [] },
+    { name: "common_event_properties", items: draft.common_event_properties ?? draft.common_properties ?? [] },
+    { name: "user_properties", items: draft.user_properties ?? [] }
+  ];
+  for (const pool of pools) {
+    const displayMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < pool.items.length; i++) {
+      const dn = pool.items[i].display_name;
+      if (!dn) continue;
+      const list = displayMap.get(dn) || [];
+      list.push(i);
+      displayMap.set(dn, list);
+    }
+    for (const [displayName, indices] of displayMap) {
+      if (indices.length <= 1) continue;
+      for (let j = 1; j < indices.length; j++) {
+        const prop = pool.items[indices[j]];
+        const newDisplayName = `${displayName} (${prop.name})`;
+        prop.display_name = newDisplayName;
+        fixed.push(`Disambiguated display name "${displayName}" \u2192 "${newDisplayName}" in ${pool.name}`);
+      }
+    }
+  }
+  return fixed;
+}
+function fixEventPropNameInvalid(draft, errors) {
+  const invalidNames = /* @__PURE__ */ new Set();
+  for (const error of errors) {
+    if (error.errorType === "event_prop_name_invalid") {
+      invalidNames.add(error.value);
+    }
+  }
+  for (const prop of draft.event_properties) {
+    if (invalidNames.has(prop.name)) {
+      const fixedName = prop.name.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
+      const oldName = prop.name;
+      prop.name = fixedName;
+      for (const event of draft.events) {
+        const idx = event.prop_names.indexOf(oldName);
+        if (idx >= 0) {
+          event.prop_names[idx] = fixedName;
+        }
+      }
+      if (prop.display_name && !prop.display_name.includes("(")) {
+        prop.display_name = `${prop.display_name}${t("fix.auto_fix_suffix")}`;
+      }
+    }
+  }
+}
+function fixEventNameDuplicate(draft, errors) {
+  const duplicateEvents = /* @__PURE__ */ new Set();
+  for (const error of errors) {
+    if (error.errorType === "event_name_duplicate") {
+      duplicateEvents.add(error.value);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  draft.events = draft.events.filter((event) => {
+    if (duplicateEvents.has(event.event_name)) {
+      if (seen.has(event.event_name)) {
+        return false;
+      }
+      seen.add(event.event_name);
+    }
+    return true;
+  });
+}
+function fixDraft(draft, response) {
+  const errors = extractErrors(response);
+  const fixed = [];
+  if (errors.length === 0) {
+    return fixed;
+  }
+  const errorTypes = new Set(errors.map((e) => e.errorType));
+  if (errorTypes.has("event_prop_display_duplicate")) {
+    fixDisplayDuplicate(draft, errors);
+    fixed.push(t("fix.display_name_dedup"));
+  }
+  if (errorTypes.has("complex_event_property_should_has_same_child_property")) {
+    fixArrayRowConsistency(draft, errors);
+    fixed.push(t("fix.array_row_consistency"));
+  }
+  if (errorTypes.has("event_prop_name_invalid")) {
+    fixEventPropNameInvalid(draft, errors);
+    fixed.push(t("fix.event_prop_name_invalid"));
+  }
+  if (errorTypes.has("event_name_duplicate")) {
+    fixEventNameDuplicate(draft, errors);
+    fixed.push(t("fix.event_name_duplicate"));
+  }
+  return fixed;
+}
+function validateAndFix(draft) {
+  const fixed = [];
+  const unknownFixes = fixUnknownPropRefs(draft);
+  if (unknownFixes.length > 0) {
+    fixed.push(t("fix.unknown_prop_ref"));
+  }
+  const displayFixes = fixDisplayNameDuplicates(draft);
+  if (displayFixes.length > 0) {
+    fixed.push(t("fix.display_name_dedup"));
+  }
+  const compositeChildren = /* @__PURE__ */ new Map();
+  const evProps = draft.event_properties ?? draft.common_properties ?? [];
+  for (const prop of evProps) {
+    if (prop.type === "array_row" || prop.type === "object") {
+      compositeChildren.set(prop.name, []);
+    }
+  }
+  for (const prop of evProps) {
+    if (prop.name.includes(".")) {
+      const parent = prop.name.split(".")[0];
+      const children = compositeChildren.get(parent);
+      if (children) {
+        children.push(prop.name);
+      }
+    }
+  }
+  let needFix = false;
+  for (const event of draft.events) {
+    if (!event.prop_names) continue;
+    for (const [parentName, children] of compositeChildren) {
+      if (event.prop_names.includes(parentName)) {
+        for (const child of children) {
+          if (!event.prop_names.includes(child)) {
+            needFix = true;
+          }
+        }
+      }
+    }
+  }
+  if (needFix) {
+    fixArrayRowConsistency(draft, []);
+    fixed.push(t("fix.array_row_consistency"));
+  }
+  return fixed;
+}
+
+// src/tracking/plan/conflict.ts
+function detectConflicts(newDraft, existingDraft) {
+  const conflicts = [];
+  for (const newProp of newDraft.event_properties) {
+    const existingProp = existingDraft.event_properties.find((p) => p.name === newProp.name);
+    if (existingProp && existingProp.type !== newProp.type) {
+      conflicts.push({
+        type: "property_type_conflict",
+        severity: "error",
+        name: newProp.name,
+        existingType: existingProp.type,
+        newType: newProp.type
+      });
+    }
+  }
+  for (const newProp of newDraft.common_event_properties) {
+    const existingProp = existingDraft.common_event_properties.find((p) => p.name === newProp.name);
+    if (existingProp && existingProp.type !== newProp.type) {
+      conflicts.push({
+        type: "property_type_conflict",
+        severity: "error",
+        name: newProp.name,
+        existingType: existingProp.type,
+        newType: newProp.type
+      });
+    }
+  }
+  for (const newProp of newDraft.user_properties) {
+    const existingProp = existingDraft.user_properties.find((p) => p.name === newProp.name);
+    if (existingProp && existingProp.type !== newProp.type) {
+      conflicts.push({
+        type: "property_type_conflict",
+        severity: "error",
+        name: newProp.name,
+        existingType: existingProp.type,
+        newType: newProp.type
+      });
+    }
+  }
+  for (const newEvent of newDraft.events) {
+    const existingEvent = existingDraft.events.find((e) => e.event_name === newEvent.event_name);
+    if (existingEvent) {
+      conflicts.push({
+        type: "event_exists",
+        severity: "warning",
+        name: newEvent.event_name,
+        existingPropCount: existingEvent.prop_names.length,
+        newPropCount: newEvent.prop_names.length
+      });
+    }
+  }
+  return {
+    hasErrors: conflicts.some((c) => c.severity === "error"),
+    hasWarnings: conflicts.some((c) => c.severity === "warning"),
+    conflicts
+  };
+}
+function formatConflictReport(result, existingSummary) {
+  const lines = [];
+  lines.push(t("conflict.existing_plan_title"));
+  lines.push(t("conflict.events_count", { count: existingSummary.events }));
+  lines.push(t("conflict.event_props_count", { count: existingSummary.eventProps }));
+  lines.push(t("conflict.common_props_count", { count: existingSummary.commonProps }));
+  lines.push(t("conflict.user_props_count", { count: existingSummary.userProps }));
+  lines.push("");
+  if (result.hasErrors) {
+    lines.push(t("conflict.severe_conflict_title"));
+    lines.push("");
+    lines.push(t("conflict.type_conflict_explanation"));
+    lines.push("");
+    lines.push(t("conflict.type_conflict_table_header"));
+    lines.push("|---|---|---|");
+    for (const c of result.conflicts.filter((c2) => c2.type === "property_type_conflict")) {
+      lines.push(`| ${c.name} | ${c.existingType} | ${c.newType} |`);
+    }
+    lines.push("");
+    lines.push(t("conflict.suggestion"));
+    lines.push(t("conflict.suggestion_fix_types"));
+    lines.push(t("conflict.suggestion_use_replace"));
+  }
+  if (result.hasWarnings && !result.hasErrors) {
+    lines.push(t("conflict.warning_event_exists_title"));
+    lines.push("");
+    for (const c of result.conflicts.filter((c2) => c2.type === "event_exists")) {
+      lines.push(t("conflict.event_exists_detail", { name: c.name, existingCount: c.existingPropCount ?? 0, newCount: c.newPropCount ?? 0 }));
+    }
+    lines.push("");
+    lines.push(t("conflict.append_note"));
+    lines.push(t("conflict.append_note_1"));
+    lines.push(t("conflict.append_note_2"));
+    lines.push(t("conflict.append_note_3"));
+  }
+  return lines.join("\n");
+}
+
+// src/commands/tracking/plan.ts
+import { readdir } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+
+// src/commands/tracking/shared.ts
+import { existsSync as existsSync3, statSync } from "fs";
+var HOST_OPTION_DESC = "Override active AE host URL";
+function resolveTrackingHost(program2, opts) {
+  const root = program2.root ?? program2;
+  const globalHost = root.opts()?.host;
+  const host = resolveHost(opts.host || globalHost);
+  if (!host) {
+    throw new Error("No active AE host configured. Run: ae-cli auth login");
+  }
+  return host;
+}
+function isExistingDirectory(path5) {
+  if (!existsSync3(path5)) return false;
+  try {
+    return statSync(path5).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function assertOutputFilePath(path5, optionName = "--out") {
+  const trimmed = path5.trim();
+  if (trimmed.endsWith("/") || trimmed.endsWith("\\") || isExistingDirectory(trimmed)) {
+    console.error(t("error.output_path_is_directory", { path: trimmed, option: optionName }));
+    process.exit(1);
+  }
+}
+function assertInputFilePath(path5, optionName = "--in") {
+  const trimmed = path5.trim();
+  if (!existsSync3(trimmed)) {
+    console.error(t("error.input_path_not_found", { path: trimmed, option: optionName }));
+    process.exit(1);
+  }
+  if (isExistingDirectory(trimmed)) {
+    console.error(t("error.input_path_is_directory", { path: trimmed, option: optionName }));
+    process.exit(1);
+  }
+}
+
+// src/commands/tracking/plan.ts
+var MAX_FIX_RETRIES = 3;
+var TEMPLATE_DIRS = [
+  resolve(getPackageRoot(), "tracking-plan-template"),
+  resolve(getConfigDir(), "templates")
+];
+function registerPlan(cmd, rootProgram) {
+  cmd.description("manage AE tracking plans");
+  cmd.command("draft").description("Generate xlsx from draft.json (inject autotrack events; use --fix to auto-repair validation errors)").requiredOption("--in <path>", "draft JSON input").requiredOption("--out <path>", "xlsx output").option("--fix", "auto fix validation errors", false).action(async (opts) => {
+    assertInputFilePath(opts.in, "--in");
+    assertOutputFilePath(opts.out, "--out");
+    const draft = JSON.parse(await readFile(opts.in, "utf8"));
+    const locale = draft.meta.lang ?? detectCliLocale();
+    injectAutotrackEvents(draft, locale);
+    if (opts.fix) {
+      const fixed = validateAndFix(draft);
+      if (fixed.length > 0) {
+        console.log(t("plan.draft_autofixed", { items: fixed.join(", ") }));
+        await writeFile(opts.in, JSON.stringify(draft, null, 2), "utf8");
+      }
+    }
+    try {
+      validateDraft(draft);
+    } catch (e) {
+      if (!opts.fix) {
+        throw e;
+      }
+      console.log(t("plan.draft_validation_failed_attempting_fix"));
+      for (let retry = 0; retry < MAX_FIX_RETRIES; retry++) {
+        const fixed = validateAndFix(draft);
+        if (fixed.length === 0) {
+          console.error(t("plan.no_auto_fix_available"));
+          console.error(e instanceof Error ? e.message : String(e));
+          process.exit(1);
+        }
+        console.log(t("plan.draft_fixed", { items: fixed.join(", ") }));
+        await writeFile(opts.in, JSON.stringify(draft, null, 2), "utf8");
+        try {
+          validateDraft(draft);
+          break;
+        } catch (retryErr) {
+          if (retry === MAX_FIX_RETRIES - 1) {
+            console.error(t("plan.validate_still_errors_after_fix", {
+              error: retryErr instanceof Error ? retryErr.message : String(retryErr)
+            }));
+            console.error(t("plan.max_fix_retries"));
+            process.exit(1);
+          }
+        }
+      }
+    }
+    await writeDraftXlsx(draft, opts.out, locale);
+    const counts = `events=${draft.events.length}, event_props=${draft.event_properties.length}, common=${draft.common_event_properties.length}, user=${draft.user_properties.length}`;
+    console.log(t("plan.wrote_xlsx", { path: opts.out, counts }));
+  });
+  cmd.command("validate").description("Validate draft.json structure and field rules").requiredOption("--in <path>", "draft JSON input").option("--fix", "auto fix validation errors", false).action(async (opts) => {
+    assertInputFilePath(opts.in, "--in");
+    const draft = JSON.parse(await readFile(opts.in, "utf8"));
+    try {
+      validateDraft(draft);
+      console.log(t("plan.validate_passed"));
+    } catch (e) {
+      const errorMsg = e instanceof Error ? e.message : String(e);
+      console.log(t("plan.validate_failed") + "\n" + errorMsg);
+      if (opts.fix) {
+        console.log("\n" + t("plan.attempting_auto_fix") + "...");
+        const fixed = validateAndFix(draft);
+        if (fixed.length > 0) {
+          console.log(t("plan.fixed_items", { items: fixed.join(", ") }));
+          await writeFile(opts.in, JSON.stringify(draft, null, 2), "utf8");
+          console.log(t("plan.updated_file", { path: opts.in }));
+          try {
+            validateDraft(draft);
+            console.log(t("plan.validate_passed_after_fix"));
+          } catch (e2) {
+            console.log(t("plan.validate_still_errors_after_fix", { error: e2 instanceof Error ? e2.message : String(e2) }));
+          }
+        } else {
+          console.log(t("plan.no_auto_fix_available"));
+        }
+      }
+    }
+  });
+  cmd.command("upload").description("Upload xlsx tracking plan to AE (conflict check, auto-fix retry, optional --switch-lang)").requiredOption("-p, --project <id>", "AE projectId", (v) => parseInt(v, 10)).requiredOption("--xlsx <path>", "xlsx file").requiredOption("--draft <path>", "draft JSON (for auto-fix)").option("--host <url>", HOST_OPTION_DESC).option("--lang <locale>", "xlsx language: zh / en / ja / ko").option("--replace", "delete existing plan first", false).option("--auto-fix", "auto fix upload errors and retry", true).option("--switch-lang", "auto switch AE project language to match xlsx", false).action(async (opts) => {
+    assertInputFilePath(opts.draft, "--draft");
+    assertInputFilePath(opts.xlsx, "--xlsx");
+    const host = resolveTrackingHost(rootProgram, opts);
+    let client = await createTrackingClient(host);
+    const draftPre = JSON.parse(await readFile(opts.draft, "utf8"));
+    const xlsxLocale = opts.lang ?? draftPre.meta.lang ?? detectCliLocale();
+    const aeLocale = await client.getServerLang();
+    if (aeLocale && aeLocale !== xlsxLocale) {
+      console.log("\n" + t("plan.ae_lang_mismatch", { aeLang: aeLocale, xlsxLang: xlsxLocale }));
+      if (opts.switchLang) {
+        const aeLangCode = cliLocaleToAE(xlsxLocale);
+        await client.saveUserAutoConfig(aeLangCode);
+        console.log(t("plan.ae_lang_switched", { aeLang: aeLangCode }));
+        await new Promise((r) => setTimeout(r, 2e3));
+        client = await createTrackingClient(host);
+      } else {
+        console.log(t("plan.ae_lang_switch_hint"));
+        process.exit(13);
+      }
+    }
+    if (!opts.replace) {
+      console.log(t("plan.checking_conflicts"));
+      try {
+        const existingDraft = await fetchPlan({ projectId: opts.project, host });
+        const conflictResult = detectConflicts(draftPre, existingDraft);
+        if (conflictResult.hasErrors) {
+          const existingSummary = {
+            events: existingDraft.events.length,
+            eventProps: existingDraft.event_properties.length,
+            commonProps: existingDraft.common_event_properties.length,
+            userProps: existingDraft.user_properties.length
+          };
+          console.log("\n" + formatConflictReport(conflictResult, existingSummary));
+          console.log("\n" + t("plan.cannot_append_mode"));
+          return;
+        }
+        if (conflictResult.hasWarnings) {
+          const existingSummary = {
+            events: existingDraft.events.length,
+            eventProps: existingDraft.event_properties.length,
+            commonProps: existingDraft.common_event_properties.length,
+            userProps: existingDraft.user_properties.length
+          };
+          console.log("\n" + formatConflictReport(conflictResult, existingSummary));
+          console.log("\n" + t("plan.append_continue_note") + "\n");
+        }
+      } catch (e) {
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        if (errorMsg.includes("return_code -1001") || errorMsg.includes("token expired") || errorMsg.includes("Session expired")) {
+          console.log(t("plan.token_expired_refreshing"));
+          client = await createTrackingClient(host);
+        } else {
+          console.log(t("plan.no_existing_plan"));
+        }
+      }
+    }
+    if (opts.replace) {
+      const del = await client.deleteProgram(opts.project);
+      console.log(t("plan.deleted_existing_plan", { message: del.return_message }));
+      await new Promise((resolve2) => setTimeout(resolve2, 5e3));
+    }
+    let retryCount = 0;
+    let draft = JSON.parse(await readFile(opts.draft, "utf8"));
+    const locale = opts.lang ?? draft.meta.lang ?? "zh";
+    let tokenRefreshed = false;
+    let lastRes = null;
+    while (retryCount < MAX_FIX_RETRIES) {
+      const file = await readFile(opts.xlsx);
+      lastRes = await client.uploadProgramExcel({
+        projectId: opts.project,
+        file,
+        filename: path3.basename(opts.xlsx)
+      });
+      console.log(JSON.stringify(lastRes, null, 2));
+      if (lastRes.return_code === -1001 && !tokenRefreshed) {
+        console.log("[auth] token expired during upload, refreshing session...");
+        client = await createTrackingClient(host);
+        tokenRefreshed = true;
+        continue;
+      }
+      const errors = extractErrors(lastRes);
+      if (errors.length === 0 || lastRes.return_code !== 0) {
+        break;
+      }
+      if (!opts.autoFix) {
+        console.log("\n" + t("plan.upload_has_validation_errors"));
+        break;
+      }
+      console.log("\n" + t("plan.auto_fixing_retry", { current: retryCount + 1, max: MAX_FIX_RETRIES }) + "...");
+      const fixed = fixDraft(draft, lastRes);
+      if (fixed.length === 0) {
+        console.log(t("plan.no_auto_fix_upload"));
+        break;
+      }
+      console.log(t("plan.fixed_items", { items: fixed.join(", ") }));
+      await writeFile(opts.draft, JSON.stringify(draft, null, 2), "utf8");
+      injectAutotrackEvents(draft, locale);
+      await writeDraftXlsx(draft, opts.xlsx, locale);
+      console.log(t("plan.regenerated_xlsx", { path: opts.xlsx }));
+      retryCount++;
+    }
+    if (retryCount >= MAX_FIX_RETRIES) {
+      console.log("\n" + t("plan.max_fix_retries"));
+    }
+    const msg = lastRes?.return_message ?? "";
+    const isLangMismatch = msg.includes("\u65E0\u6CD5\u8BC6\u522B\u8868\u683C\u5185\u5BB9") || msg.includes("The content of the form cannot be recognized") || msg.includes("\u30C6\u30FC\u30D6\u30EB\u306E\u5185\u5BB9\u3092\u8A8D\u8B58\u3067\u304D\u307E\u305B\u3093") || msg.includes("\uD2B8\uB798\uD0B9 \uBC29\uC548\uC744 \uC2E4\uBCC4 \uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+    if (lastRes && lastRes.return_code !== 0 && isLangMismatch) {
+      const xlsxLocale2 = opts.lang ?? draft.meta.lang ?? detectCliLocale();
+      console.log("\n" + t("plan.language_mismatch_hint", { locale: xlsxLocale2 }));
+    }
+  });
+  cmd.command("fetch").description("Fetch tracking plan from AE and output draft.json").requiredOption("-p, --project <id>", "AE projectId", (v) => parseInt(v, 10)).option("--host <url>", HOST_OPTION_DESC).option("--out <path>", "write to file instead of stdout").action(async (opts) => {
+    if (opts.out) assertOutputFilePath(opts.out, "--out");
+    const host = resolveTrackingHost(rootProgram, opts);
+    const draft = await fetchPlan({ projectId: opts.project, host });
+    const s = JSON.stringify(draft, null, 2) + "\n";
+    if (opts.out) {
+      await writeFile(opts.out, s, "utf8");
+    } else process.stdout.write(s);
+  });
+  cmd.command("archive").description("Copy draft.xlsx to plans/ and record archive metadata in draft.json").requiredOption("--draft <path>", "draft.json path").requiredOption("--xlsx <path>", "draft.xlsx path").requiredOption("--name <name>", "plan name for filename").option("--plans-dir <dir>", "plans output directory", resolve(process.cwd(), "plans")).action(async (opts) => {
+    assertInputFilePath(opts.draft, "--draft");
+    assertInputFilePath(opts.xlsx, "--xlsx");
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const dest = resolve(opts.plansDir, `${stamp}-${opts.name}.xlsx`);
+    if (existsSync4(dest)) {
+      console.error(t("plan.archive_exists", { path: dest }));
+      console.error(t("plan.remove_or_rename"));
+      return;
+    }
+    try {
+      await cp(opts.xlsx, dest);
+    } catch (e) {
+      if (e.code === "EEXIST") {
+        console.error(t("plan.archive_exists", { path: dest }));
+        console.error(t("plan.remove_or_rename"));
+        return;
+      }
+      throw e;
+    }
+    const draft = JSON.parse(await readFile(opts.draft, "utf8"));
+    draft.meta.archived_at = stamp;
+    draft.meta.archived_path = dest;
+    await writeFile(opts.draft, JSON.stringify(draft, null, 2), "utf8");
+    console.log(t("plan.archived_to", { path: dest }));
+    console.log(t("plan.draft_updated_archived", { stamp }));
+  });
+  cmd.command("delete").description("Delete the entire tracking plan from an AE project").requiredOption("-p, --project <id>", "AE projectId", (v) => parseInt(v, 10)).option("--host <url>", HOST_OPTION_DESC).action(async (opts) => {
+    const host = resolveTrackingHost(rootProgram, opts);
+    const client = await createTrackingClient(host);
+    const res = await client.deleteProgram(opts.project);
+    console.log(JSON.stringify(res, null, 2));
+  });
+  cmd.command("list-templates").description("List bundled and user tracking plan templates (xlsx/md)").action(async () => {
+    const found = [];
+    for (const dir of TEMPLATE_DIRS) {
+      if (!existsSync4(dir)) continue;
+      let entries = [];
+      try {
+        entries = await readdir(dir);
+      } catch {
+        continue;
+      }
+      for (const f of entries) {
+        if (!f.endsWith(".xlsx")) continue;
+        const base = f.replace(/\.xlsx$/i, "");
+        const mdPath = resolve(dir, base + ".md");
+        const hasMd = existsSync4(mdPath);
+        found.push({
+          path: hasMd ? mdPath : resolve(dir, f),
+          name: base,
+          hasMd
+        });
+      }
+    }
+    if (found.length === 0) {
+      console.log(t("plan.no_templates_found", { dirs: TEMPLATE_DIRS.join(", ") }));
+      return;
+    }
+    console.log(t("plan.templates_found", { count: found.length }) + "\n");
+    for (const tmpl of found) {
+      const mdNote = tmpl.hasMd ? t("plan.template_md_label") : t("plan.template_xlsx_label");
+      console.log(`  ${tmpl.name}${mdNote}`);
+      console.log(`    ${tmpl.path}`);
+    }
+  });
+}
+
+// src/commands/tracking/code.ts
+import { readFile as readFile4, writeFile as writeFile2, mkdir } from "fs/promises";
+import { dirname as dirname2 } from "path";
+
+// src/tracking/project-detect/detect.ts
+import { readFile as readFile2, readdir as readdir2, stat } from "fs/promises";
+import { join as join3 } from "path";
+async function exists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJson(p) {
+  try {
+    return JSON.parse(await readFile2(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function classifyDir(cwd) {
+  if (await exists(join3(cwd, "project.config.json"))) {
+    const cfg = await readJson(join3(cwd, "project.config.json"));
+    if (cfg && "miniprogramRoot" in cfg) return "mini-program";
+  }
+  if (await exists(join3(cwd, "ProjectSettings/ProjectVersion.txt"))) return "unity";
+  if (await exists(join3(cwd, "Podfile"))) return "ios";
+  if (await exists(join3(cwd, "build.gradle")) || await exists(join3(cwd, "settings.gradle"))) return "android";
+  const pkg2 = await readJson(join3(cwd, "package.json"));
+  if (pkg2) {
+    const deps = { ...pkg2.dependencies ?? {}, ...pkg2.devDependencies ?? {} };
+    if (deps.astro) return "web-astro";
+    if (deps.next) return "web-nextjs";
+    if (deps.react) return "web-react";
+    if (deps.vue) return "web-vue";
+    if (deps.express || deps.fastify || deps.koa) return "node-server";
+    return "web-vanilla";
+  }
+  if (await exists(join3(cwd, "go.mod"))) return "go-server";
+  if (await exists(join3(cwd, "pom.xml"))) return "java-server";
+  if (await exists(join3(cwd, "pyproject.toml")) || await exists(join3(cwd, "requirements.txt"))) return "python-server";
+  return "unknown";
+}
+async function classify(cwd) {
+  const direct = await classifyDir(cwd);
+  if (direct !== "unknown") return { appType: direct, subPath: void 0 };
+  let entries;
+  try {
+    entries = await readdir2(cwd, { withFileTypes: true });
+  } catch {
+    return { appType: "unknown", subPath: void 0 };
+  }
+  const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").slice(0, 20);
+  let vanillaMatch;
+  for (const d of dirs) {
+    const sub = await classifyDir(join3(cwd, d.name));
+    if (sub !== "unknown" && sub !== "web-vanilla") {
+      return { appType: sub, subPath: d.name };
+    }
+    if (sub === "web-vanilla" && !vanillaMatch) {
+      vanillaMatch = { appType: sub, subPath: d.name };
+    }
+  }
+  if (vanillaMatch) return vanillaMatch;
+  return { appType: "unknown", subPath: void 0 };
+}
+function recommend(appType) {
+  switch (appType) {
+    case "web-react":
+    case "web-vue":
+    case "web-nextjs":
+    case "web-vanilla":
+    case "web-astro":
+    case "ios":
+    case "android":
+    case "mini-program":
+    case "unity":
+      return ["A", "F"];
+    case "node-server":
+    case "python-server":
+    case "go-server":
+    case "java-server":
+      return ["E", "F"];
+    case "unknown":
+    default:
+      return ["B", "E"];
+  }
+}
+async function detectProject(cwd) {
+  const { appType, subPath } = await classify(cwd);
+  return {
+    appType,
+    subPath,
+    entryFiles: [],
+    existingTracking: [],
+    recommendedModes: recommend(appType)
+  };
+}
+
+// src/tracking/xlsx/read.ts
+import XLSXMod from "xlsx";
+import path4 from "path";
+var XLSX = XLSXMod.default ?? XLSXMod;
+var VALID_PROP_TYPES2 = /* @__PURE__ */ new Set(["string", "number", "bool", "datetime", "object", "array_row", "array_string"]);
+var VALID_UPDATE_TYPES2 = /* @__PURE__ */ new Set(["user_set", "user_setOnce", "user_add"]);
+function normalizeHeader(h) {
+  return h.trim().replace(/[（(]\s*(?:必填|必須|필수|required|Required)\s*[）)]/g, "").trim().replace(/名称$/g, "\u540D");
+}
+function buildHeaderMap(headerRow) {
+  const map = /* @__PURE__ */ new Map();
+  headerRow.forEach((cell, i) => {
+    if (cell === null || cell === void 0) return;
+    const norm = normalizeHeader(String(cell));
+    if (norm !== "") {
+      map.set(norm, i);
+    }
+  });
+  return map;
+}
+function colIdx(headerMap, ...candidates) {
+  for (const c of candidates) {
+    const norm = normalizeHeader(c);
+    if (headerMap.has(norm)) return headerMap.get(norm);
+  }
+  return -1;
+}
+function cellStr(row, idx) {
+  if (idx < 0 || idx >= row.length) return "";
+  const v = row[idx];
+  if (v === null || v === void 0) return "";
+  return String(v).trim();
+}
+function parsePropType(raw, propName, sheetCtx) {
+  const canonical = displayToType(raw);
+  if (canonical) return canonical;
+  if (VALID_PROP_TYPES2.has(raw)) return raw;
+  process.stderr.write(
+    `[read] unknown type "${raw}" on ${sheetCtx}:${propName}, defaulting to string
+`
+  );
+  return "string";
+}
+function parseUpdateType(raw, propName) {
+  if (VALID_UPDATE_TYPES2.has(raw)) return raw;
+  process.stderr.write(
+    `[xlsx/read] Warning: unknown update_type "${raw}" for user property "${propName}", falling back to "user_set"
+`
+  );
+  return "user_set";
+}
+function shouldSkipRow(row, firstColIdx) {
+  const first = cellStr(row, firstColIdx);
+  if (!first) return true;
+  if (!/^[a-zA-Z#][a-zA-Z0-9_.]*$/.test(first)) return true;
+  return false;
+}
+function parseEventSheet(rows, source, sheetName2) {
+  const eventsMap = /* @__PURE__ */ new Map();
+  const propsMap = /* @__PURE__ */ new Map();
+  const eventsOrder = [];
+  if (rows.length < 2) return { events: [], event_properties: [] };
+  const headerRow = rows[0];
+  const hMap = buildHeaderMap(headerRow);
+  let eventNameCol = colIdx(hMap, ...allHeaderNames("event_name"), "\u4E8B\u4EF6\u540D\u79F0");
+  let eventDisplayCol = colIdx(hMap, ...allHeaderNames("event_display_name"));
+  let eventDescCol = colIdx(hMap, ...allHeaderNames("event_desc"));
+  let eventTagCol = colIdx(hMap, ...allHeaderNames("event_tag"));
+  let eventPlatformCol = colIdx(hMap, ...allHeaderNames("platform"));
+  let propNameCol = colIdx(hMap, ...allHeaderNames("prop_name"), "\u5C5E\u6027\u540D\u79F0");
+  let propDisplayCol = colIdx(hMap, ...allHeaderNames("prop_display_name"));
+  let propTypeCol = colIdx(hMap, ...allHeaderNames("prop_type"));
+  let propDescCol = colIdx(hMap, ...allHeaderNames("prop_desc"));
+  if (eventNameCol === -1 && eventDisplayCol !== -1) {
+    const candidateCol = eventDisplayCol - 1;
+    if (candidateCol >= 0) {
+      const candidateHeader = headerRow[candidateCol];
+      if (candidateHeader === null || candidateHeader === "" || candidateHeader === void 0) {
+        eventNameCol = candidateCol;
+      }
+    }
+  }
+  if (eventNameCol === -1) {
+    eventNameCol = hMap.has(normalizeHeader("\u4E8B\u4EF6\u6A21\u5757")) ? 1 : 0;
+  }
+  if (propNameCol === -1 && propDisplayCol !== -1) {
+    const candidateCol = propDisplayCol - 1;
+    if (candidateCol >= 0) {
+      const candidateHeader = headerRow[candidateCol];
+      if (candidateHeader === null || candidateHeader === "" || candidateHeader === void 0) {
+        propNameCol = candidateCol;
+      }
+    }
+  }
+  if (propTypeCol === -1 && propDisplayCol !== -1 && propDescCol !== -1) {
+    const candidateCol = propDescCol - 1;
+    if (candidateCol > propDisplayCol) {
+      const candidateHeader = headerRow[candidateCol];
+      if (candidateHeader === null || candidateHeader === "" || candidateHeader === void 0) {
+        propTypeCol = candidateCol;
+      }
+    }
+  }
+  if (propNameCol === -1) {
+    propNameCol = hMap.has(normalizeHeader("\u4E8B\u4EF6\u6A21\u5757")) ? 4 : 4;
+  }
+  if (propTypeCol === -1) {
+    propTypeCol = hMap.has(normalizeHeader("\u4E8B\u4EF6\u6A21\u5757")) ? 6 : 6;
+  }
+  const isIdent = (s) => /^[a-zA-Z#][a-zA-Z0-9_.]*$/.test(s);
+  let lastEventName = "";
+  for (let i = 1; i < rows.length; i++) {
+    let parsePlatform2 = function(raw) {
+      if (!raw) return void 0;
+      const normalized = raw.trim().toLowerCase();
+      if (normalized === "client" || normalized === "server" || normalized === "both") {
+        return normalized;
+      }
+      if (normalized.includes("client") && normalized.includes("server")) return "both";
+      if (normalized.includes("\u5BA2\u6237\u7AEF") && normalized.includes("\u670D\u52A1\u7AEF")) return "both";
+      if (normalized.includes("\u670D\u52A1\u7AEF")) return "server";
+      if (normalized.includes("\u5BA2\u6237\u7AEF")) return "client";
+      return void 0;
+    };
+    var parsePlatform = parsePlatform2;
+    const row = rows[i];
+    const rawEventName = cellStr(row, eventNameCol);
+    const propName = propNameCol >= 0 ? cellStr(row, propNameCol) : "";
+    if (!rawEventName && !propName) continue;
+    if (rawEventName && !isIdent(rawEventName)) continue;
+    const eventName = rawEventName || lastEventName;
+    if (!eventName) continue;
+    const eventDisplayName = rawEventName && eventDisplayCol >= 0 ? cellStr(row, eventDisplayCol) : "";
+    const eventDesc = rawEventName && eventDescCol >= 0 ? cellStr(row, eventDescCol) : "";
+    const eventTag = rawEventName && eventTagCol >= 0 ? cellStr(row, eventTagCol) : "";
+    const eventPlatformRaw = rawEventName && eventPlatformCol >= 0 ? cellStr(row, eventPlatformCol) : "";
+    const propDisplayName = propDisplayCol >= 0 ? cellStr(row, propDisplayCol) : "";
+    const propTypeRaw = propTypeCol >= 0 ? cellStr(row, propTypeCol) : "";
+    const propDesc = propDescCol >= 0 ? cellStr(row, propDescCol) : "";
+    if (rawEventName) lastEventName = rawEventName;
+    if (!eventsMap.has(eventName)) {
+      const evt = {
+        event_name: eventName,
+        source,
+        prop_names: []
+      };
+      if (eventDisplayName) evt.display_name = eventDisplayName;
+      if (eventDesc) evt.event_desc = eventDesc;
+      if (eventTag) evt.event_tag = eventTag;
+      if (eventPlatformRaw) evt.platform = parsePlatform2(eventPlatformRaw);
+      eventsMap.set(eventName, evt);
+      eventsOrder.push(eventName);
+    }
+    if (propName && /^[a-zA-Z#][a-zA-Z0-9_.]*$/.test(propName)) {
+      const evt = eventsMap.get(eventName);
+      if (!evt.prop_names.includes(propName)) {
+        evt.prop_names.push(propName);
+      }
+      if (!propsMap.has(propName)) {
+        const propType = parsePropType(propTypeRaw, propName, sheetName2);
+        const prop = {
+          name: propName,
+          type: propType,
+          source
+        };
+        if (propDisplayName) prop.display_name = propDisplayName;
+        if (propDesc) prop.desc = propDesc;
+        propsMap.set(propName, prop);
+      } else {
+        const existing = propsMap.get(propName);
+        const newType = parsePropType(propTypeRaw, propName, sheetName2);
+        if (propTypeRaw && existing.type !== newType) {
+          process.stderr.write(
+            `[xlsx/read] Warning: property "${propName}" has conflicting types: "${existing.type}" vs "${newType}". Keeping first.
+`
+          );
+        }
+      }
+    }
+  }
+  const events = eventsOrder.map((name) => eventsMap.get(name));
+  const event_properties = Array.from(propsMap.values());
+  return { events, event_properties };
+}
+function parseCommonEventSheet(rows, source, sheetName2) {
+  const props = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (rows.length < 2) return props;
+  const headerRow = rows[0];
+  const hMap = buildHeaderMap(headerRow);
+  let propNameCol = colIdx(hMap, ...allHeaderNames("common_prop_name"), "\u5C5E\u6027\u540D\u79F0");
+  const propDisplayCol = colIdx(hMap, ...allHeaderNames("common_prop_display_name"));
+  let propTypeCol = colIdx(hMap, ...allHeaderNames("common_prop_type"));
+  const propDescCol = colIdx(hMap, ...allHeaderNames("common_prop_desc"));
+  if (propNameCol === -1 && propDisplayCol !== -1) {
+    const candidateCol = propDisplayCol - 1;
+    if (candidateCol >= 0) {
+      const h = headerRow[candidateCol];
+      if (h === null || h === "" || h === void 0) propNameCol = candidateCol;
+    }
+  }
+  if (propNameCol === -1) propNameCol = 0;
+  if (propTypeCol === -1 && propDisplayCol !== -1 && propDescCol !== -1) {
+    const candidateCol = propDescCol - 1;
+    if (candidateCol > propDisplayCol) {
+      const h = headerRow[candidateCol];
+      if (h === null || h === "" || h === void 0) propTypeCol = candidateCol;
+    }
+  }
+  if (propTypeCol === -1 && propDisplayCol !== -1) {
+    const candidateCol = propDisplayCol + 1;
+    if (candidateCol < headerRow.length) {
+      const h = headerRow[candidateCol];
+      if (h === null || h === "" || h === void 0) propTypeCol = candidateCol;
+    }
+  }
+  if (propTypeCol === -1) propTypeCol = 2;
+  for (let i = 1; i < rows.length; i++) {
+    const row = rows[i];
+    if (shouldSkipRow(row, propNameCol)) continue;
+    const name = cellStr(row, propNameCol);
+    const displayName = propDisplayCol >= 0 ? cellStr(row, propDisplayCol) : "";
+    const typeRaw = cellStr(row, propTypeCol);
+    const desc = propDescCol >= 0 ? cellStr(row, propDescCol) : "";
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const prop = {
+      name,
+      type: parsePropType(typeRaw, name, sheetName2),
+      source
+    };
+    if (displayName) prop.display_name = displayName;
+    if (desc) prop.desc = desc;
+    props.push(prop);
+  }
+  return props;
+}
+function parseUserDataSheet(rows, source, sheetName2) {
+  const props = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (rows.length < 2) return props;
+  const headerRow = rows[0];
+  const hMap = buildHeaderMap(headerRow);
+  let propNameCol = colIdx(hMap, ...allHeaderNames("user_prop_name"), "\u5C5E\u6027\u540D\u79F0");
+  const propDisplayCol = colIdx(hMap, ...allHeaderNames("user_prop_display_name"));
+  let propTypeCol = colIdx(hMap, ...allHeaderNames("user_prop_type"));
+  const updateTypeCol = colIdx(hMap, ...allHeaderNames("update_type"));
+  const propDescCol = colIdx(hMap, ...allHeaderNames("user_prop_desc"));
+  const propTagCol = colIdx(hMap, ...allHeaderNames("prop_tag"));
+  if (propNameCol === -1 && propDisplayCol !== -1) {
+    const candidateCol = propDisplayCol - 1;
+    if (candidateCol >= 0) {
+      const h = headerRow[candidateCol];
+      if (h === null || h === "" || h === void 0) propNameCol = candidateCol;
+    }
+  }
+  if (propNameCol === -1) propNameCol = 0;
+  if (propTypeCol === -1 && propDisplayCol !== -1 && updateTypeCol !== -1) {
+    const candidateCol = updateTypeCol - 1;
+    if (candidateCol > propDisplayCol) {
+      const h = headerRow[candidateCol];
+      if (h === null || h === "" || h === void 0) propTypeCol = candidateCol;
+    }
+  }
+  if (propTypeCol === -1) propTypeCol = 2;
+  for (let i = 1; i < rows.length; i++) {
+    const row = rows[i];
+    if (shouldSkipRow(row, propNameCol)) continue;
+    const name = cellStr(row, propNameCol);
+    const displayName = propDisplayCol >= 0 ? cellStr(row, propDisplayCol) : "";
+    const typeRaw = cellStr(row, propTypeCol);
+    const updateTypeRaw = updateTypeCol >= 0 ? cellStr(row, updateTypeCol) : "";
+    const desc = propDescCol >= 0 ? cellStr(row, propDescCol) : "";
+    const propTag = propTagCol >= 0 ? cellStr(row, propTagCol) : "";
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const prop = {
+      name,
+      type: parsePropType(typeRaw, name, sheetName2),
+      update_type: parseUpdateType(updateTypeRaw, name),
+      source
+    };
+    if (displayName) prop.display_name = displayName;
+    if (desc) prop.desc = desc;
+    if (propTag) prop.prop_tag = propTag;
+    props.push(prop);
+  }
+  return props;
+}
+async function readTemplateXlsx(filePath) {
+  let wb;
+  try {
+    wb = XLSX.readFile(filePath);
+  } catch (err) {
+    throw new Error(t("error.xlsx_read_failed", { path: filePath, error: String(err) }));
+  }
+  const planName = path4.basename(filePath, path4.extname(filePath));
+  const source = "template";
+  let events = [];
+  let event_properties = [];
+  let common_event_properties = [];
+  let user_properties = [];
+  for (const sName of wb.SheetNames) {
+    if (!sName.startsWith("#")) continue;
+    if (allSheetNames("user_id").includes(sName)) continue;
+    const ws = wb.Sheets[sName];
+    const rows = XLSX.utils.sheet_to_json(ws, {
+      header: 1,
+      raw: false,
+      defval: null
+    });
+    if (allSheetNames("event_data").includes(sName)) {
+      const result = parseEventSheet(rows, source, sName);
+      events = result.events;
+      event_properties = result.event_properties;
+    } else if (allSheetNames("common_props").includes(sName)) {
+      common_event_properties = parseCommonEventSheet(rows, source, sName);
+    } else if (allSheetNames("user_data").includes(sName)) {
+      user_properties = parseUserDataSheet(rows, source, sName);
+    }
+  }
+  return {
+    meta: {
+      app_type: "",
+      sdk_integration_mode: "client_only",
+      plan_name: planName
+    },
+    events,
+    event_properties,
+    common_event_properties,
+    user_properties
+  };
+}
+
+// src/tracking/xlsx/md.ts
+import { readFile as readFile3 } from "fs/promises";
+var MD_SECTIONS = {
+  event_data: allSheetNames("event_data").map((s) => s.replace(/^#/, "")),
+  common_props: allSheetNames("common_props").map((s) => s.replace(/^#/, "")),
+  user_data: allSheetNames("user_data").map((s) => s.replace(/^#/, ""))
+};
+var MD_COL_EVENT_NAME = ["\u4E8B\u4EF6\u540D", "Event Name", "\u30A4\u30D9\u30F3\u30C8\u540D", "\uC774\uBCA4\uD2B8 \uC774\uB984"];
+var MD_COL_DISPLAY_NAME = ["\u663E\u793A\u540D", "Display Name", "\u8868\u793A\u540D", "\uD45C\uC2DC \uC774\uB984", "\u30A4\u30D9\u30F3\u30C8\u8868\u793A\u540D", "\uC774\uBCA4\uD2B8 \uD45C\uC2DC \uC774\uB984"];
+var MD_COL_DESC = ["\u8BF4\u660E", "Description", "\u8AAC\u660E", "\uC124\uBA85", "\u30A4\u30D9\u30F3\u30C8\u8AAC\u660E", "\uC774\uBCA4\uD2B8 \uC124\uBA85"];
+var MD_COL_TAG = ["\u6807\u7B7E", "Tag", "\u30BF\u30B0", "\uD0DC\uADF8", "\u30AB\u30C6\u30B4\u30EA", "\u30A4\u30D9\u30F3\u30C8 \uD0DC\uADF8"];
+var MD_COL_PLATFORM = ["\u5E73\u53F0", "Platform", "\u30D7\u30E9\u30C3\u30C8\u30D5\u30A9\u30FC\u30E0", "\uD50C\uB7AB\uD3FC"];
+var MD_COL_PROP_NAME = ["\u5C5E\u6027\u540D", "Property Name", "\u30D7\u30ED\u30D1\u30C6\u30A3\u540D", "\uC18D\uC131 \uC774\uB984"];
+var MD_COL_PROP = ["\u5C5E\u6027", "Properties", "\u30D7\u30ED\u30D1\u30C6\u30A3", "\uC18D\uC131"];
+var MD_COL_TYPE = ["\u7C7B\u578B", "Type", "\u30BF\u30A4\u30D7", "\uC720\uD615", "\u30D7\u30ED\u30D1\u30C6\u30A3\u30BF\u30A4\u30D7", "\uC18D\uC131 \uC720\uD615"];
+var MD_COL_UPDATE = ["\u66F4\u65B0\u65B9\u5F0F", "Update Type", "\u66F4\u65B0\u65B9\u6CD5", "\uC5C5\uB370\uC774\uD2B8 \uBC29\uC2DD"];
+function matchSection(trimmed, candidates) {
+  for (const c of candidates) {
+    if (trimmed === `## ${c}`) return true;
+  }
+  return false;
+}
+function findCol(colIndex, candidates, fallback) {
+  for (const c of candidates) {
+    if (colIndex[c] !== void 0) return colIndex[c];
+  }
+  return fallback;
+}
+var VALID_UPDATE_TYPES3 = /* @__PURE__ */ new Set(["user_set", "user_setOnce", "user_add"]);
+function parseType(raw) {
+  const canonical = displayToType(raw);
+  if (canonical) return canonical;
+  return "string";
+}
+function parseUpdateType2(raw) {
+  if (VALID_UPDATE_TYPES3.has(raw)) return raw;
+  return "user_set";
+}
+function trimCell(s) {
+  if (!s) return "";
+  return s.trim();
+}
+function parseEventSection(lines) {
+  const dataLines = [];
+  let inSection = false;
+  let headerCols = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (matchSection(trimmed, MD_SECTIONS.event_data)) {
+      inSection = true;
+      continue;
+    }
+    if (trimmed.startsWith("## ") && inSection) break;
+    if (!inSection) continue;
+    if (trimmed.startsWith("|") && !trimmed.match(/^\|\s*---/)) {
+      const cells = trimmed.split("|").slice(1, -1).map((c) => c.trim());
+      if (headerCols === 0) headerCols = cells.length;
+      dataLines.push(cells);
+    }
+  }
+  if (dataLines.length < 2) return { events: [], event_properties: [] };
+  const header = dataLines[0];
+  const colIndex = {};
+  header.forEach((h, i) => {
+    if (h) colIndex[h] = i;
+  });
+  const eventNameCol = findCol(colIndex, MD_COL_EVENT_NAME, 0);
+  const displayCol = findCol(colIndex, MD_COL_DISPLAY_NAME, 1);
+  const descCol = findCol(colIndex, MD_COL_DESC, 2);
+  const tagCol = findCol(colIndex, MD_COL_TAG, 3);
+  const platformCol = findCol(colIndex, MD_COL_PLATFORM, 4);
+  const propsCol = findCol(colIndex, MD_COL_PROP, 5);
+  const eventsMap = /* @__PURE__ */ new Map();
+  const propsMap = /* @__PURE__ */ new Map();
+  const source = "template";
+  for (let i = 2; i < dataLines.length; i++) {
+    const cells = dataLines[i];
+    if (cells.length < headerCols) continue;
+    const eventName = trimCell(cells[eventNameCol]);
+    if (!eventName) continue;
+    const isIdent = (s) => /^[a-zA-Z#][a-zA-Z0-9_.]*$/.test(s);
+    if (!isIdent(eventName)) continue;
+    const displayName = trimCell(cells[displayCol]);
+    const eventDesc = trimCell(cells[descCol]);
+    const eventTag = trimCell(cells[tagCol]);
+    const platformRaw = trimCell(cells[platformCol]);
+    const propNamesRaw = trimCell(cells[propsCol]);
+    const evt = {
+      event_name: eventName,
+      source,
+      prop_names: []
+    };
+    if (displayName) evt.display_name = displayName;
+    if (eventDesc) evt.event_desc = eventDesc;
+    if (eventTag) evt.event_tag = eventTag;
+    if (platformRaw) {
+      const normalized = platformRaw.toLowerCase();
+      if (normalized === "client" || normalized === "server" || normalized === "both") {
+        evt.platform = normalized;
+      } else if (normalized.includes("client") && normalized.includes("server")) {
+        evt.platform = "both";
+      }
+    }
+    const propNames = propNamesRaw ? propNamesRaw.split(",").map((p) => p.trim()).filter((p) => isIdent(p)) : [];
+    evt.prop_names = propNames;
+    eventsMap.set(eventName, evt);
+    for (const propName of propNames) {
+      if (!propsMap.has(propName)) {
+        propsMap.set(propName, { name: propName, type: "string", source });
+      }
+    }
+  }
+  return {
+    events: Array.from(eventsMap.values()),
+    event_properties: Array.from(propsMap.values())
+  };
+}
+function parseCommonSection(lines, source) {
+  const dataLines = [];
+  let inSection = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (matchSection(trimmed, MD_SECTIONS.common_props)) {
+      inSection = true;
+      continue;
+    }
+    if (trimmed.startsWith("## ") && inSection) break;
+    if (!inSection) continue;
+    if (trimmed.startsWith("|") && !trimmed.match(/^\|\s*---/)) {
+      const cells = trimmed.split("|").slice(1, -1).map((c) => c.trim());
+      dataLines.push(cells);
+    }
+  }
+  if (dataLines.length < 2) return [];
+  const header = dataLines[0];
+  const colIndex = {};
+  header.forEach((h, i) => {
+    if (h) colIndex[h] = i;
+  });
+  const nameCol = findCol(colIndex, MD_COL_PROP_NAME, 0);
+  const displayCol = findCol(colIndex, MD_COL_DISPLAY_NAME, 1);
+  const typeCol = findCol(colIndex, MD_COL_TYPE, 2);
+  const descCol = findCol(colIndex, MD_COL_DESC, 3);
+  const props = [];
+  for (let i = 2; i < dataLines.length; i++) {
+    const cells = dataLines[i];
+    const name = trimCell(cells[nameCol]);
+    if (!name || !/^[a-zA-Z#][a-zA-Z0-9_.]*$/.test(name)) continue;
+    props.push({
+      name,
+      type: parseType(trimCell(cells[typeCol])),
+      source,
+      display_name: trimCell(cells[displayCol]) || void 0,
+      desc: trimCell(cells[descCol]) || void 0
+    });
+  }
+  return props;
+}
+function parseUserSection(lines, source) {
+  const dataLines = [];
+  let inSection = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (matchSection(trimmed, MD_SECTIONS.user_data)) {
+      inSection = true;
+      continue;
+    }
+    if (trimmed.startsWith("#") && inSection) break;
+    if (!inSection) continue;
+    if (trimmed.startsWith("|") && !trimmed.match(/^\|\s*---/)) {
+      const cells = trimmed.split("|").slice(1, -1).map((c) => c.trim());
+      dataLines.push(cells);
+    }
+  }
+  if (dataLines.length < 2) return [];
+  const header = dataLines[0];
+  const colIndex = {};
+  header.forEach((h, i) => {
+    if (h) colIndex[h] = i;
+  });
+  const nameCol = findCol(colIndex, MD_COL_PROP_NAME, 0);
+  const displayCol = findCol(colIndex, MD_COL_DISPLAY_NAME, 1);
+  const typeCol = findCol(colIndex, MD_COL_TYPE, 2);
+  const updateCol = findCol(colIndex, MD_COL_UPDATE, 3);
+  const descCol = findCol(colIndex, MD_COL_DESC, 4);
+  const tagCol = findCol(colIndex, MD_COL_TAG, 5);
+  const props = [];
+  for (let i = 2; i < dataLines.length; i++) {
+    const cells = dataLines[i];
+    const name = trimCell(cells[nameCol]);
+    if (!name || !/^[a-zA-Z#][a-zA-Z0-9_.]*$/.test(name)) continue;
+    const prop = {
+      name,
+      type: parseType(trimCell(cells[typeCol])),
+      update_type: parseUpdateType2(trimCell(cells[updateCol])),
+      source
+    };
+    const displayName = trimCell(cells[displayCol]);
+    if (displayName) prop.display_name = displayName;
+    const desc = trimCell(cells[descCol]);
+    if (desc) prop.desc = desc;
+    const tag = trimCell(cells[tagCol]);
+    if (tag) prop.prop_tag = tag;
+    props.push(prop);
+  }
+  return props;
+}
+async function readTemplateMd(filePath) {
+  const content = await readFile3(filePath, "utf8");
+  const lines = content.split("\n");
+  const source = "template";
+  let planName = "";
+  for (const line of lines) {
+    const m = line.match(/^#\s+(.+)$/);
+    if (m) {
+      planName = m[1].trim();
+      break;
+    }
+  }
+  const { events, event_properties } = parseEventSection(lines);
+  const common_event_properties = parseCommonSection(lines, source);
+  const user_properties = parseUserSection(lines, source);
+  return {
+    meta: {
+      plan_name: planName,
+      app_type: "",
+      sdk_integration_mode: "client_only"
+    },
+    events,
+    event_properties,
+    common_event_properties,
+    user_properties
+  };
+}
+
+// src/commands/tracking/code.ts
+function inferSdkMode(events) {
+  const hasPlatform = events.some((e) => e.platform !== void 0);
+  if (!hasPlatform) return void 0;
+  const platforms = new Set(events.map((e) => e.platform ?? "client"));
+  if (platforms.has("both")) return "both";
+  if (platforms.has("client") && platforms.has("server")) return "both";
+  if (platforms.has("server")) return "server_only";
+  return "client_only";
+}
+function registerCode(cmd) {
+  cmd.description("tooling for ae-generate-tracking-code skill");
+  const importTemplateCmd = cmd.command("import-template").description("Import a template file (md or xlsx) to draft.json, inferring sdk_integration_mode from events").requiredOption("--template <path>", "Path to template file (.md or .xlsx)").requiredOption("--out <path>", "Output path for draft.json").option("--sdk-type <type>", "Client SDK type (android/ios/openharmony/javascript/etc.)").option("--languages <langs>", "Client languages comma-separated (e.g., java,kotlin for android)").option("--server <lang>", "Server language (java/python/go/etc.)").action(async (opts) => {
+    assertInputFilePath(opts.template, "--template");
+    assertOutputFilePath(opts.out, "--out");
+    const draft = opts.template.endsWith(".md") ? await readTemplateMd(opts.template) : await readTemplateXlsx(opts.template);
+    const inferredMode = inferSdkMode(draft.events);
+    if (inferredMode) {
+      draft.meta.sdk_integration_mode = inferredMode;
+      process.stdout.write(t("code.inferred_sdk_mode", { mode: draft.meta.sdk_integration_mode }) + "\n");
+    } else {
+      process.stdout.write(t("code.default_sdk_mode", { mode: draft.meta.sdk_integration_mode }) + "\n");
+    }
+    if (opts.sdkType) {
+      draft.meta.client_sdk_type = opts.sdkType;
+      draft.meta.client_platforms = [opts.sdkType];
+    }
+    if (opts.languages) {
+      const langs = opts.languages.split(",");
+      draft.meta.client_languages = langs;
+      if (draft.meta.client_platforms?.[0]) {
+        const platform = draft.meta.client_platforms[0];
+        const langMap = {};
+        langMap[platform] = langs;
+        draft.meta.client_platform_languages = langMap;
+      }
+    }
+    if (opts.server) {
+      draft.meta.server_language = opts.server;
+    }
+    await mkdir(dirname2(opts.out), { recursive: true });
+    await writeFile2(opts.out, JSON.stringify(draft, null, 2), "utf8");
+    process.stdout.write(t("code.wrote_events", { count: draft.events.length, path: opts.out }) + "\n");
+  });
+  const dryrunCmd = cmd.command("dryrun").description("Preview SDK integration layout from draft.json (skill helper; hidden)").requiredOption("--plan <path>", "Draft JSON (from plan fetch)").option("--cwd <path>", "target project dir", process.cwd()).action(async (opts) => {
+    assertInputFilePath(opts.plan, "--plan");
+    const draft = JSON.parse(await readFile4(opts.plan, "utf8"));
+    const detect = await detectProject(opts.cwd);
+    const tagged = /* @__PURE__ */ new Map();
+    for (const ev of draft.events) {
+      const tag = ev.event_tag ?? "uncategorized";
+      if (!tagged.has(tag)) tagged.set(tag, []);
+      tagged.get(tag).push(ev.event_name);
+    }
+    const out = {
+      detect,
+      sdkInit: { candidateFiles: detect.entryFiles, placed: false },
+      commonProperties: draft.common_event_properties.map((p) => p.name),
+      userProperties: draft.user_properties.map((p) => ({ name: p.name, update_type: p.update_type })),
+      eventGroups: [...tagged.entries()].map(([tag, events]) => ({ tag, events }))
+    };
+    process.stdout.write(JSON.stringify(out, null, 2) + "\n");
+  });
+  const detectCmd = cmd.command("detect").description("detect project type and recommended SDK integration modes").option("--cwd <path>", "project directory", process.cwd()).action(async (opts) => {
+    const result = await detectProject(opts.cwd);
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  });
+  importTemplateCmd._hidden = true;
+  dryrunCmd._hidden = true;
+  detectCmd._hidden = true;
+}
+
+// src/tracking/wiki-query/query.ts
+import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
+var WIKI_ROOT = join4(getPackageRoot(), "wiki/te-docs");
+function searchIndex(keyword) {
+  const indexPath = join4(WIKI_ROOT, "index.md");
+  if (!existsSync5(indexPath)) return [];
+  const lines = readFileSync3(indexPath, "utf8").split("\n");
+  const kw = keyword.toLowerCase();
+  const hits = [];
+  for (const line of lines) {
+    const m = /^\|\s*\[([^\]]+)\]\(([^)]+)\)\s*\|.*\|\s*\[docs\]\(([^)]+)\)\s*\|$/.exec(line);
+    if (!m) continue;
+    const [, name, rawPath, sourceUrl] = m;
+    if (name.toLowerCase().includes(kw) || rawPath.toLowerCase().includes(kw)) {
+      hits.push({ name, rawPath, sourceUrl });
+    }
+  }
+  return hits;
+}
+
+// src/commands/tracking/wiki.ts
+function registerWiki(cmd) {
+  cmd.description("AE docs wiki (bundled)");
+  cmd.command("query").description("Search bundled AE docs wiki index by keyword").requiredOption("--keyword <kw>", "substring to search in index").action((opts) => {
+    const hits = searchIndex(opts.keyword);
+    for (const h of hits) console.log(`${h.name}	${h.rawPath}	${h.sourceUrl}`);
+  });
+  cmd.command("sync").description("Refresh wiki from docs-v2 (developer only; disabled in published package)").action(async () => {
+    console.error(t("wiki.sync_not_supported"));
+    console.error(t("wiki.not_in_published_package"));
+    process.exit(2);
+  });
+}
+
+// src/commands/tracking/lang.ts
+var SUPPORTED = ["zh", "en", "ja", "ko"];
+var SUPPORTED_LABELS = {
+  zh: "\u4E2D\u6587 (Chinese)",
+  en: "English",
+  ja: "\u65E5\u672C\u8A9E (Japanese)",
+  ko: "\uD55C\uAD6D\uC5B4 (Korean)"
+};
+function registerLang(cmd, rootProgram) {
+  cmd.description("manage AE server language for tracking commands");
+  cmd.command("set").description("set the AE server language").argument("<locale>", "language code: zh / en / ja / ko").option("--host <url>", HOST_OPTION_DESC).action(async (locale, opts) => {
+    const normalized = locale.trim().toLowerCase();
+    if (!SUPPORTED.includes(normalized)) {
+      console.error(`Unsupported language: "${locale}"`);
+      console.error("Supported languages:");
+      for (const code of SUPPORTED) {
+        console.error(`  ${code} \u2014 ${SUPPORTED_LABELS[code]}`);
+      }
+      process.exit(1);
+    }
+    const host = resolveTrackingHost(rootProgram, opts);
+    const client = await createTrackingClient(host);
+    const aeCode = cliLocaleToAE(normalized);
+    await client.saveUserAutoConfig(aeCode);
+    process.stderr.write(`[ae-cli] Server language saved: ${aeCode}
+`);
+    const config = await client.getUserAutoConfig();
+    if (config) {
+      const serverLang = config.lang ?? config.umi_locale ?? config.locale;
+      console.log(`Server response: ${JSON.stringify({ lang: serverLang })}`);
+    } else {
+      console.log("Server response: (empty)");
+    }
+  });
+}
+
+// src/commands/tracking/index.ts
+function registerTracking(program2) {
+  const tracking = program2.command("tracking").description("AE tracking plan lifecycle (xlsx, debug, wiki)");
+  registerPlan(tracking.command("plan"), program2);
+  registerCode(tracking.command("code"));
+  registerWiki(tracking.command("wiki"));
+  registerLang(tracking.command("lang"), program2);
+}
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
@@ -385,52 +2882,52 @@ program.name("ae-cli").version(version).description("CLI tool for ThinkingAI (AE
 async function loadCommands() {
   const commands = [];
   try {
-    const teAnalysis = await import("./te-analysis-CB3DA5I5.js");
+    const teAnalysis = await import("./te-analysis-VAR4KUOK.js");
     commands.push(...teAnalysis.default);
   } catch {
   }
   try {
-    const teAudience = await import("./te-audience-W7SCQFC7.js");
+    const teAudience = await import("./te-audience-KMKYI2YJ.js");
     commands.push(...teAudience.default);
   } catch {
   }
   try {
-    const teMeta = await import("./te-meta-PDKLMWXN.js");
+    const teMeta = await import("./te-meta-EPZGQN56.js");
     commands.push(...teMeta.default);
   } catch {
   }
   try {
-    const teCommon = await import("./te-common-FBXVWBSI.js");
+    const teCommon = await import("./te-common-WNCZB7R7.js");
     commands.push(...teCommon.default);
   } catch {
   }
   try {
-    const engage = await import("./te-engage-KARARMIR.js");
+    const engage = await import("./te-engage-4XHCTS6I.js");
     commands.push(...engage.default);
   } catch {
   }
   try {
-    const community = await import("./te-community-LNVDZSGW.js");
+    const community = await import("./te-community-JEEFXPB3.js");
     commands.push(...community.default);
   } catch {
   }
   try {
-    const dataops = await import("./te-dataops-IPCSSWYH.js");
+    const dataops = await import("./te-dataops-GD3XBYCS.js");
     commands.push(...dataops.default);
   } catch {
   }
   try {
-    const teKb = await import("./te-kb-2Z2CARN3.js");
+    const teKb = await import("./te-kb-B62KFP2A.js");
     commands.push(...teKb.default);
   } catch {
   }
   try {
-    const teTeam = await import("./te-team-SW5B7DHO.js");
+    const teTeam = await import("./te-team-YY24VORI.js");
     commands.push(...teTeam.default);
   } catch {
   }
   try {
-    const teAgent = await import("./te-agent-YV4DXEXK.js");
+    const teAgent = await import("./te-agent-KZRIEN4N.js");
     commands.push(...teAgent.default);
   } catch {
   }
@@ -438,35 +2935,35 @@ async function loadCommands() {
 }
 async function registerAuthCommands() {
   try {
-    const { registerAuth } = await import("./auth-H3GJD55A.js");
+    const { registerAuth } = await import("./auth-GHBMJ5ZR.js");
     registerAuth(program);
   } catch {
   }
 }
 async function registerConfigCommands() {
   try {
-    const { registerConfig } = await import("./config-64G36TJL.js");
+    const { registerConfig } = await import("./config-NCUGK6NS.js");
     registerConfig(program);
   } catch {
   }
 }
 async function registerApiCommand() {
   try {
-    const { registerApi } = await import("./raw-WJIWC6YP.js");
+    const { registerApi } = await import("./raw-7NVWSVJP.js");
     registerApi(program);
   } catch {
   }
 }
 async function registerSyncCommand() {
   try {
-    const { registerSync } = await import("./sync-NVASAISS.js");
+    const { registerSync } = await import("./sync-GRVO4K3U.js");
     registerSync(program);
   } catch {
   }
 }
 async function registerModelCommand() {
   try {
-    const { registerModel } = await import("./model-VZCYNIOG.js");
+    const { registerModel } = await import("./model-SJSOZTRS.js");
     registerModel(program);
   } catch {
   }
@@ -480,6 +2977,7 @@ async function main() {
   await registerApiCommand();
   await registerSyncCommand();
   await registerModelCommand();
+  registerTracking(program);
   program.parse();
 }
 main();