tiktok-scripts/tiktok-app/dist/tiktok-app.js

"ui";
/*! tiktok-app v2026.10.13
 *  built 2026-10-28T15:01:13.992Z
 *  modules: theme, store, records, sources, device, service, fingerprint, engine, session, resume, widgets, dialog, floatball, page-id, page-dm, page-video, page-tasks, page-records, page-login, page-mine, main
 *  由 tools/build.js 自动生成 —— 请不要直接编辑本文件，改 src/ 后重新构建。
 */
(function () {

/* ============================== src/theme.js ============================== */
/* ============================== src/theme.js ==============================
 * 设计令牌 + 绘制工具。
 *
 * 所有颜色/尺寸/字号都取自 Ardot 设计稿（file 734917825641912），
 * 页面代码里**不允许出现裸色值或裸尺寸**——要改视觉先改这里。
 *
 * 为什么用「代码建 View」而不是 XML 布局：
 *   ① 设计稿用了渐变、径向光晕、多层描边、按状态换色，XML 属性表达不了，
 *      最后仍要落到代码里 setBackground(GradientDrawable)，反而两套并存；
 *   ② XML 字面量（E4X）不是标准 JS，PC 侧无法用 node 做语法检查与离线自检，
 *      而 AutoX 设备端是没有 linter 的（见规范 SKILL.md「设备端没有门禁」）。
 *      纯代码建 View 让整个产物能在 PC 上被语法检查和桩测。
 */

var Theme = {};

/* ---------------------------------------------------------------- 颜色 */

Theme.hex = {
    bg: "#030014",
    tabBar: "#0A0A17",
    dialogBg: "#17142B",
    accent: "#2EA6FF",
    accentText: "#7CC7FF",
    accentDeep: "#9381FF",
    /* 任务卡图标衬底的紫。设计稿里 UID私信 的图标框是 #9482FF@16%，
     * 与主色渐变里的紫（#9381FF）**不是同一个值** —— 不要"统一"成一个。 */
    violet: "#9482FF",
    textPrimary: "#FFFFFF",
    textSecondary: "#CFCCE6",
    /* 弹窗里的设置名用的是更亮一档的正文色（设计稿 §6：正文 #CFCCE6 / #E6E4F5） */
    textBody: "#E6E4F5",
    textMuted: "#9A97B8",
    textFaint: "#8E8BA8",
    /* 弱提示（区说明 / 「上次运行」/ 底部提示）。比 textFaint 再暗一档，
     * 三级文字层次来自设计稿 §6：次要 #9A97B8·#8E8BA8 / 弱提示 #6F6C8A。 */
    textDim: "#6F6C8A",
    /* 未选中页签的颜色。**不要删**：它一旦缺失，argb(undefined) 会算出 0
     * （全透明），非活动页签会整片消失 —— 而且 uiautomator 里它们的
     * bounds 是正常的，只有肉眼看得出来，极难定位。
     * 取值 2026-10-13 更新为 #8E8BA8：旧的 #7A7794 对比度只有 4.4:1，
     * 未达 WCAG AA（规格书 §9 第 5 条已统一改为新值）。 */
    tabIdle: "#8E8BA8",
    /* 警示色：设计稿里「未开启」状态标签与「确认解绑」按钮用的是两种不同的暖色。
     * warn 偏琥珀（权限告缺、卡密到期），danger 偏红（不可逆操作）。 */
    warn: "#F5C24B",
    danger: "#FF5470",
    ok: "#13DDC4",
    divider: "#FFFFFF"
};

/* 卡片与标签的填充/描边一律是「白色 + 透明度」，不是独立色值。
 * 这样叠在深色背景与叠在渐变光晕上的观感一致。 */
Theme.alpha = {
    cardFill: 0.04,
    cardFillActive: 0.06,
    cardStroke: 0.08,
    cardStrokeActive: 0.35,
    chipFill: 0.06,
    chipStroke: 0.10,
    accentChipFill: 0.20,
    /* 全局运行条：青蓝 12% 填充（设计稿 B2 的 30:304，无描边） */
    runBarFill: 0.12,
    runBarStroke: 0.28,
    /* 警示图标底 / 任务图标框：设计稿里是 14% 的同色衬底 */
    warnFill: 0.14,
    iconBoxFill: 0.14,
    mask: 0.72,
    glowA: 0.30,
    glowB: 0.20
};

/* ---------------------------------------------------------------- 尺寸 */

Theme.m = {
    screenW: 375,
    contentPadding: 20,
    cardPadding: 14,
    cardRadius: 16,
    chipRadius: 8,
    pillRadius: 99,
    dialogRadius: 24,
    gapPage: 16,
    gapCard: 12,
    gapTight: 8,
    gapInline: 10,

    titleSize: 22,
    sectionSize: 16,
    labelSize: 13,
    chipSize: 11,
    hintSize: 11,
    tabSize: 11,

    rowHeight: 26,
    chipPadV: 6,
    chipPadH: 6,
    tabBarHeight: 49,
    tabIconSize: 22,
    runBtnHeight: 48,
    runBtnWidth: 335,
    runBarRadius: 12,
    runBarPadV: 12,
    runBarPadH: 10,
    warnIconSize: 40,
    warnIconRadius: 12,
    loginLogoSize: 72,
    loginLogoRadius: 20,
    loginBtnHeight: 48,
    dialogWidth: 315,
    statusBarHeight: 62,
    safeAreaHeight: 33,
    touchTarget: 44,

    /* ===== 2026-10-13 规格书新增（§6 尺寸与圆角 / 触控标准）===== */

    /* 二级页返回头：高 44，返回热区 44×44，标题 21 SemiBold */
    backHeaderHeight: 44,
    backHotSize: 44,
    backArrowSize: 20,
    detailTitleSize: 21,

    /* 任务卡（B1/B2）：图标框 40 圆角 12 / 图标 22 / 卡名 15 /
     * 运行按钮 68×44（触控标准明确写了 68×44） */
    taskIconBox: 40,
    taskIconSize: 22,
    taskIconRadius: 12,
    taskNameSize: 15,
    taskRunBtnW: 68,
    taskRunBtnH: 44,

    /* 记录条目（D1/D3）：图标框 36 圆角 10 / 图标 20 / 卡片圆角 14 */
    recordIconBox: 36,
    recordIconSize: 20,
    recordIconRadius: 10,
    recordCardRadius: 14,

    /* 状态徽标（空闲/运行中/未配置）与结果标签：全圆角小胶囊 */
    badgePadH: 8,
    badgePadV: 3,

    /* 底栏整体高度 = 页签行 49 + 安全区 33（设计稿 §6） */
    tabBarTotal: 83,

    /* 区间输入框：**单框宽 56、数字居中**（§6）。比早期实现的 64 窄，
     * 是为了让「标签 + 56 ~ 56」一行放得下而不挤。 */
    rangeFieldW: 56,

    /* 内容区底部渐隐：y=577 h=80（§6），右侧滚动指示条 x=367 w=3 */
    fadeHeight: 80,
    indicatorW: 3,

    /* 弹窗按钮：行动按钮 44 / 主按钮 46（A4 的去授权是 46） */
    dialogBtnHeight: 44,
    dialogPrimaryHeight: 46,

    /* 日志行（D3）：等宽 11 / 行距紧凑 */
    logSize: 11
};

/* ---------------------------------------------------------------- 工具 */

/** dp → px。设计稿是 375 逻辑宽，必须换算后再交给原生控件。 */
function dp(value) {
    var density = 1;
    try {
        density = context.getResources().getDisplayMetrics().density;
    } catch (e) {
        /* 离线桩测环境没有 Android context，退化为 1:1，不影响逻辑正确性 */
        density = 1;
    }
    return Math.round(value * density);
}

/**
 * "#2EA6FF" → Java 可用的 ARGB int（负数形式，与 colors.parseColor 同构）。
 *
 * 色值写错时返回**醒目的洋红**而不是 0。0 是全透明：
 * 界面上的表现是「某块东西不见了」，不报错、不留痕 ——
 * tabIdle 掉过一次，整排非活动页签就是这么消失的，
 * 而 uiautomator 里它们的 bounds 一切正常，只有肉眼能发现。
 * 洋红至少让错误在一眼之内就暴露出来。
 */
function argb(hex) {
    var h = String(hex).replace("#", "");
    if (h.length === 6) { h = "FF" + h; }
    var value = parseInt(h, 16);
    if (isNaN(value)) {
        console.log("[theme] 非法色值（已用洋红代替）: " + hex);
        return -65281; /* 0xFFFF00FF */
    }
    return value | 0;
}

/** 给 hex 色叠加不透明度，得到 ARGB int。#FFFFFF + 0.06 → 约 #0FFFFFFF */
function alphaOf(hex, alpha) {
    var h = String(hex).replace("#", "");
    if (h.length === 8) { h = h.substring(2); }
    var a = Math.round(Math.max(0, Math.min(1, alpha)) * 255);
    return parseInt(("0" + a.toString(16)).slice(-2) + h, 16) | 0;
}

/** 纯色圆角背景。 */
function solidBg(colorInt, radiusDp) {
    var drawable = new android.graphics.drawable.GradientDrawable();
    drawable.setShape(android.graphics.drawable.GradientDrawable.RECTANGLE);
    drawable.setColor(colorInt);
    if (radiusDp) { drawable.setCornerRadius(dp(radiusDp)); }
    return drawable;
}

/** 圆角 + 描边（卡片默认形态）。 */
function strokeBg(fillAlpha, strokeAlpha, strokeHex, radiusDp) {
    var drawable = new android.graphics.drawable.GradientDrawable();
    drawable.setShape(android.graphics.drawable.GradientDrawable.RECTANGLE);
    drawable.setColor(alphaOf("#FFFFFF", fillAlpha));
    drawable.setCornerRadius(dp(radiusDp));
    drawable.setStroke(dp(1), alphaOf(strokeHex || "#FFFFFF", strokeAlpha));
    return drawable;
}

/** 线性渐变（主按钮、选中态）。默认左→右，与设计稿一致。 */
function gradientBg(fromHex, toHex, radiusDp) {
    var drawable = new android.graphics.drawable.GradientDrawable();
    drawable.setShape(android.graphics.drawable.GradientDrawable.RECTANGLE);
    drawable.setOrientation(android.graphics.drawable.GradientDrawable.Orientation.LEFT_RIGHT);
    drawable.setColors([argb(fromHex), argb(toHex)]);
    if (radiusDp) { drawable.setCornerRadius(dp(radiusDp)); }
    return drawable;
}

/** 径向光晕：中心有色、边缘透明，用来复刻设计稿背景的两团光。 */
function glowBg(hex, alpha) {
    var drawable = new android.graphics.drawable.GradientDrawable();
    var colors = [alphaOf(hex, alpha), alphaOf(hex, 0)];
    drawable.setShape(android.graphics.drawable.GradientDrawable.OVAL);
    drawable.setGradientType(android.graphics.drawable.GradientDrawable.RADIAL_GRADIENT);
    drawable.setGradientRadius(dp(220));
    drawable.setColors(colors);
    return drawable;
}

/** 页面根背景：底色 + 两团光晕，所有承载体统一从这里取，避免各自拼。 */
function screenBackground() {
    return solidBg(argb(Theme.hex.bg));
}

/**
 * 竖向渐隐（透明 → 色），用在内容区底部（设计稿 §6「底部渐隐 y=577 h=80」）。
 *
 * 为什么要它：内容区是可滚动的，卡片被底栏"硬切"一刀会让人以为列表到头了。
 * 加一层渐隐，滚动的连续性一眼可见。
 * 颜色取**页面底色**：叠在空内容上时它等于背景，不会露出多余的色块。
 */
function fadeBg(hex) {
    var drawable = new android.graphics.drawable.GradientDrawable();
    drawable.setShape(android.graphics.drawable.GradientDrawable.RECTANGLE);
    drawable.setOrientation(android.graphics.drawable.GradientDrawable.Orientation.TOP_BOTTOM);
    drawable.setColors([alphaOf(hex, 0), argb(hex)]);
    return drawable;
}

/** 同色衬底（任务图标框 / 警示图标底）：hex + 透明度，圆角方块。 */
function tintBg(hex, alpha, radiusDp) {
    var drawable = new android.graphics.drawable.GradientDrawable();
    drawable.setShape(android.graphics.drawable.GradientDrawable.RECTANGLE);
    drawable.setColor(alphaOf(hex, alpha));
    if (radiusDp) { drawable.setCornerRadius(dp(radiusDp)); }
    return drawable;
}

/* ------------------------------------------------------------- 基础控件 */

/** 统一的 TextView 工厂，防止每个页面各写一遍字号字色。 */
function text(content, sizeSp, hex, bold) {
    var view = new android.widget.TextView(context);
    view.setText(String(content === null || content === undefined ? "" : content));
    view.setTextSize(sizeSp);
    view.setTextColor(argb(hex));
    if (bold) {
        view.setTypeface(android.graphics.Typeface.DEFAULT_BOLD);
    }
    return view;
}

/**
 * 等宽数字（设计稿里 200 / 30、2026.10.10 用的是 JetBrains Mono）。
 * 与 text() 一样带 undefined 兜底——String(undefined) 会变成界面上的 "undefined"。
 */
function monoText(content, sizeSp, hex) {
    var view = new android.widget.TextView(context);
    view.setText(content === null || content === undefined ? "" : String(content));
    view.setTextSize(sizeSp);
    view.setTextColor(argb(hex));
    view.setTypeface(android.graphics.Typeface.MONOSPACE);
    return view;
}

function box(widthDp, heightDp) {
    var view = new android.view.View(context);
    view.setLayoutParams(new android.widget.LinearLayout.LayoutParams(
        widthDp >= 0 ? dp(widthDp) : widthDp,
        heightDp >= 0 ? dp(heightDp) : heightDp
    ));
    return view;
}

/**
 * 垂直间距。⚠️ 只能用在**竖向** LinearLayout 里。
 *
 * 它的宽度是 MATCH_PARENT，放进横向容器会占满整行剩余空间，
 * 把同行后面那些 weight=1 的 View 挤成 0 宽（真机上表现为「文字全部消失」）。
 * 横向间距请用 hgap()。
 */
function spacer(heightDp) {
    return box(-1, heightDp);
}

/**
 * 横向间距。固定宽度、高度 1px。
 * 与 spacer 的区别只在宽度策略，但用错了就是「文字不见了」这种难查的现象，
 * 所以刻意分成两个名字，让用错的时候在代码上一眼能看出来。
 */
function hgap(widthDp) {
    var view = new android.view.View(context);
    view.setLayoutParams(new android.widget.LinearLayout.LayoutParams(dp(widthDp), 1));
    return view;
}

/** 撑开剩余空间，用于「左标题 / 右控件」两栏布局。 */
function flexible() {
    var view = new android.view.View(context);
    var lp = new android.widget.LinearLayout.LayoutParams(0, 1);
    lp.weight = 1;
    view.setLayoutParams(lp);
    return view;
}

/**
 * 横向行。
 *
 * fill 默认为 true：横向行几乎都是「左标签(weight=1) + 右控件」的结构，
 * **必须显式填满宽度**，否则父容器按 WRAP_CONTENT 测量时，
 * weight=1 的左侧标签会分到 0 宽 —— 真机上表现为「这一行的文字不见了」。
 * 需要包裹内容的场合（例如作为另一行右侧的控件组）显式传 false。
 */
function row(fill) {
    var layout = new android.widget.LinearLayout(context);
    layout.setOrientation(android.widget.LinearLayout.HORIZONTAL);
    layout.setGravity(android.view.Gravity.CENTER_VERTICAL);
    if (fill === undefined || fill) {
        layout.setLayoutParams(new android.widget.LinearLayout.LayoutParams(-1, -2));
    }
    return layout;
}

/** 竖向容器，同样默认填满宽度（卡片、页面主体都属于这类）。 */
function column(fill) {
    var layout = new android.widget.LinearLayout(context);
    layout.setOrientation(android.widget.LinearLayout.VERTICAL);
    if (fill === undefined || fill) {
        layout.setLayoutParams(new android.widget.LinearLayout.LayoutParams(-1, -2));
    }
    return layout;
}

/** 给 LinearLayout 统一挂 LayoutParams，省掉每处的重复样板。 */
function params(view, widthDp, heightDp, weight) {
    var lp = new android.widget.LinearLayout.LayoutParams(
        widthDp >= 0 ? dp(widthDp) : widthDp,
        heightDp >= 0 ? dp(heightDp) : heightDp
    );
    if (weight) { lp.weight = weight; }
    view.setLayoutParams(lp);
    return view;
}

function marginParams(view, widthDp, heightDp, l, t, r, b) {
    var lp = new android.widget.LinearLayout.LayoutParams(
        widthDp >= 0 ? dp(widthDp) : widthDp,
        heightDp >= 0 ? dp(heightDp) : heightDp
    );
    lp.setMargins(dp(l), dp(t), dp(r), dp(b));
    view.setLayoutParams(lp);
    return view;
}

Theme.util = {
    dp: dp,
    argb: argb,
    alphaOf: alphaOf,
    solidBg: solidBg,
    strokeBg: strokeBg,
    gradientBg: gradientBg,
    glowBg: glowBg,
    fadeBg: fadeBg,
    tintBg: tintBg,
    screenBackground: screenBackground,
    text: text,
    monoText: monoText,
    box: box,
    spacer: spacer,
    hgap: hgap,
    flexible: flexible,
    row: row,
    column: column,
    params: params,
    marginParams: marginParams
};

/* 便捷短名：页面代码里 90% 的调用都是这几个，长名前缀会淹掉结构。 */
var U = Theme.util;


/* ============================== src/store.js ============================== */
/* ============================== src/store.js ==============================
 * 数据模型 + 持久化 + 校验。
 *
 * 这一层只做三件事：给默认值、读回来、写出去。**不做界面**，也不碰设备。
 * 页面代码永远通过 Store.get()/Store.set() 拿值，不直接碰 storages。
 *
 * ── 核心设计：默认值只有一个来源 ─────────────────────────────
 * 所有字段都在下面的 Store.FIELDS 里声明一次（路径 / 类型 / 范围 / 默认值），
 * `defaults()` 与 `validate()` 都由它推导。
 *
 * 为什么必须这样：早先的版本里默认值写在 defaults()、校验规则写在 validate()、
 * 范围写在另一张 LIMITS 表里——三处各写一半，结果就是
 * 「LIMITS 遍历时把视频页的 stopCount 也写进了私信页对象，而默认值取的是
 *   私信页不存在的 d.tabs.dm.stopCount」→ 真的往配置里塞了个 undefined。
 * 一张表就没有这种漂移。
 */

var Store = {};

/* v8（2026-10-17）：ID提取页从「四张单选脚本卡」改成**三段式**
 * （① 取材清单 ② 只要这样的账号 ③ 输出）。
 *
 * 四张卡的 23 个字段全部删除，清单改由 `Sources` 模块单独持久化
 * （不定长列表进不了这张标量表）。旧配置由 `Sources.migrateLegacy()`
 * 翻译成清单，用户的选项一个不丢。
 *
 * v7（同日早些时候）是"清语义"那一档：删同义反复的开关、补缺输入的开关、
 * 功能设置分三组。那一档的成果（36 个字段、三组结构、置灰方式）v8 全部继承。
 */
Store.SCHEMA_VERSION = 8;
Store.STORAGE_NAME = "feizhou_app";
Store.STORAGE_KEY = "config";

/** 业务文本文件的约定目录。界面上的「选择文件」默认指向这里。 */
Store.TEXT_DIR = "/sdcard/Download/tiktok_app";

/* ------------------------------------------------ 下拉/开关的候选值集中定义 */

Store.options = {
    dedupe:      ["ID 模式", "UID 模式"],
    enterPage:   ["粉丝页", "评论页", "主页", "关注页"],
    /* 「从哪个页面取」与「展开哪个列表」是**两件事**，v7 之前共用一个 enterPage，
     * 于是 s3（文本裂变）里能选到「评论页」—— 而在"展开文本里这些人的列表"这个语义下，
     * 评论页根本不是合法值。分开之后 s3 只能选粉丝 / 关注。 */
    expandList:  ["粉丝列表", "关注列表"],
    /* 脚本二「视频从哪来」：原来只有一个"自定评论页面提 ID"开关，勾上却没说
     * 从哪条视频开始 —— 补上这个来源维度，那个开关才有意义。 */
    videoSource: ["当前屏幕", "关键词搜索"],
    aiGender:    ["男", "女"],
    toggle:      ["开启", "关闭"],
    dedupeMode:  ["关注+私信去重", "仅关注去重", "仅私信去重"],
    filterDate:  ["7 天内", "30 天内", "不限"],
    firstAction: ["都执行", "仅点赞", "仅评论"],
    langRegion:     ["通杀", "仅中文", "仅英文"],
    nicknameCheck:  ["通杀", "仅检测昵称", "仅检测个签"],
    /* 点赞 / 评论 / 关注概率。设计稿把它们做成固定档位 ——
     * 养号动作的强度直接决定账号安全，给几个安全档位比让用户随手填 90% 更负责。 */
    likeRate:       ["10%", "20%", "30%", "50%"],
    commentRate:    ["5%", "10%", "20%", "30%"],
    followRate:     ["5%", "10%", "15%", "30%"]
};

/* 候选值 ↔ 存储值的双向映射。
 * 界面显示中文，存储里存稳定英文 key——改文案时不会把老数据作废。 */
Store.enum = {
    dedupe:      { "id": "ID 模式", "text": "UID 模式" },
    /* 「关注页」是脚本三要用的（设计稿 16:533 的下拉就是它）。
     * 新增候选一律**追加在末尾**：位置即下拉里的顺序，插在中间会让老用户
     * 下次点开下拉时发现选项换了地方。 */
    enterPage:   { "fans": "粉丝页", "comment": "评论页", "home": "主页", "follow": "关注页" },
    /* v7：只含"能列出一串人的页"。s3 用它，与 enterPage 语义分开。 */
    expandList:  { "fans": "粉丝列表", "follow": "关注列表" },
    videoSource: { "screen": "当前屏幕", "keyword": "关键词搜索" },
    aiGender:    { "male": "男", "female": "女" },
    toggle:      { "on": "开启", "off": "关闭" },
    dedupeMode:  { "follow_dm": "关注+私信去重", "follow": "仅关注去重", "dm": "仅私信去重" },
    filterDate:  { "7d": "7 天内", "30d": "30 天内", "all": "不限" },
    firstAction: { "both": "都执行", "like": "仅点赞", "comment": "仅评论" },
    langRegion:     { "any": "通杀", "zh": "仅中文", "en": "仅英文" },
    nicknameCheck:  { "any": "通杀", "nick": "仅检测昵称", "sign": "仅检测个签" },
    likeRate:       { "r10": "10%", "r20": "20%", "r30": "30%", "r50": "50%" },
    commentRate:    { "r5": "5%", "r10": "10%", "r20": "20%", "r30": "30%" },
    followRate:     { "r5": "5%", "r10": "10%", "r15": "15%", "r30": "30%" },
    licenseStatus: { "none": "未登录", "active": "已登录", "expired": "已过期" },
    /* ★ 2026-10-13 规格书 §1：底栏只剩 **3 个 tab**（任务 / 记录 / 我的）。
     * 原来的 id/dm/nurture/video 四个页签降级为「任务」tab 里的四张任务卡，
     * 各自的详情页 (C1/C6/C8/C9) 变成二级页。v6 迁移负责把老存档的
     * activeTab（例如 "nurture"）映射成 "tasks"，否则老用户启动会落回默认页。 */
    tab:         { "tasks": "任务", "records": "记录", "mine": "我的" }
};

/** 某组枚举的全部 key。 */
function enumKeys(group) {
    var map = Store.enum[group] || {};
    var out = [];
    for (var k in map) {
        if (map.hasOwnProperty(k)) { out.push(k); }
    }
    return out;
}

/**
 * 枚举 key → 显示文案。
 *
 * 关键兜底：key 缺失或非法时**回退到该枚举的第一项**，绝不返回 "undefined"。
 * 选择框显示成空白或 "undefined" 是用户最容易看到、也最说不清的一类 bug，
 * 在数据层一次堵死比在每个页面各写一遍兜底可靠。
 */
Store.label = function (group, key) {
    var map = Store.enum[group];
    if (!map) {
        return key === undefined || key === null ? "" : String(key);
    }
    if (key === undefined || key === null || map[key] === undefined) {
        var first = enumKeys(group)[0];
        return first === undefined ? "" : map[first];
    }
    return map[key];
};

/** 当前值在候选列表里的位置，供下拉框设定初始选中项。 */
Store.indexOfLabel = function (group, key) {
    var list = Store.options[group] || [];
    return Math.max(0, list.indexOf(Store.label(group, key)));
};

/** 依位置取回 key，供下拉框选中后写回。 */
Store.keyAt = function (group, index) {
    var list = Store.options[group] || [];
    var label = list[index];
    var map = Store.enum[group] || {};
    for (var k in map) {
        if (map.hasOwnProperty(k) && map[k] === label) { return k; }
    }
    return label;
};

/* ------------------------------------------------------------ 字段声明表 */

/** 生成「勾选 + 展开」两个字段——所有脚本卡都有这两个开关。 */
function cardFields(basePath, checked, expanded) {
    return [
        { path: basePath + ".checked",  type: "bool", def: !!checked },
        { path: basePath + ".expanded", type: "bool", def: !!expanded }
    ];
}

var F = [];

/* ——— 全局 ——— */
F.push(
    /* values 与 Store.enum.tab 必须一致（曾经少了 "mine"：
     * 切到「我的」后重启会落回 ID提取，因为写入端的归一化认不出这个值）。
     * v6 起是三个 tab：任务 / 记录 / 我的。 */
    { path: "activeTab", type: "enum", values: ["tasks", "records", "mine"], def: "tasks" },
    /* 二级页（任务详情 / 运行详情）也落盘：用户切走再回来，还停在原来那个详情页。
     * 存 key 而不是存 View —— 值域与「任务清单」一一对应，非法值一律回退空串（= 一级页）。 */
    { path: "activeDetail", type: "enum", values: ["", "id", "dm", "nurture", "video"], def: "" },
    { path: "license.code",     type: "text", def: "" },
    /* 登录页输入框里的卡密**草稿**：手打 16 位卡密时被系统回收进程，重开还在。
     * 激活成功后**不清它**：解绑后回到登录页，上次的卡密已经填好，一键即可重新激活
     * （它和 `license.code` 在同一个 JSON 里，多留一份不增加暴露面）。
     * 顺带避开一个坑：清它会被登录页输入框的「切屏前整体提交」又写回来。 */
    { path: "license.draftCode", type: "text", def: "" },
    { path: "license.status",   type: "enum", values: ["none", "active", "expired"], def: "none" },
    { path: "license.expireAt", type: "text", def: "" }
);

/* ——— 全局悬浮球（规格书 §10 / H1–H7）———
 * 三个字段都是「记忆用户的选择」，没有它们球每次都会跑回默认位置：
 *   · hidden —— 用户点了「隐藏悬浮球」。没有它就只能靠"下次启动又冒出来"，
 *     而那是最招人烦的一种行为；恢复入口在「我的」页（本项目补充，规格书未写）。
 *   · side / yRatio —— 拖动吸附后的位置。存**比例**而不是像素：换机型、
 *     换分辨率、旋转后仍然落在相对合理的位置（存像素就会出现"球跑到屏幕外"）。 */
F.push(
    { path: "ball.hidden", type: "bool", def: false },
    { path: "ball.side",   type: "enum", values: ["left", "right"], def: "left" },
    { path: "ball.yRatio", type: "int", min: 0, max: 1000, def: 500 }
);

/* ——— ID提取页 ———
 * ★ v8（2026-10-17）：四张脚本卡的 **23 个字段全部删除**。
 *
 * 为什么删而不是继续改：四张卡是「起点 × 深度」的 4 个**不完整组合**
 * （各缺一块、各有别人没有的一块，合起来才完整）。这个结构本身就是"乱"的根 ——
 * 于是用户想同时抓两种来源时，单选约束直接不允许。
 * v8 把它们换成**取材清单**：可累加、每条自带起点与深度、按顺序串行执行。
 *
 * 清单**不在这张表里**：它是不定长列表，放进来就等于让 validate() 去校验数组，
 * 还会把「路径 → 值控件」那套审计规则带歪。它走 `Sources` 模块自己的 storage key
 * （照 `Records` 先例，理由见 `src/sources.js` 文件头）。
 *
 * 旧配置由 `Sources.migrateLegacy()` 翻译成清单（`Store.load` 末尾调用）：
 * 用户原来的选择一个都不丢 —— s4 的三个开关甚至会展开成**三条**取材。
 */

/* ID提取页的「功能设置」（设计稿 16:733）。
 * 门槛类字段（关注量/粉丝量/获赞量/视频量）按「一个控件一个数」拆成 min/max 两项，
 * 而不是设计稿里的 0 ~ 500000 一个控件 —— 与 UID私信页的上限处理保持同一套规则。 */
F.push(
    { path: "tabs.id.features.filterPrivate",  type: "bool", def: true },
    { path: "tabs.id.features.filterNoAvatar", type: "bool", def: true },
    { path: "tabs.id.features.regionCodes",    type: "text", def: "JP#TW#US" },
    { path: "tabs.id.features.langRegion",     type: "enum", group: "langRegion",    def: "any" },
    { path: "tabs.id.features.nicknameCheck",  type: "enum", group: "nicknameCheck", def: "any" },
    { path: "tabs.id.features.cloudDedupe",    type: "bool", def: false },
    /* optional 标记的字段允许默认空串：云端去重默认是关的，
     * 「还没填表名」是一个真实且合理的状态，不该被塞一个假默认值。
     * 取值审计靠这个标记把它和「漏了默认值」区分开。 */
    { path: "tabs.id.features.cloudTable",     type: "text", def: "", optional: true },
    /* v7：本地去重从脚本卡收到这里，全页只出现一次。
     * 「跨轮去重」是另一件事：与历史已提取的 ID 比对，所以单独一个开关 ——
     * 原来用「ID 模式 / UID 模式」两个词表达它，用户根本看不出那是在说"要不要跟历史比"。 */
    { path: "tabs.id.features.dedupeLocal",    type: "bool", def: true },
    { path: "tabs.id.features.dedupeHistory",  type: "bool", def: false },
    { path: "tabs.id.features.aiAvatar",       type: "bool", def: false },
    { path: "tabs.id.features.aiGender",       type: "enum", group: "aiGender", def: "male" },
    { path: "tabs.id.features.aiAgeMax",       type: "int", min: 0, max: 100, def: 20 },
    { path: "tabs.id.features.followMin",      type: "int", min: 0, max: 100000000, def: 0 },
    { path: "tabs.id.features.followMax",      type: "int", min: 0, max: 100000000, def: 500000 },
    { path: "tabs.id.features.fansMin",        type: "int", min: 0, max: 100000000, def: 0 },
    { path: "tabs.id.features.fansMax",        type: "int", min: 0, max: 100000000, def: 500000 },
    { path: "tabs.id.features.likesMin",       type: "int", min: 0, max: 100000000, def: 0 },
    { path: "tabs.id.features.likesMax",       type: "int", min: 0, max: 100000000, def: 500000 },
    { path: "tabs.id.features.videosMin",      type: "int", min: 0, max: 100000000, def: 0 },
    { path: "tabs.id.features.videosMax",      type: "int", min: 0, max: 100000000, def: 500000 },
    /* 0 = 不限制。用「0 表示不限」而不是留空，是因为数字输入框留空无法表达。 */
    { path: "tabs.id.features.extractLimit",   type: "int", min: 0, max: 100000, def: 0 },
    /**
     * 抓完之后是否顺手把 username 换成 TikTok 内部的数字 uid，另存一份映射文件。
     *
     * 默认开：数字 uid 在 App 界面上任何地方都读不到，不在这里换就得事后另跑一次。
     * 但每个要多下约 400KB 的主页 SSR（约 2.5 秒），只要 handle 的场景可以关掉。
     * 2026-10-28 之前这个开关只存在于引擎配置里（界面写死 true），想关得改代码。
     */
    { path: "tabs.id.features.resolveUid",     type: "bool", def: true },
    /**
     * 运行时长的**下限**（分钟）。
     *
     * 它不是"最长多久"，而是"至少跑这么久"—— 引擎会按提取上限自动放大：
     * 每个收录约 20 秒（开过滤时要逐个开用户页，含被跳过的折算），
     * 所以 limit=100 会自动给到约 38 分钟，limit=1000 给到 4 小时（封顶）。
     *
     * 界面上写「至少运行 __ 分钟（按提取上限自动放宽，最多 4 小时）」。
     */
    { path: "tabs.id.features.maxRuntimeMin",  type: "int", min: 1, max: 240, def: 30 }
);

/* ——— UID私信页 ——— */
F.push.apply(F, cardFields("tabs.dm.scripts.s1", true, true));
F.push(
    { path: "tabs.dm.scripts.s1.doDm",        type: "bool", def: true },
    { path: "tabs.dm.scripts.s1.filterDate",  type: "enum", group: "filterDate",  def: "7d" },
    { path: "tabs.dm.scripts.s1.firstAction", type: "enum", group: "firstAction", def: "both" },
    { path: "tabs.dm.scripts.s1.uidTextPath", type: "text", def: Store.TEXT_DIR + "/uid_list.txt" }
);
F.push.apply(F, cardFields("tabs.dm.scripts.s2", false, false));
F.push(
    { path: "tabs.dm.aiGender",     type: "enum", group: "aiGender",    def: "male" },
    /* 关注与私信是两个独立动作，各自一个开关 + 一个数量区间。
     * 早先把它们挤成「进行关注 / 进行私信」一个开关、「200 / 30」一个控件，
     * 结果是想单独关掉私信就得连关注一起关掉。
     * 数量本身是**区间**（最少关注多少、最多关注多少），所以是一行两项。 */
    { path: "tabs.dm.doFollow",     type: "bool", def: true },
    { path: "tabs.dm.followMin",    type: "int", min: 0, max: 5000, def: 100 },
    { path: "tabs.dm.followMax",    type: "int", min: 0, max: 5000, def: 200 },
    { path: "tabs.dm.doDm",         type: "bool", def: true },
    { path: "tabs.dm.dmMin",        type: "int", min: 0, max: 1000, def: 20 },
    { path: "tabs.dm.dmMax",        type: "int", min: 0, max: 1000, def: 30 },
    { path: "tabs.dm.restMin",      type: "int", min: 0, max: 3600, def: 100 },
    { path: "tabs.dm.restMax",      type: "int", min: 0, max: 3600, def: 500 },
    { path: "tabs.dm.dedupeMode",   type: "enum", group: "dedupeMode",  def: "follow_dm" },
    { path: "tabs.dm.dmTextPath",      type: "text", def: Store.TEXT_DIR + "/dm_text.txt" },
    { path: "tabs.dm.commentTextPath", type: "text", def: Store.TEXT_DIR + "/comment_text.txt" }
);

/* ——— 养号页 ———
 * 参数与脚本卡分开存：即使不勾选脚本，用户也能先把这组参数调好。
 * 浏览时长与单次操作都是区间（两个数），概率仍然是固定档位。 */
F.push.apply(F, cardFields("tabs.nurture.scripts.s1", true, false));
F.push(
    { path: "tabs.nurture.browseMin",      type: "int", min: 0, max: 600, def: 3 },
    { path: "tabs.nurture.browseMax",      type: "int", min: 0, max: 600, def: 8 },
    { path: "tabs.nurture.likeRate",       type: "enum", group: "likeRate",    def: "r30" },
    { path: "tabs.nurture.commentRate",    type: "enum", group: "commentRate", def: "r10" },
    { path: "tabs.nurture.followRate",     type: "enum", group: "followRate",  def: "r15" },
    { path: "tabs.nurture.actionMin",      type: "int", min: 0, max: 500, def: 10 },
    { path: "tabs.nurture.actionMax",      type: "int", min: 0, max: 500, def: 30 }
);

/* ——— 视频功能页 ———
 * keyword / region 给的是**可直接跑的业务默认值**而不是空串：
 * 空着的输入框既看不出该填什么，也让「未配置」和「配了空值」无法区分。 */
F.push.apply(F, cardFields("tabs.video.scripts.s1", false, false));
F.push(
    { path: "tabs.video.keyword",     type: "text", def: "fashion" },
    { path: "tabs.video.region",      type: "text", def: "US" },
    { path: "tabs.video.stopMin",     type: "int", min: 1, max: 500,  def: 1 },
    { path: "tabs.video.stopMax",     type: "int", min: 1, max: 500,  def: 5 },
    { path: "tabs.video.intervalMin", type: "int", min: 0, max: 3600, def: 20 },
    { path: "tabs.video.intervalMax", type: "int", min: 0, max: 3600, def: 20 },
    { path: "tabs.video.actions.follow",  type: "bool", def: true },
    { path: "tabs.video.actions.dm",      type: "bool", def: true },
    { path: "tabs.video.actions.like",    type: "bool", def: false },
    { path: "tabs.video.actions.comment", type: "bool", def: false },
    { path: "tabs.video.dmTextPath",      type: "text", def: Store.TEXT_DIR + "/dm_text.txt" },
    { path: "tabs.video.commentTextPath", type: "text", def: Store.TEXT_DIR + "/comment_text.txt" }
);

Store.FIELDS = F;

/**
 * 跨字段约束：上界不得小于下界。
 * 单字段的 min/max 表达不了这种关系，所以单独列出来做后处理。
 *
 * 界面上每一个 `W.rangeRow` 都必须在下面有一对 ——
 * 漏一条的后果是「最小值 500 / 最大值 100」这种自相矛盾的组合能存进配置，
 * 而且因为区间行的两个数在**同一行**，错位比拆两行时更刺眼。
 */
Store.CROSS_RULES = [
    { low: "tabs.dm.followMin", high: "tabs.dm.followMax" },
    { low: "tabs.dm.dmMin",     high: "tabs.dm.dmMax" },
    { low: "tabs.dm.restMin",   high: "tabs.dm.restMax" },
    { low: "tabs.nurture.browseMin", high: "tabs.nurture.browseMax" },
    { low: "tabs.nurture.actionMin", high: "tabs.nurture.actionMax" },
    { low: "tabs.video.stopMin",     high: "tabs.video.stopMax" },
    { low: "tabs.video.intervalMin", high: "tabs.video.intervalMax" },
    { low: "tabs.id.features.followMin", high: "tabs.id.features.followMax" },
    { low: "tabs.id.features.fansMin",   high: "tabs.id.features.fansMax" },
    { low: "tabs.id.features.likesMin",  high: "tabs.id.features.likesMax" },
    { low: "tabs.id.features.videosMin", high: "tabs.id.features.videosMax" }
];

/* ---------------------------------------------------------------- 路径工具 */

function isPlainObject(value) {
    return value !== null && typeof value === "object" && !(value instanceof Array);
}

function readPath(obj, path) {
    var segs = String(path).split(".");
    var node = obj;
    for (var i = 0; i < segs.length; i++) {
        if (node === null || typeof node !== "object") { return undefined; }
        node = node[segs[i]];
    }
    return node;
}

function assignPath(obj, path, value) {
    var segs = String(path).split(".");
    var node = obj;
    for (var i = 0; i < segs.length - 1; i++) {
        if (!isPlainObject(node[segs[i]])) { node[segs[i]] = {}; }
        node = node[segs[i]];
    }
    node[segs[segs.length - 1]] = value;
    return obj;
}

/* ---------------------------------------------------------------- 默认值 */

/** 从字段表推导默认配置——默认值只有这一处来源，不会与校验规则漂移。 */
Store.defaults = function () {
    var cfg = { version: Store.SCHEMA_VERSION };
    for (var i = 0; i < Store.FIELDS.length; i++) {
        var f = Store.FIELDS[i];
        assignPath(cfg, f.path, f.def);
    }
    return cfg;
};

/* ---------------------------------------------------------------- 版本迁移 */

/**
 * 逐版本迁移。键是「从哪个版本升上来」，函数把配置就地改造成下一版的样子。
 *
 * 参数说明：
 *   cfg —— 已经按当前字段表归一化过的配置（结构完整、类型正确）
 *   src —— **原始输入**。有些旧字段在新版字段表里已被删除，
 *          归一化后 cfg 里就没有它了，只能从 src 里读回来。
 *
 * 为什么必须有迁移：类型归一化只能处理「类型不对」，
 * 处理不了「语义变了」——例如 v1 的空串其实等于未设置、
 * v2 的一个开关其实要拆成两个。这类差异只有迁移能表达。
 */
Store.MIGRATIONS = {
    1: function (cfg, problems) {
        /* v1 里这几项的默认值都是空串，界面上表现为空框 */
        var emptyInV1 = [
            "tabs.video.keyword",
            "tabs.video.region",
            "tabs.dm.dmTextPath",
            "tabs.dm.commentTextPath",
            "tabs.video.dmTextPath",
            "tabs.video.commentTextPath"
        ];

        for (var i = 0; i < emptyInV1.length; i++) {
            var path = emptyInV1[i];
            if (readPath(cfg, path) === "") {
                var def = Store.defaultOf(path);
                if (def) {
                    assignPath(cfg, path, def);
                    problems.push(path + " 旧版为空，已补默认值 " + def);
                }
            }
        }
    },

    2: function (cfg, problems, src) {
        /* v2 用一个 doFollowDm 同时控制关注与私信，v3 拆成两个独立开关。
         * 旧值同时赋给两者，保证升级后行为与升级前一致（都是开就是都开）。 */
        var legacy = readPath(src, "tabs.dm.doFollowDm");
        if (typeof legacy === "boolean") {
            assignPath(cfg, "tabs.dm.doFollow", legacy);
            assignPath(cfg, "tabs.dm.doDm", legacy);
            problems.push("tabs.dm.doFollowDm 已拆为「进行关注」「进行私信」两个开关，旧值 " +
                          legacy + " 已沿用");
        }
    },

    /**
     * v4 → v5：五处「一个值」改成「一个区间」。
     *
     * 迁移原则是**不改变原有行为**，具体分三类：
     *   · 原本是「上限」的（关注上限 / 私信上限 / 单次操作上限）
     *     → min 给 0（= 不设下界），max 沿用旧上限。
     *       旧语义就是「最多 N 个」，升级后仍然是最多 N 个。
     *   · 原本是「精确个数」的（停止个数）
     *     → min = max = 旧值。这跟设计稿里「间隔时间 20 ~ 20」是同一个表达：
     *       相等的上下界就是定值。
     *   · 原本是「档位」的（浏览时长 3 ~ 8 这类）
     *     → 直接取该档的上下界，一一对应。
     * 全新安装拿到的则是设计稿给的默认区间（例如 关注数量 100 ~ 200）。
     */
    4: function (cfg, problems, src) {
        /* 旧档位 → 区间。两组档位的 key 本身不重叠（d3_8… / n10…），
         * 所以用一张平表就够，不必再按字段名分一层。 */
        var RANGE_OF = {
            "d3_8": [3, 8], "d5_10": [5, 10], "d8_15": [8, 15],
            "n10": [0, 10], "n20": [0, 20], "n30": [0, 30], "n50": [0, 50]
        };

        inheritRange(src, cfg, problems, "tabs.dm.followLimit", 0, "upper",
                     "tabs.dm.followMin", "tabs.dm.followMax", "关注数量");
        inheritRange(src, cfg, problems, "tabs.dm.dmLimit", 0, "upper",
                     "tabs.dm.dmMin", "tabs.dm.dmMax", "私信数量");
        inheritRange(src, cfg, problems, "tabs.nurture.actionLimit", 0, "upper",
                     "tabs.nurture.actionMin", "tabs.nurture.actionMax", "单次操作", RANGE_OF);
        inheritRange(src, cfg, problems, "tabs.nurture.browseDuration", 0, "upper",
                     "tabs.nurture.browseMin", "tabs.nurture.browseMax", "浏览时长（分钟）", RANGE_OF);
        inheritRange(src, cfg, problems, "tabs.video.stopCount", 0, "exact",
                     "tabs.video.stopMin", "tabs.video.stopMax", "停止个数");
    },

    /**
     * v5 → v6：底栏从 5 个页签收敛成 3 个 tab（任务 / 记录 / 我的）。
     *
     * 这不是"改个名字"：原来的 id/dm/nurture/video 四个页签
     * **降级成「任务」tab 里的四张任务卡**，各自的详情页成了二级页。
     * 所以老存档里 `activeTab = "nurture"` 必须映射成 `"tasks"` ——
     * 不映射的话写入端的枚举归一化会把非法值回退成默认值，
     * 表面上"没问题"，但老用户会发现"我上次停在养号页，重启跑到任务列表了"，
     * 而这恰恰是**无法解释**的那类现象。
     *
     * 四个旧页签的**配置数据一个都没动**（`tabs.id.*` / `tabs.dm.*` / … 原样保留），
     * 只是入口层级变了 —— 迁移只碰入口，不碰业务配置。
     */
    5: function (cfg, problems, src) {
        var OLD_TABS = ["id", "dm", "nurture", "video"];
        var oldTab = readPath(src, "activeTab");
        if (OLD_TABS.indexOf(oldTab) >= 0) {
            assignPath(cfg, "activeTab", "tasks");
            /* 老用户在某个任务页上 → 直接把他带回那个任务的详情页，
             * 而不是只扔到任务列表让他自己再点一次。 */
            assignPath(cfg, "activeDetail", oldTab);
            problems.push("activeTab " + oldTab + " → tasks（该任务已升为二级页，已直接停在它的详情页）");
        } else if (oldTab === "mine") {
            assignPath(cfg, "activeTab", "mine");
        }
    },

    /**
     * v6 → v7：ID提取页清语义（需求重整 A 档）。
     *
     * 两件必须做的，都是"类型系统看不出来的语义差异"：
     *
     * ① **s3 的「进入页面」值域收窄**。原来是共用 `enterPage` 的四个值
     *    （粉丝页/评论页/主页/关注页），但这个字段在脚本三里的意思是
     *    "展开文本里这些人的哪个**列表**" —— 评论页和主页根本不是列表。
     *    存量值是这两个的，一律落到「关注列表」（脚本三的设计稿默认值）。
     *    不处理的话，`normalizeField` 会把非法枚举悄悄退回默认值，
     *    用户只会看到"我选过的选项自己变了"，而不知道发生了什么。
     *
     * ② **去重从卡片搬到功能设置**。旧的 `dedupeEnabled` 是用户对"要不要去重"
     *    的真实表达，不能因为控件搬家就丢掉 —— 把它继承到 `dedupeLocal`。
     *    旧 `dedupe`（ID 模式 / UID 模式）表达的其实是"跟不跟历史比"，
     *    映射到新增的 `dedupeHistory`（"UID 模式"= 按输入文本比 = 留了个文本基准，
     *    语义上更接近"跨轮"）。这条映射**不完美**，所以写进 problems 里说清楚。
     */
    6: function (cfg, problems, src) {
        /* ⚠️ v8 起 s3 的「进入页面」字段已经随四张卡一起删除，
         * 这里不再对它做归一化 —— 那段值现在由 `Sources.migrateLegacy()`
         * 从原始 src 直接读，翻译成取材的「展开哪个列表」。
         * 原来那条 assignPath 会写到一个**已不存在的路径**上，纯属幽灵写入。 */

        var oldDedupe = readPath(src, "tabs.id.scripts.s1.dedupeEnabled");
        if (typeof oldDedupe === "boolean") {
            assignPath(cfg, "tabs.id.features.dedupeLocal", oldDedupe);
            problems.push("「主播去重」已并入功能设置 →「本地去重」，旧值 " + oldDedupe + " 已沿用");
        }

        var oldMode = readPath(src, "tabs.id.scripts.s1.dedupe");
        if (oldMode === "text") {
            assignPath(cfg, "tabs.id.features.dedupeHistory", true);
            problems.push("旧去重模式「UID 模式」→「跨轮去重」已打开（按输入文本比对历史）");
        }
    }
};

/**
 * 把一个**已被删除**的旧字段迁移成一对区间字段。
 *
 * 为什么必须从 src 里读：旧字段已经不在 `Store.FIELDS` 里，
 * 归一化之后的 cfg 里根本没有它 —— 只有原始输入还留着。
 *
 * mode:
 *   "upper" —— 旧值是上限 → min 给 fallback（通常是 0），max = 旧值
 *   "exact" —— 旧值是精确量 → min = max = 旧值
 * mapping —— 若给了映射表，旧值是里面的档位 key，直接取对应的一对数字
 */
function inheritRange(src, cfg, problems, legacyPath, fallback, mode, minPath, maxPath, label, mapping) {
    var legacy = readPath(src, legacyPath);
    if (legacy === undefined || legacy === null) { return; }

    var low = fallback;
    var high = fallback;

    if (mapping) {
        var pair = mapping[legacy];
        if (!pair) { return; }
        low = pair[0];
        high = pair[1];
    } else {
        var n = Number(legacy);
        if (isNaN(n)) { return; }
        low = (mode === "exact") ? n : fallback;
        high = n;
    }

    assignPath(cfg, minPath, low);
    assignPath(cfg, maxPath, high);
    problems.push(legacyPath + " → " + label + " " + low + " ~ " + high +
                  "（旧值 " + legacy + " 已沿用）");
}

/* ---------------------------------------------------------------- 校验 */

/** 单字段归一化。只有「确实非法」才记问题——缺失属正常迁移，不刷屏。 */
function normalizeField(raw, field, problems) {
    var missing = raw === undefined || raw === null;

    if (field.type === "bool") {
        return missing ? field.def : !!raw;
    }

    if (field.type === "int") {
        var n = Number(raw);
        if (missing || raw === "" || isNaN(n)) {
            if (!missing && raw !== "") {
                problems.push(field.path + " 不是数字（" + raw + "），已用默认值 " + field.def);
            }
            return field.def;
        }
        n = Math.round(n);
        if (field.min !== undefined && n < field.min) {
            problems.push(field.path + " " + n + " 低于下限，已抬到 " + field.min);
            n = field.min;
        }
        if (field.max !== undefined && n > field.max) {
            problems.push(field.path + " " + n + " 超过上限，已压到 " + field.max);
            n = field.max;
        }
        return n;
    }

    if (field.type === "enum") {
        var keys = field.values || enumKeys(field.group);
        if (keys.indexOf(raw) >= 0) { return raw; }
        if (!missing) {
            problems.push(field.path + " 非法取值（" + raw + "），已回退 " + field.def);
        }
        return field.def;
    }

    /* text：只认字符串。
     * 非字符串（数字/布尔/对象）一律回退默认值，**不做 String() 转换**——
     * 配置里出现数字只可能是手改或异常写入，把 42 静默转成 "42"
     * 会让一个无效的搜索条件直接生效，比回退默认危险得多。
     * （用户正常输入的数字也会以字符串形式存进来，不会走到这里。） */
    if (typeof raw === "string") { return raw; }
    if (!missing) {
        problems.push(field.path + " 不是文本（" + (typeof raw) + "），已用默认值 " + field.def);
    }
    return field.def;
}

/**
 * 把任意输入收敛成合法配置。返回 { config, problems }。
 *
 * 遍历的是**字段表**而不是输入对象 —— 表外的键会被丢弃，
 * 这样手改过的脏 JSON、旧版本残留字段都不会穿透到界面。
 *
 * problems 用于运行期把发现的问题打印出来：设备端没有测试框架，
 * 校验结果必须能被人看见，否则「悄悄用默认值跑」比报错更难查。
 */
Store.validate = function (input) {
    var src = isPlainObject(input) ? input : {};
    var problems = [];

    /* 没写 version 的（很早期的存档）按 0 处理，否则 NaN 的比较恒为 false，迁移会被跳过 */
    var fromVersion = Number(input ? input.version : 0);
    if (isNaN(fromVersion)) { fromVersion = 0; }

    if (fromVersion !== Store.SCHEMA_VERSION) {
        problems.push("version " + (input && input.version !== undefined ? input.version : "(无)") +
                      " → " + Store.SCHEMA_VERSION + "，缺失字段已按默认值补齐");
    }

    var cfg = { version: Store.SCHEMA_VERSION };
    for (var i = 0; i < Store.FIELDS.length; i++) {
        var f = Store.FIELDS[i];
        assignPath(cfg, f.path, normalizeField(readPath(src, f.path), f, problems));
    }

    /* 迁移放在归一化之后：此时 cfg 已是完整结构，迁移只需处理语义差异
     * （例如「v1 的空串其实等于未设置」「v2 的一个开关要拆成两个」这类
     *  类型系统看不出来的事）。src 一并传入，用于读取已被删除的旧字段。 */
    for (var v = fromVersion; v < Store.SCHEMA_VERSION; v++) {
        var migrate = Store.MIGRATIONS[v];
        if (migrate) { migrate(cfg, problems, src); }
    }

    for (var j = 0; j < Store.CROSS_RULES.length; j++) {
        var rule = Store.CROSS_RULES[j];
        var low = readPath(cfg, rule.low);
        var high = readPath(cfg, rule.high);
        if (typeof low === "number" && typeof high === "number" && high < low) {
            problems.push(rule.high + "(" + high + ") 小于 " + rule.low + "(" + low + ")，已抬齐");
            assignPath(cfg, rule.high, low);
        }
    }

    return { config: cfg, problems: problems };
};

/* ---------------------------------------------------------------- 合并 */

/**
 * 深合并：patch 覆盖 base 的同名键，patch 没有的键保留 base 的值。
 * 只递归「纯对象」——数组整体替换，不逐项合并（数组语义通常是「整份配置」）。
 */
Store.merge = function (base, patch) {
    if (!isPlainObject(patch)) { return base; }
    var out = {};
    var k;
    for (k in base) {
        if (base.hasOwnProperty(k)) { out[k] = base[k]; }
    }
    for (k in patch) {
        if (!patch.hasOwnProperty(k)) { continue; }
        if (isPlainObject(base[k]) && isPlainObject(patch[k])) {
            out[k] = Store.merge(base[k], patch[k]);
        } else {
            out[k] = patch[k];
        }
    }
    return out;
};

/* ---------------------------------------------------------------- 读写 */

function storage() {
    return storages.create(Store.STORAGE_NAME);
}

/** 读配置；任何异常都退回默认值，绝不让界面因读取失败而起不来。 */
Store.load = function () {
    var raw = null;
    try {
        raw = storage().get(Store.STORAGE_KEY, null);
    } catch (e) {
        console.log("[store] 读取失败，使用默认配置: " + e);
    }
    if (typeof raw === "string" && raw.length > 0) {
        try {
            raw = JSON.parse(raw);
        } catch (e2) {
            console.log("[store] JSON 解析失败，使用默认配置");
            raw = null;
        }
    }
    var result = Store.validate(raw);
    if (result.problems.length > 0) {
        console.log("[store] 校验修正: " + result.problems.join(" | "));
    }
    return result.config;
};

/** 写配置。返回是否成功——界面要据此提示用户，而不是静默丢数据。 */
Store.save = function (config) {
    try {
        storage().put(Store.STORAGE_KEY, JSON.stringify(config));
        return true;
    } catch (e) {
        console.log("[store] 保存失败: " + e);
        return false;
    }
};

Store.reset = function () {
    try {
        storage().remove(Store.STORAGE_KEY);
    } catch (e) {
        console.log("[store] 重置失败: " + e);
    }
    return Store.defaults();
};

/* 运行期只持有一份实例，页面通过它读写，避免各自 load 出多份副本互相覆盖。 */
Store.state = null;

Store.init = function () {
    Store.state = Store.load();
    return Store.state;
};

Store.current = function () {
    if (!Store.state) { Store.init(); }
    return Store.state;
};

/** 按路径取字段声明；没有契约的路径返回 null（调用方据此决定要不要归一化）。 */
Store.fieldOf = function (path) {
    for (var i = 0; i < Store.FIELDS.length; i++) {
        if (Store.FIELDS[i].path === path) { return Store.FIELDS[i]; }
    }
    return null;
};

/**
 * 改一个字段并立即落盘。页面唯一的状态写入出口。
 *
 * ★ 写之前先按字段表**归一化**（夹紧越界、回退非法枚举、纠正类型）。
 *   「配置里永远没有越界值」这条不变量必须由写入端保证，而不是只靠 load 时的
 *   `validate()`。少了这一步，界面上直接输入的值会原样落盘：用户填 99999 越过了
 *   上限 500，配置里就真的是 99999 —— 要等下一次重启加载才被纠正，
 *   而用户看到的是「我填的数它照收了，可跑起来又不是那么回事」。
 */
Store.set = function (path, value) {
    var field = Store.fieldOf(path);
    /* 表外的路径（例如未来新增的临时键）不做归一化，原样写入 */
    var next = field ? normalizeField(value, field, []) : value;
    assignPath(Store.current(), path, next);
    return Store.save(Store.current());
};

/**
 * 取字段值。第二参数是缺失时的兜底 —— **页面里凡是喂给界面的取值都应该带上它**，
 * 否则 undefined 会一路飘到 String() 变成界面上的 "undefined"。
 */
Store.get = function (path, fallback) {
    var value = readPath(Store.current(), path);
    return value === undefined ? fallback : value;
};

/* ------------------------------------------------- 类型安全的取值（界面专用） */

/** 取某字段在字段表里声明的默认值——界面兜底时用它，与数据层保持同一来源。 */
Store.defaultOf = function (path) {
    for (var i = 0; i < Store.FIELDS.length; i++) {
        if (Store.FIELDS[i].path === path) { return Store.FIELDS[i].def; }
    }
    return undefined;
};

/** groupOrValues 既接受枚举组名，也接受候选数组。 */
function keysOf(groupOrValues) {
    if (groupOrValues instanceof Array) { return groupOrValues; }
    return enumKeys(groupOrValues);
}

/**
 * 取枚举值，**保证返回一个合法 key**。
 * 缺失或非法时回退到该枚举第一项，并把这个修正回写到配置里——
 * 于是「选择框总有选中项」在数据层就被保证，页面不必各自兜底。
 */
Store.getEnum = function (path, groupOrValues) {
    var keys = keysOf(groupOrValues);
    var raw = Store.get(path, null);
    if (raw !== null && keys.indexOf(raw) >= 0) { return raw; }

    var fallback = keys.length > 0 ? keys[0] : "";
    var declared = Store.defaultOf(path);
    if (declared !== undefined && keys.indexOf(declared) >= 0) { fallback = declared; }
    Store.set(path, fallback);
    return fallback;
};

/** 取数值，保证返回有限数；非法时回退默认值并回写。 */
Store.getNumber = function (path, def) {
    var raw = Store.get(path, null);
    var n = Number(raw);
    if (raw !== null && raw !== "" && !isNaN(n)) { return n; }

    var fallback = def === undefined ? Store.defaultOf(path) : def;
    if (typeof fallback !== "number") { fallback = 0; }
    Store.set(path, fallback);
    return fallback;
};

/** 取文本，保证返回字符串；缺失或非字符串时回退默认值并回写。 */
Store.getText = function (path, def) {
    var raw = Store.get(path, null);
    if (typeof raw === "string") { return raw; }

    var fallback = def === undefined ? Store.defaultOf(path) : def;
    if (typeof fallback !== "string") { fallback = ""; }
    Store.set(path, fallback);
    return fallback;
};

/** 取布尔，保证返回布尔值。 */
Store.getBool = function (path, def) {
    var raw = Store.get(path, null);
    if (typeof raw === "boolean") { return raw; }

    var fallback = def === undefined ? Store.defaultOf(path) : def;
    if (typeof fallback !== "boolean") { fallback = false; }
    Store.set(path, fallback);
    return fallback;
};


/* ============================== src/records.js ============================== */
/* ============================== src/records.js ==============================
 * 运行记录（规格书 D1/D2/D3 的数据来源）。
 *
 * ## 为什么单独一个模块，而不是塞进 Store.FIELDS
 * Store 管的是「**固定字段**的配置」——一张声明表，每个路径一个值。
 * 运行记录是**不定长的列表**（跑一次多一条），塞进字段表就等于
 * 让 validate() 去校验一个数组，还把「路径 → 值控件」的那套审计规则带歪。
 * 所以它走同一份 storages 的**另一个 key**，自己管读写。
 *
 * ## 记录里存什么
 * 只存**界面真的知道的东西**：任务/脚本、结果分类、起止时间、结果文案、
 * 结果文件、日志行。不编造没发生过的字段（例如"实际提取了几个 ID"只有
 * 引擎回传了才写；没回传就留空，D3 那一行就不显示）。
 *
 * ## 日志从哪来
 * 引擎（tiktok-auto）通过 `--log` 通道把真实输出按行 append 到
 * run-log.jsonl，界面在结束时读回来。**没有日志就不显示日志卡的空壳** ——
 * 详见 `Engine.readLog()` 与 §「日志缺失时如实说明」。
 */

var Records = {};

/** 与 Store 共用一份 storages，只是换一个 key（见文件头注释）。 */
Records.STORAGE_NAME = "feizhou_app";
Records.STORAGE_KEY = "records";

/**
 * 最多保留多少条。
 *
 * 上限是**必要的**：记录里含日志行，跑几十次之后 JSON 会长到
 * storages 读取明显变慢（它每次整体读字符串）。
 * 50 条足够回溯，超出的从尾部丢弃（新记录永远在最前）。
 */
Records.MAX = 50;

/** 结果分类 → 界面文案 + 色调。tone 直接喂给 W.pill。 */
Records.RESULT = {
    success: { key: "success", label: "\u5DF2\u5B8C\u6210",   tone: "ok" },
    stopped: { key: "stopped", label: "\u624B\u52A8\u505C\u6B62", tone: "mute" },
    failed:  { key: "failed",  label: "\u62A5\u9519\u4E2D\u65AD", tone: "danger" }
};

/** 归一化结果分类：引擎给的终态与记录分类不是一套词（finished/stopped/failed）。 */
Records.resultOf = function (status) {
    if (status === "finished" || status === "success") { return Records.RESULT.success; }
    if (status === "stopped") { return Records.RESULT.stopped; }
    return Records.RESULT.failed;
};

/* ------------------------------------------------------------ 读写 */

function storage() {
    return storages.create(Records.STORAGE_NAME);
}

/** 读全部记录（新的在前）。任何异常都退回空数组——记录读不出来不该让界面起不来。 */
Records.list = function () {
    var raw = null;
    try {
        raw = storage().get(Records.STORAGE_KEY, null);
    } catch (e) {
        console.log("[records] 读取失败: " + e);
    }
    if (typeof raw === "string" && raw.length > 0) {
        try {
            raw = JSON.parse(raw);
        } catch (e2) {
            console.log("[records] JSON 解析失败，按空处理");
            raw = null;
        }
    }
    if (!(raw instanceof Array)) { return []; }

    /* 逐条清洗：缺 id / 缺任务名的脏条目直接丢掉，
     * 免得 D1 上出现一行点不开、也说不清是什么的东西。 */
    var out = [];
    for (var i = 0; i < raw.length; i++) {
        var one = raw[i];
        if (!one || typeof one !== "object") { continue; }
        if (!one.id || !one.taskKey) { continue; }
        out.push(one);
    }
    return out;
};

Records.save = function (list) {
    try {
        storage().put(Records.STORAGE_KEY, JSON.stringify(list));
        return true;
    } catch (e) {
        console.log("[records] 保存失败: " + e);
        return false;
    }
};

/**
 * 追加一条记录（新的在最前）。
 * @returns 落盘后的那条记录（含 id）——调用方（F5 的「查看日志」）要用它跳 D3
 */
Records.add = function (record) {
    var list = Records.list();
    var one = record || {};
    one.id = one.id || ("rec-" + Date.now() + "-" + Math.floor(Math.random() * 10000));
    one.taskKey = one.taskKey || "";
    one.taskName = one.taskName || "";
    one.scriptKey = one.scriptKey || "";
    one.scriptName = one.scriptName || "";
    one.result = one.result || "success";
    one.startedAt = one.startedAt || 0;
    one.endedAt = one.endedAt || Date.now();
    one.resultText = one.resultText || "";
    one.resultFile = one.resultFile || "";
    /* uid 映射文件的路径（ID提取且勾了「同时解析数字 uid」时才有）。
     * 老记录里没有这个字段 → 归一化成空串，渲染层据此决定要不要多一行。 */
    one.mapFile = one.mapFile || "";
    /* runId：记录页要靠它和断点里的 runId 对上（见 Resume.isRecordResumable）。
     * 老记录没有这个字段 → 归一化成空串，于是永远不会显示「继续」。 */
    one.runId = one.runId || "";
    one.logs = one.logs instanceof Array ? one.logs : [];

    list.unshift(one);
    if (list.length > Records.MAX) { list = list.slice(0, Records.MAX); }
    Records.save(list);
    return one;
};

/** 按 id 取一条（D3 用）。找不到返回 null。 */
Records.find = function (id) {
    var list = Records.list();
    for (var i = 0; i < list.length; i++) {
        if (list[i].id === id) { return list[i]; }
    }
    return null;
};

/** 某个任务最近一条记录（B1 任务卡的「上次…」）。没有则 null。 */
Records.latestOf = function (taskKey) {
    var list = Records.list();
    for (var i = 0; i < list.length; i++) {
        if (list[i].taskKey === taskKey) { return list[i]; }
    }
    return null;
};

Records.clear = function () {
    try {
        storage().remove(Records.STORAGE_KEY);
    } catch (e) {
        console.log("[records] 清空失败: " + e);
    }
};

/* ------------------------------------------------------------ 文案 */

function pad2(n) {
    return n < 10 ? "0" + n : String(n);
}

/**
 * 时长 → 人话。
 *
 * 设计稿上三种形态都出现过（「耗时 12 分 30 秒」/「已运行 41 分钟」/「运行 6 分钟」），
 * 统一走这一个函数，规则是：
 *   < 1 分钟 → "N 秒"
 *   < 1 小时 → 整分钟说「N 分钟」，带零头说「N 分 M 秒」
 *   ≥ 1 小时 → "H 小时 M 分"
 * 为什么整分钟要单独说一句：0 秒是大多数「手动停止」的真实情况，
 * 写成「12 分 0 秒」会让人以为数据不准。
 */
Records.formatDuration = function (ms) {
    var total = Math.max(0, Math.floor((ms || 0) / 1000));
    if (total < 60) { return total + " \u79D2"; }
    if (total < 3600) {
        var m = Math.floor(total / 60);
        var s = total % 60;
        return s === 0 ? (m + " \u5206\u949F") : (m + " \u5206 " + s + " \u79D2");
    }
    var h = Math.floor(total / 3600);
    var mm = Math.floor((total % 3600) / 60);
    return h + " \u5C0F\u65F6 " + mm + " \u5206";
};

/**
 * 时间点 → 「今天 10:24」/「昨天 09:58」/「10-11 09:58」。
 * 相对日期的判断必须用**本机日历**（不是 UTC）：跨时区时 UTC 会让
 * 「今天」错成昨天，而这条文案的全部意义就在于它读起来直观。
 */
Records.formatDay = function (timestamp, nowMs) {
    var d = new Date(timestamp || 0);
    var now = new Date(nowMs === undefined ? Date.now() : nowMs);
    var clock = pad2(d.getHours()) + ":" + pad2(d.getMinutes());

    var sameDay = d.getFullYear() === now.getFullYear()
        && d.getMonth() === now.getMonth()
        && d.getDate() === now.getDate();
    if (sameDay) { return "\u4ECA\u5929 " + clock; }

    var yesterday = new Date(now.getTime() - 86400000);
    var isYesterday = d.getFullYear() === yesterday.getFullYear()
        && d.getMonth() === yesterday.getMonth()
        && d.getDate() === yesterday.getDate();
    if (isYesterday) { return "\u6628\u5929 " + clock; }

    return pad2(d.getMonth() + 1) + "-" + pad2(d.getDate()) + " " + clock;
};

/** D1 条目的时间行：「今天 10:24 · 耗时 12 分 30 秒」 */
Records.timeLine = function (record, nowMs) {
    if (!record) { return ""; }
    var start = record.startedAt || record.endedAt || 0;
    var end = record.endedAt || start;
    var head = Records.formatDay(start, nowMs);
    if (record.durationMs === undefined || record.durationMs === null) {
        record.durationMs = Math.max(0, end - start);
    }
    return head + " \u00B7 \u8017\u65F6 " + Records.formatDuration(record.durationMs);
};

/**
 * D1 条目的结果行。
 * 没给出结果文案时不编 —— 返回空串，由调用方决定这一行要不要出现。
 */
Records.resultLine = function (record) {
    if (!record) { return ""; }
    var text = record.resultText || "";
    if (record.resultFile && text.indexOf(record.resultFile) < 0) {
        text = text === "" ? record.resultFile : text + " \u2192 " + record.resultFile;
    }
    return text;
};

/**
 * B1 任务卡的「上次…」一行。
 * 没有记录 → 「还未运行过」（设计稿 C9 的视频功能卡就是这个文案，不是空白）。
 */
Records.lastRunLine = function (taskKey, nowMs) {
    var one = Records.latestOf(taskKey);
    if (!one) { return "\u8FD8\u672A\u8FD0\u884C\u8FC7"; }
    var clock = Records.formatDay(one.startedAt || one.endedAt, nowMs);
    /* 「今天 10:24」太长，卡上只留时分；跨天的记录才带上日期。 */
    var short = clock.replace("\u4ECA\u5929 ", "\u4E0A\u6B21 ").replace("\u6628\u5929 ", "\u6628\u5929 ");
    var tail = Records.resultLine(one);
    return short + (tail === "" ? "" : " \u00B7 " + tail);
};


/* ============================== src/sources.js ============================== */
/* ============================== src/sources.js ==============================
 * ID提取的「取材清单」—— 从哪儿找人。
 *
 * ## 为什么单独一个模块，而不是塞进 Store.FIELDS
 * Store 管的是「**固定字段**的配置」：一张声明表，一个路径一个标量值。
 * 取材是**不定长列表**（可以 1 条，也可以 5 条），塞进字段表就等于
 * 让 validate() 去校验一个数组，还会把「路径 → 值控件」那套审计规则带歪。
 * 所以照 `Records` 的先例：**同一份 storages，另一个 key**，自己管读写。
 *
 * ## 为什么是「清单」而不是「四个脚本选一个」
 * 旧结构里四张卡是「起点 × 深度」的 4 个**不完整组合**：各缺一块、各有别人没有的一块，
 * 合起来才完整。于是用户想同时抓两种来源时，单选约束直接不允许。
 * 取材是**可累加**的，多条按顺序串行执行（同一台手机只有一个前台，没有并发可言），
 * 共用同一份去重集合与同一个输出文件 —— 这才对得上用户的真实用法。
 *
 * ## 一条取材长什么样
 * `{ id, kind, ...按 kind 决定用哪几个参数..., expand }`
 * 只有 5 种起点，每种需要的参数由 `FIELDS_OF` 声明；界面据此决定显示哪些输入行。
 * **选了什么起点才出现什么输入**，所以不会再有"勾上却无所指"的开关。
 */

var Sources = {};

/** 与 Store / Records 共用一份 storages，只是换一个 key（见文件头注释）。 */
Sources.STORAGE_NAME = "feizhou_app";
Sources.STORAGE_KEY = "sources";

/**
 * 最多几条。
 *
 * 5 条刚好覆盖全部五种起点各一条；再多页面会长到滚不完，
 * 而串行跑一轮的真实耗时也不允许（每条都要挨个打开用户页）。
 */
Sources.MAX = 5;

/**
 * 五种起点。顺序 = 下拉里的顺序 = 从常见到少见。
 *
 * `take` 是"这个起点能取到什么人"，只用于界面说明 ——
 * 执行引擎还没接，所以这里不写任何选择器。
 */
Sources.KINDS = [
    { key: "anchor", label: "指定账号", take: "它的粉丝 / 关注 / 主页展示的账号" },
    { key: "search", label: "搜索结果", take: "用户搜索结果里的人 / 视频的作者" },
    { key: "video",  label: "某个视频的评论区", take: "评论者" },
    { key: "text",   label: "文本文件", take: "文件里每一行的 UID" },
    { key: "screen", label: "当前屏幕", take: "此刻屏幕上这个列表里的人" }
];

/**
 * 深度：**最多 2 层**（列表里的人 → 这些人的粉丝）。
 *
 * 第 3 层不给选项是有原因的：100 个粉丝 × 每人 100 个粉丝 = 1 万次用户页打开，
 * 在真机上不现实，也会让账号看起来异常。这是产品约束，不是实现偷懒。
 */
Sources.EXPANDS = [
    { key: "",          label: "不展开" },
    { key: "fans",      label: "再取粉丝列表" },
    { key: "following", label: "再取关注列表" }
];

/** `anchor` 起点可以取哪几个列表（多选）。 */
Sources.LISTS = [
    { key: "fans",      label: "粉丝列表" },
    { key: "following", label: "关注列表" },
    { key: "home",      label: "主页展示" }
];

/** `search` 起点的两种类型。 */
Sources.SEARCH_TYPES = [
    { key: "users",  label: "用户" },
    { key: "videos", label: "视频作者" }
];

/** `video` 起点的两种来源。 */
Sources.VIDEO_SOURCES = [
    { key: "screen",  label: "当前屏幕" },
    { key: "keyword", label: "关键词搜索" }
];

/**
 * 每种起点**需要哪些参数**。界面与归一化都读这一张表。
 *
 * `lists` 是唯一的多值参数（数组），其余都是字符串。
 */
Sources.FIELDS_OF = {
    anchor: ["anchors", "lists"],
    search: ["searchType", "keyword"],
    video:  ["videoSource", "videoKeyword"],
    text:   ["path"],
    screen: []
};

/** 该起点是否能再展开一层（"当前屏幕"已经是最底了，没得展开）。 */
Sources.canExpand = function (kind) {
    return kind !== "screen";
};

/* ------------------------------------------------------------ 基础工具 */

function sourceTrim(text) {
    return String(text === undefined || text === null ? "" : text).replace(/^\s+|\s+$/g, "");
}

/** 留空就用业务默认值：空输入框既看不出该填什么，也让"没配"和"配了空"分不开。 */
function withDefault(value, fallback) {
    var text = sourceTrim(value);
    return text === "" ? fallback : text;
}

function sourceKeys(list) {
    var out = [];
    for (var i = 0; i < list.length; i++) { out.push(list[i].key); }
    return out;
}

/** 生成一个稳定 id。删除与自检都靠它，所以不能只用下标（删除后下标会滑）。 */
Sources.newId = function () {
    return "src-" + Date.now() + "-" + Math.floor(Math.random() * 10000);
};

/* ------------------------------------------------------------ 归一化 */

/**
 * 把一条取材收拢成合法形状。
 *
 * 两条原则：
 *   ① **只保留与该 kind 有关的参数** —— 用户从「指定账号」切到「文本文件」时，
 *      旧的 anchors 不该继续躺在数据里（导出配置时会让人以为它还有用）；
 *   ② 非法值一律回退到该参数的默认值，**并且不抛异常** ——
 *      一条坏数据不该让整页渲染不出来（与 Store.normalizeField 同一套态度）。
 *
 * @param raw    原始对象（可能缺字段、类型错、来自旧版本）
 * @param forceKind  强制用这个 kind（新建时用），不传则读 raw.kind
 */
Sources.normalize = function (raw, forceKind) {
    var one = (raw && typeof raw === "object") ? raw : {};
    var kinds = sourceKeys(Sources.KINDS);
    var kind = sourceTrim(forceKind || one.kind);
    if (kinds.indexOf(kind) < 0) { kind = "anchor"; }

    var out = {
        id: sourceTrim(one.id) || Sources.newId(),
        kind: kind
    };

    var fields = Sources.FIELDS_OF[kind];

    for (var i = 0; i < fields.length; i++) {
        var name = fields[i];
        if (name === "lists") {
            var allowed = sourceKeys(Sources.LISTS);
            var picked = [];
            var rawLists = one.lists;
            if (rawLists instanceof Array) {
                for (var j = 0; j < rawLists.length; j++) {
                    if (allowed.indexOf(rawLists[j]) >= 0 && picked.indexOf(rawLists[j]) < 0) {
                        picked.push(rawLists[j]);
                    }
                }
            }
            /* 一个都不选 = 这条取材取不到任何人。回退成"粉丝列表"而不是留空：
             * 留空会让界面出现一条**永远跑不出结果**的取材，而用户看不出为什么。 */
            if (picked.length === 0) { picked.push("fans"); }
            out.lists = picked;
        } else if (name === "searchType") {
            out.searchType = sourceKeys(Sources.SEARCH_TYPES).indexOf(one.searchType) >= 0
                ? one.searchType : "users";
        } else if (name === "videoSource") {
            out.videoSource = sourceKeys(Sources.VIDEO_SOURCES).indexOf(one.videoSource) >= 0
                ? one.videoSource : "screen";
        } else if (name === "keyword" || name === "videoKeyword") {
            out[name] = withDefault(one[name], "fashion");
        } else if (name === "path") {
            out.path = withDefault(one.path, Store.TEXT_DIR + "/uid_list.txt");
        } else if (name === "anchors") {
            /* 账号可以留空：留空 = 不限定、从当前屏幕的列表直接抓。
             * 这是真实且合理的状态，所以不塞假默认值（与 Store 里 anchorIds 同一套规则）。 */
            out.anchors = sourceTrim(one.anchors);
        }
    }

    /* 深度：screen 起点没有展开这一说；其余非法值一律回退"不展开" */
    out.expand = "";
    if (Sources.canExpand(kind)) {
        var expands = sourceKeys(Sources.EXPANDS);
        if (expands.indexOf(one.expand) >= 0) { out.expand = one.expand; }
    }

    return out;
};

/* ------------------------------------------------------------ 读写 */

function sourceStorage() {
    return storages.create(Sources.STORAGE_NAME);
}

/**
 * 读全部取材（按顺序）。
 *
 * 读不出来 → 空数组（一条坏数据不该让整个界面起不来）；
 * 超过 MAX → 截断（旧版本可能存过更多条）。
 */
Sources.list = function () {
    var raw = null;
    try {
        raw = sourceStorage().get(Sources.STORAGE_KEY, null);
    } catch (e) {
        console.log("[sources] 读取失败: " + e);
    }
    if (typeof raw === "string" && raw.length > 0) {
        try {
            raw = JSON.parse(raw);
        } catch (e2) {
            console.log("[sources] JSON 解析失败，按空处理");
            raw = null;
        }
    }
    if (!(raw instanceof Array)) { return []; }

    var out = [];
    for (var i = 0; i < raw.length && out.length < Sources.MAX; i++) {
        if (raw[i] && typeof raw[i] === "object") {
            out.push(Sources.normalize(raw[i]));
        }
    }
    return out;
};

Sources.save = function (list) {
    var safe = (list instanceof Array) ? list.slice(0, Sources.MAX) : [];
    try {
        sourceStorage().put(Sources.STORAGE_KEY, JSON.stringify(safe));
        return true;
    } catch (e) {
        console.log("[sources] 保存失败: " + e);
        return false;
    }
};

/* ------------------------------------------------------------ 增删改 */

/** 按 id 取一条（界面每次操作都重新读，避免拿渲染时的旧快照覆盖新值）。 */
Sources.find = function (id) {
    var list = Sources.list();
    for (var i = 0; i < list.length; i++) {
        if (list[i].id === id) { return list[i]; }
    }
    return null;
};


Sources.isEmpty = function () {
    return Sources.list().length === 0;
};

Sources.count = function () {
    return Sources.list().length;
};

/** 追加一条（同时告诉调用方成不成 —— 满了就不该静默失败）。 */
Sources.add = function (kind) {
    var list = Sources.list();
    if (list.length >= Sources.MAX) { return null; }
    var one = Sources.normalize({ kind: kind || "anchor" });
    list.push(one);
    Sources.save(list);
    return one;
};

/**
 * 改一条。`patch` 只合入传进来的键，其余保持。
 *
 * 注意：**改 kind 要重新归一化**（新起点不该继承旧起点的参数）——
 * 所以这里走 normalize(patch 合并后, 新 kind)，而不是简单 assign。
 */
Sources.update = function (id, patch) {
    var list = Sources.list();
    for (var i = 0; i < list.length; i++) {
        if (list[i].id !== id) { continue; }
        var merged = {};
        var k;
        for (k in list[i]) {
            if (list[i].hasOwnProperty(k)) { merged[k] = list[i][k]; }
        }
        for (k in patch) {
            if (patch.hasOwnProperty(k)) { merged[k] = patch[k]; }
        }
        merged.id = id;
        list[i] = Sources.normalize(merged, merged.kind);
        Sources.save(list);
        return list[i];
    }
    return null;
};

/**
 * 删第 index 条。
 *
 * 用**下标**而不是 id：界面是按顺序渲染的，用户点的就是"第几条"。
 * 删除后其余条目自动前移，不需要重排 id。
 */
Sources.removeAt = function (index) {
    var list = Sources.list();
    if (index < 0 || index >= list.length) { return false; }
    list.splice(index, 1);
    Sources.save(list);
    return true;
};

Sources.clear = function () {
    try {
        sourceStorage().remove(Sources.STORAGE_KEY);
    } catch (e) {
        console.log("[sources] 清空失败: " + e);
    }
};

/* ------------------------------------------------------------ 文案 */

/** 按 key 取中文名（找不到回退 key 本身 —— 显示 "zzz" 也比 "undefined" 强）。 */
function labelOf(table, key) {
    for (var i = 0; i < table.length; i++) {
        if (table[i].key === key) { return table[i].label; }
    }
    return key;
}

Sources.kindLabel = function (kind) { return labelOf(Sources.KINDS, kind); };
Sources.expandLabel = function (key) { return labelOf(Sources.EXPANDS, key); };

/**
 * 一条取材 → 一句话摘要。
 *
 * 用在两个地方：取材卡片的标题行（收起时也要看得出这条是干什么的）、
 * 以及运行记录里的「当前脚本」行（那里放不下一整段配置）。
 */
Sources.describe = function (one) {
    if (!one) { return ""; }
    var head = "";

    if (one.kind === "anchor") {
        var lists = [];
        for (var i = 0; i < one.lists.length; i++) {
            lists.push(labelOf(Sources.LISTS, one.lists[i]).replace("列表", ""));
        }
        var who = sourceTrim(one.anchors) === "" ? "当前屏幕的账号" : one.anchors.split("#")[0];
        head = who + " · " + lists.join("+");
    } else if (one.kind === "search") {
        head = (one.searchType === "videos" ? "视频作者" : "用户") + "「" + one.keyword + "」";
    } else if (one.kind === "video") {
        head = one.videoSource === "keyword"
            ? "评论区「" + one.videoKeyword + "」"
            : "当前屏幕的评论区";
    } else if (one.kind === "text") {
        var name = String(one.path).split("/").pop();
        head = "文本 " + name;
    } else {
        head = "当前屏幕";
    }

    if (one.expand) { head += " → " + labelOf(Sources.EXPANDS, one.expand).replace("再取", ""); }
    return head;
};

/**
 * 整份清单 → 一句话（任务卡与运行记录用）。
 * 空清单返回空串，由调用方决定显示「未配置」还是别的东西。
 */
Sources.summary = function () {
    var list = Sources.list();
    if (list.length === 0) { return ""; }
    if (list.length === 1) { return Sources.describe(list[0]); }
    return Sources.describe(list[0]) + " 等 " + list.length + " 条";
};

/* ------------------------------------------------------------ 旧配置迁移 */

/** 读 Store 那份 sourceStorage 的**原始** JSON（含 v8 之前的四张卡字段）。 */
function readLegacyConfig() {
    try {
        var raw = storages.create(Store.STORAGE_NAME).get(Store.STORAGE_KEY, null);
        if (typeof raw === "string" && raw.length > 0) { return JSON.parse(raw); }
        if (raw && typeof raw === "object") { return raw; }
    } catch (e) {
        console.log("[sources] 读取旧配置失败: " + e);
    }
    return null;
}

function readPathSafe(obj, path) {
    var segs = String(path).split(".");
    var node = obj;
    for (var i = 0; i < segs.length; i++) {
        if (node === null || typeof node !== "object") { return undefined; }
        node = node[segs[i]];
    }
    return node;
}

/**
 * 旧「进入页面」→ 新的「取哪些列表」。
 *
 * `comment` 没有对应：在"从一个账号取它哪个列表"这个语义下，账号页没有"评论页"。
 * 这是 v6 遗留的一处语义模糊，迁移时回退成粉丝列表并记一条日志 ——
 * 用户的意图在 v8 里可以用「某个视频的评论区」这条取材重新表达。
 */
function listsFromEnterPage(value) {
    if (value === "follow") { return ["following"]; }
    if (value === "home") { return ["home"]; }
    if (value === "comment") {
        console.log("[sources] 旧「进入页面=评论页」在取材清单里没有对应，已按「粉丝列表」迁移");
        return ["fans"];
    }
    return ["fans"];
}

/**
 * v7 → v8：把"四张卡里选了一张"翻译成取材清单。**一次性**。
 *
 * 三条原则：
 *   ① **已有清单就不动** —— 用户自己加的取材永远不被覆盖（重装/降级都安全）；
 *   ② **能展开成多条就展开** —— 脚本四的三个开关本来就是三种取材范围，
 *      旧结构只能勾在同一个脚本里，新结构下它们天然是三条独立取材；
 *   ③ 超出 `MAX` 要截断并**说出来**，不静默丢。
 *
 * @returns 迁移后的清单；没得迁移（没旧配置 / 已有清单 / 旧配置一条都没选）返回 null
 */
Sources.migrateLegacy = function () {
    if (Sources.list().length > 0) { return null; }

    var raw = readLegacyConfig();
    if (!raw) { return null; }

    var scripts = readPathSafe(raw, "tabs.id.scripts") || {};
    var items = [];

    /* —— 脚本一：主播账号 + 可选的"搜索用户"和"文本" —— */
    var s1 = scripts.s1 || {};
    if (s1.checked) {
        items.push({
            kind: "anchor",
            anchors: s1.anchorIds || "",
            lists: listsFromEnterPage(s1.enterPage),
            expand: ""
        });
        if (s1.useTextId) {
            items.push({ kind: "text", path: s1.textIdPath, expand: "" });
        }
        if (s1.customPage) {
            items.push({
                kind: "search",
                searchType: "users",
                keyword: s1.customPageKeyword || "",
                expand: ""
            });
        }
    }

    /* —— 脚本二：评论区（+ 可选展开评论者的粉丝） —— */
    var s2 = scripts.s2 || {};
    if (s2.checked) {
        items.push({
            kind: "video",
            videoSource: s2.videoSource || "screen",
            videoKeyword: s2.videoKeyword || "",
            expand: s2.commenterFans ? "fans" : ""
        });
    }

    /* —— 脚本三：文本裂变（旧"进入页面"就是它的展开方向） —— */
    var s3 = scripts.s3 || {};
    if (s3.checked) {
        items.push({
            kind: "text",
            path: s3.fissionTextPath,
            expand: (s3.enterPage === "follow") ? "following" : "fans"
        });
    }

    /* —— 脚本四：三个开关展开成三条取材（旧结构塞不下，新结构天然支持） —— */
    var s4 = scripts.s4 || {};
    if (s4.checked) {
        var kw = s4.keyword || "";
        items.push({
            kind: "search",
            searchType: "videos",
            keyword: kw,
            expand: s4.anchorFans ? "fans" : ""
        });
        if (s4.commentArea) {
            items.push({ kind: "video", videoSource: "keyword", videoKeyword: kw, expand: "" });
        }
        if (s4.commenterFans) {
            items.push({ kind: "video", videoSource: "keyword", videoKeyword: kw, expand: "fans" });
        }
    }

    if (items.length === 0) { return null; }

    if (items.length > Sources.MAX) {
        console.log("[sources] 旧配置翻译出 " + items.length + " 条取材，超过上限 " +
                    Sources.MAX + " 条，已截断（多出来的取材可在界面重新添加）");
        items = items.slice(0, Sources.MAX);
    }

    var list = [];
    for (var i = 0; i < items.length; i++) {
        list.push(Sources.normalize(items[i]));
    }
    Sources.save(list);
    return list;
};


/* ============================== src/device.js ============================== */
/* ============================== src/device.js ==============================
 * 设备数据获取层。
 *
 * 界面上的每一项「状态」都来自这里，而不是写死的假数据：
 *   无障碍 / 悬浮窗 / 通知 权限、TikTok 是否安装与版本号、屏幕尺寸、脚本版本。
 *
 * 设计原则（规范 R25「设备端危险能力必须显式声明依赖，不作为主路径」）：
 *   本文件所有探测都必须能在「能力缺失」时给出 false / 空值，绝不抛出去。
 *   AutoX 没有 try-catch 之外的门禁，一次未捕获异常就会让整个界面起不来。
 */

var Device = {};

/* TikTok 有多个发行包名，挨个探测；顺序即优先级。 */
Device.TIKTOK_PACKAGES = [
    "com.zhiliaoapp.musically",
    "com.ss.android.ugc.trill",
    "com.zhiliaoapp.musically.go"
];

/** 通用取值包装：任何异常都退化为 fallback，并留一条日志便于定位。 */
function probe(tag, fn, fallback) {
    try {
        var value = fn();
        return value === undefined || value === null ? fallback : value;
    } catch (e) {
        console.log("[device] " + tag + " 探测失败: " + e);
        return fallback;
    }
}

/* ------------------------------------------------------------ 屏幕与栏位 */

Device.screenWidth = function () {
    return probe("screenWidth", function () { return device.width; }, 375);
};

Device.screenHeight = function () {
    return probe("screenHeight", function () { return device.height; }, 812);
};

/** 系统状态栏高度。取不到时用 24dp 兜底，保证内容不被状态栏压住。 */
Device.statusBarHeight = function () {
    return probe("statusBarHeight", function () {
        var res = context.getResources();
        var id = res.getIdentifier("status_bar_height", "dimen", "android");
        return id > 0 ? res.getDimensionPixelSize(id) : U.dp(24);
    }, U.dp(24));
};

/** 底部导航栏高度。全面屏手势机型会返回 0，此时由「安全区」常量兜底。 */
Device.navBarHeight = function () {
    return probe("navBarHeight", function () {
        var res = context.getResources();
        var id = res.getIdentifier("navigation_bar_height", "dimen", "android");
        return id > 0 ? res.getDimensionPixelSize(id) : 0;
    }, 0);
};

/* ------------------------------------------------------------ 权限状态 */

/**
 * 无障碍服务。AutoX 里 auto.service 为 null 即表示未连接。
 * 这是本 App 的硬依赖——没有它就点不动 TikTok，所以权限弹窗首行必须显示它。
 */
Device.a11yEnabled = function () {
    return probe("a11y", function () { return auto.service !== null; }, false);
};

/** 悬浮窗权限。用于运行时浮层提示，缺失不影响主流程。 */
Device.overlayEnabled = function () {
    return probe("overlay", function () { return floaty.checkPermission(); }, false);
};

/**
 * 通知权限。Android 13(API 33) 起 POST_NOTIFICATIONS 是运行时权限，
 * 13 以下默认授予——不能统一按「未授予」处理，否则老机型会误报。
 */
Device.notifyEnabled = function () {
    return probe("notify", function () {
        var sdk = parseInt(android.os.Build.VERSION.SDK, 10);
        if (isNaN(sdk) || sdk < 33) { return true; }
        var granted = context.checkSelfPermission("android.permission.POST_NOTIFICATIONS");
        return granted === android.content.pm.PackageManager.PERMISSION_GRANTED;
    }, true);
};

/**
 * 权限弹窗的展示数据，界面直接渲染，不在页面里重复拼装。
 *
 * 两条约定（设计稿 02 与 12 必须完全一致）：
 *   ① 顺序固定为 无障碍服务 → 悬浮窗权限 → 通知权限；
 *   ② 通知标 optional —— 它只在任务完成时提醒你，缺了不影响脚本执行，
 *      所以既排在最后、也不参与「能不能开始运行」的判定。
 *      （早先它既没标可选、又排在悬浮窗前面，用户会以为必须开。）
 */
Device.permissionRows = function () {
    return [
        { key: "a11y",    name: "无障碍服务", granted: Device.a11yEnabled() },
        { key: "overlay", name: "悬浮窗权限", granted: Device.overlayEnabled() },
        { key: "notify",  name: "通知权限",   granted: Device.notifyEnabled(), optional: true }
    ];
};

Device.allPermissionsGranted = function () {
    var rows = Device.permissionRows();
    for (var i = 0; i < rows.length; i++) {
        if (!rows[i].granted) { return false; }
    }
    return true;
};

/**
 * 「能不能开始运行」只取决于这两个。
 * 与 allPermissionsGranted 分开是必要的：通知是可选权限，
 * 用它拦人会让用户被一个不影响执行的权限挡在门外。
 */
Device.blockingPermissionsGranted = function () {
    return Device.a11yEnabled() && Device.overlayEnabled();
};

/**
 * 打开对应权限的设置页。
 * 用标准 ACTION 常量而不是猜 Activity 名——猜错会抛 ActivityNotFound。
 * 无障碍与悬浮窗没有公开的直跳 Action，退回「应用详情页」这个一定存在的入口。
 */
Device.openPermissionSettings = function (key) {
    var pkg = context.getPackageName();
    var activity = null;
    var action = null;
    try {
        if (key === "a11y") {
            action = "android.settings.ACCESSIBILITY_SETTINGS";
        } else if (key === "overlay") {
            action = "android.settings.action.MANAGE_OVERLAY_PERMISSION";
        } else if (key === "notify") {
            action = "android.settings.APP_NOTIFICATION_SETTINGS";
        }
        if (action) {
            var intent = new android.content.Intent(action);
            if (key === "overlay") {
                intent.setData(android.net.Uri.parse("package:" + pkg));
            } else {
                intent.putExtra("package", pkg);
                intent.putExtra("android.provider.extra.APP_PACKAGE", pkg);
            }
            activity = intent;
        }
    } catch (e) {
        console.log("[device] 构造权限 Intent 失败: " + e);
        activity = null;
    }

    if (!activity) {
        /* 兜底：应用详情页。所有 Android 版本都有。 */
        activity = new android.content.Intent(
            "android.settings.APPLICATION_DETAILS_SETTINGS",
            android.net.Uri.parse("package:" + pkg)
        );
    }

    return probe("openPermission", function () {
        context.startActivity(activity);
        return true;
    }, false);
};

/* ------------------------------------------------------------ TikTok 状态 */

/** 探测 TikTok 是否安装及版本。返回 { installed, packageName, versionName }。 */
Device.tiktok = function () {
    var found = { installed: false, packageName: "", versionName: "" };
    for (var i = 0; i < Device.TIKTOK_PACKAGES.length; i++) {
        var name = Device.TIKTOK_PACKAGES[i];
        var info = probe("pkg:" + name, function () {
            return context.getPackageManager().getPackageInfo(name, 0);
        }, null);
        if (info) {
            found.installed = true;
            found.packageName = name;
            found.versionName = info.versionName || "";
            break;
        }
    }
    if (found.installed) {
        console.log("[device] TikTok 已安装 " + found.packageName + " v" + found.versionName);
    } else {
        console.log("[device] 未探测到 TikTok 客户端");
    }
    return found;
};

/** 版本号归一化：设计稿展示成 v39.5.4 这种形态。 */
Device.formatVersion = function (versionName) {
    var v = String(versionName || "").trim();
    if (!v) { return ""; }
    return v.charAt(0) === "v" ? v : "v" + v;
};

/* ------------------------------------------------------------ 文件选择 */

/** 文本文件的候选目录。只扫这几处，不做全盘遍历（全盘扫在真机上要几十秒）。 */
Device.TEXT_DIRS = ["/sdcard/Download", "/sdcard/Documents", "/sdcard/tiktok_data", "/sdcard"];

/**
 * 列出可选的文本文件，供「选择文件」按钮弹列表用。
 *
 * 这里刻意**只负责列出、不负责弹窗**：展示交给 UI 层（`W.filePicker` + `Dialog.choose`）。
 * 一来设备层不该依赖弹窗组件，二来 `dialogs.select` 这类阻塞式调用在 UI 模式下
 * 拿不到返回值，选文件会静默失效。
 *
 * 只扫几个约定目录，不做全盘遍历——全盘扫在真机上要几十秒。
 */
Device.listTextFiles = function () {
    var out = [];
    var seen = {};
    for (var i = 0; i < Device.TEXT_DIRS.length; i++) {
        var dir = Device.TEXT_DIRS[i];
        var names = probe("ls:" + dir, function () { return files.listDir(dir); }, []);
        for (var j = 0; j < names.length; j++) {
            var name = names[j];
            if (!/\.(txt|json|csv)$/i.test(name)) { continue; }
            var full = dir + "/" + name;
            if (seen[full]) { continue; }
            seen[full] = true;
            out.push(full);
        }
    }
    out.sort();
    return out;
};

/* ------------------------------------------------------------ 应用信息 */

Device.appVersionName = function () {
    return probe("appVersion", function () {
        return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;
    }, "-");
};

Device.deviceLabel = function () {
    return probe("deviceLabel", function () {
        return android.os.Build.MODEL + " / Android " + android.os.Build.VERSION.RELEASE;
    }, "-");
};


/* ============================== src/service.js ============================== */
/* ============================== src/service.js ==============================
 * 需要「服务端」的业务能力：卡密校验、检查更新。
 *
 * 这两件事的共同点是：真实场景必须联网核验，但**离线也必须能给出确定行为**。
 * 所以每个能力都是「远端优先 + 本地降级」，且降级模式会在界面上如实标注，
 * 不会把本地通过伪装成服务端通过（规范：不编造测试结果/接口字段）。
 *
 * ⚠️ 本地模式的定位必须说清楚：
 *   仅校验格式，不具备防伪能力。要真防伪，把 CONFIG.licenseEndpoint
 *   指向你自己的校验接口即可——请求/响应结构见 verifyRemote() 注释。
 */

var Service = {};

Service.CONFIG = {
    /* 留空 = 本地模式。填写后 login() 会先请求远端。 */
    licenseEndpoint: "",
    licenseTimeoutMs: 8000,
    /* 本地模式下的默认有效期（天），仅用于让「到期时间」这一栏有真实含义。 */
    localTrialDays: 30,
    /* 检查更新的清单地址，留空则用内置版本号自比。 */
    updateEndpoint: ""
};

/** 脚本版本。设计稿的「版本信息卡」显示的就是它；build.js 会用构建日期覆盖。 */
Service.SCRIPT_VERSION = "2026.10.13";

Service.CHANGELOG = [
    "2026.10.11  数量类设置全部改为「最小值 ~ 最大值」区间（关注/私信/休息/浏览/单次/停止/间隔）",
    "2026.10.11  补齐登录页 / 运行状态条 / 拦截弹窗，ID提取页改单选",
    "2026.10.10  界面层按设计稿重构，配置项全部落盘",
    "2026.10.03  接入设备真实状态（权限 / TikTok 版本）",
    "2026.09.28  首个可运行版本"
];

/* ---------------------------------------------------------------- 卡密 */

/** 去掉空格与连字符并转大写，得到比较用的规范形式。 */
Service.normalizeCode = function (code) {
    return String(code || "").replace(/[\s-]/g, "").toUpperCase();
};

/**
 * 格式校验：16 位大写字母或数字。
 * 只做形态校验——真伪必须靠服务端，本地无法判定一个随机串是不是有效卡密。
 */
Service.isWellFormed = function (code) {
    return /^[A-Z0-9]{16}$/.test(Service.normalizeCode(code));
};

/** 展示用分组：ABCDEFGHIJKLMNOP → ABCDE-FGHI-JKLM-NOPQ 形态的 4 组。 */
Service.formatCode = function (code) {
    var n = Service.normalizeCode(code);
    var out = [];
    for (var i = 0; i < n.length; i += 4) { out.push(n.substring(i, i + 4)); }
    return out.join("-");
};

function httpPostJson(url, payload) {
    var body = JSON.stringify(payload);
    var response = http.post(url, body, {
        headers: { "Content-Type": "application/json" },
        timeout: Service.CONFIG.licenseTimeoutMs
    });
    if (!response || response.statusCode !== 200) {
        return null;
    }
    try {
        return JSON.parse(response.body.string());
    } catch (e) {
        console.log("[service] 卡密响应不是合法 JSON");
        return null;
    }
}

/**
 * 远端校验。
 * 请求：POST {endpoint}  {"code":"<规范化卡密>"}
 * 响应：{"ok":true,"expireAt":"2026-11-09"} 或 {"ok":false,"reason":"卡密不存在"}
 * 返回 null 表示「没问到」（网络/格式问题），调用方据此决定是否降级为本地模式。
 */
Service.verifyRemote = function (code) {
    if (!Service.CONFIG.licenseEndpoint) { return null; }
    var data = null;
    try {
        data = httpPostJson(Service.CONFIG.licenseEndpoint, { code: code });
    } catch (e) {
        console.log("[service] 卡密远端校验异常: " + e);
        return null;
    }
    if (!data) { return null; }
    return {
        ok: !!data.ok,
        expireAt: data.expireAt || "",
        reason: data.reason || "卡密无效"
    };
};

/** 今天 + N 天，格式 yyyy-MM-dd。用于本地模式生成到期时间。 */
Service.datePlusDays = function (days) {
    var now = new Date();
    now.setDate(now.getDate() + Number(days || 0));
    var m = now.getMonth() + 1;
    var d = now.getDate();
    return now.getFullYear() + "-" + (m < 10 ? "0" + m : m) + "-" + (d < 10 ? "0" + d : d);
};

Service.today = function () {
    return Service.datePlusDays(0);
};

/** 过期判定：只比日期字符串（yyyy-MM-dd 字典序即时间序），不引时区计算。 */
Service.isExpired = function (expireAt) {
    if (!expireAt) { return false; }
    return Service.today() > String(expireAt);
};

/**
 * 登录。返回 { ok, status, message }。
 * status: "active" | "expired" | "none"
 */
Service.login = function (code) {
    var normalized = Service.normalizeCode(code);
    if (!Service.isWellFormed(normalized)) {
        return { ok: false, status: "none", message: "卡密格式不对，应为 16 位字母或数字" };
    }

    var remote = Service.verifyRemote(normalized);
    if (remote) {
        if (!remote.ok) {
            return { ok: false, status: "none", message: remote.reason };
        }
        if (Service.isExpired(remote.expireAt)) {
            return { ok: false, status: "expired", message: "该卡密已于 " + remote.expireAt + " 到期" };
        }
        return {
            ok: true,
            status: "active",
            code: normalized,
            expireAt: remote.expireAt,
            message: "登录成功（服务端核验）"
        };
    }

    /* 本地模式：只有格式校验，如实告知，不伪装成服务端通过。 */
    return {
        ok: true,
        status: "active",
        code: normalized,
        expireAt: Service.datePlusDays(Service.CONFIG.localTrialDays),
        message: "登录成功（本地模式，未联网核验）"
    };
};

/** 读当前卡密状态，并顺手处理「已过期但状态还写着 active」的情况。 */
Service.licenseStatus = function () {
    var status = Store.getEnum("license.status", "licenseStatus");
    var expireAt = Store.getText("license.expireAt");
    var code = Store.getText("license.code");

    if (status === "active" && Service.isExpired(expireAt)) {
        Store.set("license.status", "expired");
        status = "expired";
    }

    return { status: status, code: code, expireAt: expireAt };
};

/**
 * 状态 → 界面文案与配色 key。集中在这里，避免页面各自判断。
 *
 * ⚠️ 返回值里必须带 `status` —— 页面除了文案还要按状态分支
 * （已登录才显示「解绑」，否则显示「去登录」）。
 * 早先只返回 text/tone/expireAt，页面写 `display.status === "active"` 永远是 false，
 * 结果是「已登录」旁边挂着「去登录」，自相矛盾但没有任何报错。
 */
Service.licenseDisplay = function () {
    var st = Service.licenseStatus();
    if (st.status === "active") {
        return { status: st.status, text: "已登录", tone: "ok", expireAt: st.expireAt || "—" };
    }
    if (st.status === "expired") {
        return { status: st.status, text: "已过期", tone: "warn", expireAt: st.expireAt || "—" };
    }
    return { status: st.status, text: "未登录", tone: "warn", expireAt: "—" };
};

Service.logout = function () {
    Store.set("license.status", "none");
    Store.set("license.code", "");
    Store.set("license.expireAt", "");
};

/* ---------------------------------------------------------------- 更新 */

/**
 * 检查更新。远端不可达时退化为「与内置版本号自比」，
 * 结论同样如实标注来源，避免把「没连上」说成「已是最新」。
 */
Service.checkUpdate = function () {
    var current = Service.SCRIPT_VERSION;
    if (Service.CONFIG.updateEndpoint) {
        var data = null;
        try {
            var response = http.get(Service.CONFIG.updateEndpoint, { timeout: 8000 });
            if (response && response.statusCode === 200) {
                data = JSON.parse(response.body.string());
            }
        } catch (e) {
            console.log("[service] 检查更新失败: " + e);
        }
        if (data && data.version) {
            return {
                latest: String(data.version),
                hasUpdate: String(data.version) > current,
                source: "remote",
                note: data.note || ""
            };
        }
        return { latest: current, hasUpdate: false, source: "unknown", note: "检查失败，请稍后重试" };
    }
    return { latest: current, hasUpdate: false, source: "local", note: "已是最新" };
};


/* ============================== src/fingerprint.js ============================== */
/**
 * fingerprint.js — 配置指纹（界面侧）
 *
 * ★ **逐字节同算法的一份拷贝**，源头在 `tiktok-auto/src/fingerprint.js`。
 *
 * 为什么必须有两份：界面要在"点继续之前"就判断断点还有没有效（不折腾用户手机），
 * 引擎要在"启动 App 之前"再判断一次（用户也可能直接改配置手起引擎）。
 * 项目没有共享模块机制，只能各放一份。
 *
 * **改算法必须两边一起改**：两侧算出的指纹不同 = 界面说"能续跑"、引擎说"配置变了"。
 * `tiktok-auto/tools/pc-selftest-id.js` 有一组断言专门比对两份实现的结果。
 */
var Fingerprint = (function () {
    'use strict';

    var VERSION = 1;

    /**
     * 是不是数组。
     *
     * 不用 `v instanceof Array`：跨 realm（PC 自检把 Node 造的对象喂进 vm 沙箱）时
     * `instanceof` 会返回 false，那会让"数组"被当成普通对象序列化，两边算出的指纹就不一样了。
     *
     * 也不用 `toString` 配 `Function.prototype.call` 的写法：那个关键字加左括号
     * 命中 MCP 危险调用黑名单（`tools/build.js` 的 `DANGEROUS_RULES`），会让每次下发都要人工确认。
     * 优先 `Array.isArray`（ES5，AutoX 的 Rhino 支持），没有时退回 `.apply`。
     */
    function isArray(v) {
        if (typeof Array.isArray === 'function') {
            return Array.isArray(v);
        }
        return Object.prototype.toString.apply(v, []) === '[object Array]';
    }

    /** 自有键，排序后返回（键序无关 → 同一份配置换个键序不会让断点失效） */
    function ownKeys(v) {
        var keys = [];
        for (var k in v) {
            if (Object.prototype.hasOwnProperty.apply(v, [k]) === true) {
                keys.push(k);
            }
        }
        keys.sort();
        return keys;
    }

    /**
     * 稳定序列化：对象按键名排序、数组保持顺序、每个值带类型前缀。
     *
     * 类型前缀是必须的 —— 否则 `"1"`（字符串）和 `1`（数字）会序列化成同一个串，
     * 而界面上"粉丝下限"这类字段确实可能一个是空串一个是 0。
     */
    function canon(v) {
        if (v === null || v === undefined) {
            return 'n';
        }
        if (isArray(v)) {
            var parts = [];
            for (var i = 0; i < v.length; i += 1) {
                parts.push(canon(v[i]));
            }
            return '[' + parts.join(',') + ']';
        }
        if (typeof v === 'object') {
            var keys = ownKeys(v);
            var out = [];
            for (var j = 0; j < keys.length; j += 1) {
                out.push(keys[j] + ':' + canon(v[keys[j]]));
            }
            return '{' + out.join(',') + '}';
        }
        if (typeof v === 'number') {
            return 'd' + String(v);
        }
        if (typeof v === 'boolean') {
            return v ? 'T' : 'F';
        }
        return 's' + JSON.stringify(String(v));
    }

    /**
     * djb2-xor 摘要。
     *
     * 末尾拼上原文长度：32 位散列碰撞概率本来就不高，加个长度等于多一维区分，
     * 而且是"免费"的（长度本来就要算）。输出是 base36，比十六进制短。
     */
    function digest(text) {
        var s = String(text);
        var h = 5381;
        for (var i = 0; i < s.length; i += 1) {
            h = (((h << 5) + h) ^ s.charCodeAt(i)) | 0;   /* |0 截成 32 位，避免精度丢失 */
        }
        return (h >>> 0).toString(36) + '-' + s.length.toString(36);
    }

    /** 把一条取材归一化成"只含参与指纹的字段"，缺项补默认 */
    function ofSource(one, index) {
        var s = one || {};
        return {
            key: s.key || ('i' + index + ':' + (s.kind || '')),
            kind: s.kind || '',
            anchors: s.anchors || '',
            lists: isArray(s.lists) ? s.lists : [],
            searchType: s.searchType || '',
            keyword: s.keyword || '',
            videoSource: s.videoSource || '',
            videoKeyword: s.videoKeyword || '',
            path: s.path || '',
            expand: s.expand || ''
        };
    }

    /**
     * 算 `id` 段的指纹。
     *
     * **分项存**（sources / filter / output 各一份）而不只存一个总串：
     * 界面要能说清"是**取材**改过了"而不是含糊的"配置变了"，用户才知道该改回去什么。
     *
     * @param id `config.id` 整段（界面传 `Engine.buildIdConfig().config.id`，
     *           引擎传解析后的 `config.id` —— 两者是同一份数据）
     */
    function ofIdSection(id) {
        var section = id || {};

        var list = isArray(section.sources) ? section.sources : [];
        var sources = [];
        for (var i = 0; i < list.length; i += 1) {
            sources.push(ofSource(list[i], i));
        }

        var f = section.filter || {};
        var o = section.output || {};

        var sourcesHash = digest(canon(sources));
        var filterHash = digest(canon({
            private: f.private === true,
            noAvatar: f.noAvatar === true,
            langRegion: f.langRegion || 'any',
            nicknameCheck: f.nicknameCheck || 'any',
            follow: f.follow || {},
            fans: f.fans || {},
            likes: f.likes || {}
        }));
        var outputHash = digest(canon({
            dir: o.dir || '',
            historyPath: o.historyPath || '',
            dedupeHistory: o.dedupeHistory !== false
        }));

        return {
            v: VERSION,
            sources: sourcesHash,
            filter: filterHash,
            output: outputHash,
            all: digest(sourcesHash + filterHash + outputHash)
        };
    }

    /**
     * 比两份指纹。
     * @returns { same, changed: ['sources'|'filter'|'output'] }
     */
    function compare(a, b) {
        if (!a || !b || a.v !== VERSION || b.v !== VERSION) {
            return { same: false, changed: ['sources', 'filter', 'output'] };
        }
        var changed = [];
        if (a.sources !== b.sources) {
            changed.push('sources');
        }
        if (a.filter !== b.filter) {
            changed.push('filter');
        }
        if (a.output !== b.output) {
            changed.push('output');
        }
        return { same: changed.length === 0, changed: changed };
    }

    return {
        VERSION: VERSION,
        canon: canon,
        digest: digest,
        ofIdSection: ofIdSection,
        compare: compare
    };
}());


/* ============================== src/engine.js ============================== */
/* ============================== src/engine.js ==============================
 * 执行引擎桥接：把界面收集的配置交给 tiktok-auto，再把它的进度读回来。
 *
 * ## 为什么走文件，不走内存
 * 界面与被唤起的引擎是**两个独立的 ScriptEngine**：各有各的全局作用域，
 * 界面里的对象传不过去（实测确认）。所以两边只通过约定好的四个文件说话：
 *
 *   run-config.json     界面 → 人/追溯：完整配置快照（人可读）
 *   engine-config.json  界面 → 引擎：映射后的引擎配置
 *   run-state.json      引擎 → 界面：进度与终态
 *   stop.flag           界面 → 引擎：停止请求（内容是本次运行的 runId）
 *
 * 文件通道是**异步**的，所以界面这边的规则是：**所有动作以状态文件的回报为准**，
 * 而不是"我点了就当我做了"。点「停止运行」后界面显示"正在收尾"、
 * 等到引擎真的上报 stopped 才切回未运行 —— 否则界面说"已停止"而 TikTok 还在自己动，
 * 用户不知道该信谁。
 *
 * ## 为什么不删 stop.flag
 * 停止靠**比内容**而不是靠"文件在不在"：只有内容等于本次 runId 才算数。
 * 于是不必删除它（删除既有竞态，`files.remove` 又命中 MCP 危险调用黑名单），
 * 上一轮残留的标志也不会误杀下一轮。
 *
 * ## 能力边界要如实说
 * tiktok-auto 目前实现的是「搜索 → 逐个看 → 评论」。界面「执行操作」里的
 * 关注 / 私信 / 点赞**尚未接入**，`buildConfig()` 会把它们逐条记进 notes，
 * 由调用方决定怎么告知用户 —— **绝不静默忽略**：
 * 用户勾了点赞却什么都没发生，比明确告知"尚未支持"糟得多。
 */

var Engine = {};

Engine.DIR = "/sdcard/tiktok_app";
Engine.CONFIG_PATH = Engine.DIR + "/engine-config.json";
Engine.STATE_PATH = Engine.DIR + "/run-state.json";
Engine.STOP_FLAG_PATH = Engine.DIR + "/stop.flag";

/**
 * 引擎的日志文件（jsonl，一行一条）。
 *
 * 2026-10-13 新增：D3 运行详情里的「执行日志」要看的就是它。
 * 为什么走文件而不是读 console：引擎是**另一个 ScriptEngine**，
 * 它的 stdout 界面根本读不到（见本文件头的通道说明）。
 * 引擎侧由 `logger.setSink` → `files.append` 落盘（tiktok-auto/src/bridge.js）。
 */
Engine.LOG_PATH = Engine.DIR + "/run-log.jsonl";

/** 一条记录最多带走多少行日志（记录要落盘，不能让日志把它撑爆）。 */
Engine.LOG_MAX_LINES = 200;

/** 引擎产物在项目里的相对位置（项目模式下从这个位置找） */
Engine.SCRIPT_RELATIVE = "tiktok-auto/dist/tiktok-auto.js";

/** 本次运行的标识。由界面生成并同时告诉引擎与停止标志，三方比对。 */
Engine.RUN_ID = "";

/** 上次定位到的引擎产物路径；null 表示还没找过 */
Engine.scriptPath = null;

/**
 * 是否**确实在引擎列表里见过**子引擎。
 *
 * 用途唯一：给"引擎没写终态就没了"的兜底判定加一道保险。
 * `engines.all()` 在不同运行时里的可见性不完全一致 —— 如果它从来就不报告子引擎，
 * 那"看不到子引擎"这件事毫无信息量，此时宁可不判定，也不要误把正在跑的运行结束掉。
 */
Engine.sawChild = false;

/* ------------------------------------------------------------ 运行标识 */

/**
 * 生成本次运行的标识。
 * 用「时间戳 + 随机串」：同一秒内连点两次也不会撞，
 * 而且人在日志里一眼能看出这是哪一次运行。
 */
Engine.newRunId = function () {
    return "run-" + Date.now() + "-" + Math.floor(Math.random() * 100000);
};

/* ------------------------------------------------------------ 定位引擎 */

/** 探测用的候选路径，按「最可能正确」排序。 */
Engine.candidates = function () {
    var list = [];

    /* ① 入口脚本同级 —— 项目模式下最准。
     *    用 myEngine().source 而不是 files.cwd()：后者依赖运行方式，
     *    前者永远是入口脚本的真实路径。 */
    try {
        var source = String(engines.myEngine().source || "");
        var cut = source.lastIndexOf("/");
        if (cut > 0) {
            list.push(source.substring(0, cut) + "/" + Engine.SCRIPT_RELATIVE);
        }
    } catch (e) {
        /* 取不到就靠后面的候选 */
    }

    /* ② 扫一层项目目录：产物可能来自另一个项目文件夹 */
    try {
        var names = files.listDir("/sdcard/Scripts");
        for (var i = 0; i < names.length; i += 1) {
            var dir = "/sdcard/Scripts/" + names[i];
            if (files.isDir(dir)) {
                list.push(dir + "/" + Engine.SCRIPT_RELATIVE);
            }
        }
    } catch (e) {
        /* 没这个目录就跳过 */
    }

    /* ③ 扁平部署：产物被单独拷到 Download（手工推送时的常见形态） */
    list.push("/sdcard/Download/tiktok-auto.js");
    list.push(Engine.DIR + "/tiktok-auto.js");

    return list;
};

/**
 * 找到引擎产物。
 * @returns 路径；找不到返回空串（调用方负责给出可操作的提示）
 */
Engine.locate = function () {
    var list = Engine.candidates();
    for (var i = 0; i < list.length; i += 1) {
        try {
            if (files.exists(list[i])) {
                Engine.scriptPath = list[i];
                return list[i];
            }
        } catch (e) {
            /* 单个候选探测失败不该中断整轮查找 */
        }
    }
    Engine.scriptPath = null;
    return "";
};

/* ------------------------------------------------------------ 配置映射 */

function trimAll(text) {
    return String(text).replace(/^\s+|\s+$/g, "");
}

/**
 * 读文本文件的行，跳过空行与 `#` 开头的注释行。
 * 读不到（文件不存在 / 权限问题）时返回空数组 —— 调用方按"没配"处理。
 */
function readLines(path) {
    var out = [];
    try {
        if (!path || !files.exists(path)) { return out; }
        var lines = String(files.read(path)).split(/\r?\n/);
        for (var i = 0; i < lines.length; i += 1) {
            var text = trimAll(lines[i]);
            if (text !== "" && text.charAt(0) !== "#") { out.push(text); }
        }
    } catch (e) {
        console.log("[engine] 读取文本失败 " + path + ": " + e);
    }
    return out;
}

function randomInt(min, max) {
    var low = Math.floor(min);
    var high = Math.floor(max);
    if (high < low) { high = low; }
    return low + Math.floor(Math.random() * (high - low + 1));
}

/** 秒 → 毫秒，并给一个下限：0 秒会让"观看"立刻返回，等于没看 */
function seconds(ms) {
    return Math.max(1000, Math.floor(ms) * 1000);
}

/**
 * 界面配置 → 引擎配置。
 *
 * @param task 当前要跑的任务（`App.startRun` 传进来的那个对象，含 `task` 字段）
 * @returns { config, notes }
 *   notes 是「用户表达了意图、但引擎这次做不到」的条目，逐条是人话。
 */
Engine.buildConfig = function (task, opts) {
    /* 两条链路的配置形状完全不同（视频链路是"搜索→看→评"，ID提取是"取材清单"），
     * 所以在这里分派，而不是往一个函数里塞两套 if —— 那样两边都会变得难读且易改错。 */
    if (task && task.task === "id") {
        return Engine.buildIdConfig(opts);
    }
    return Engine.buildVideoConfig();
};

/* ------------------------------------------------------------ ID 提取 */

/** ID 提取的产物目录（与其它通道文件同根，方便一起清理/查看） */
Engine.ID_DIR = "/sdcard/Download/tiktok_app";

/**
 * 断点文件（ID提取的"跑到哪了"）。
 *
 * 与产物同目录：用户清产物时看得见它；而且它引用的是 runFile 的绝对路径，
 * 放在一起语义最直白。引擎侧同一份路径由 `id.resume.path` 传下去。
 */
Engine.ID_PROGRESS_PATH = Engine.ID_DIR + "/id_progress.json";

/**
 * 界面 → 引擎（task = 'id'）。
 *
 * ## 取材清单几乎是原样透传
 * `Sources` 模块当初就是**照着引擎侧的契约**设计的（`kind` + 每种起点的参数 + `expand`），
 * 所以这里不需要再翻译一遍字段名。少一层翻译就少一处"路径拼错=静默丢值"的机会。
 *
 * ## 做不到的项一律进 notes
 * 这是项目一贯的规矩：用户勾了却什么都没发生，比明确告知"这次不生效"糟得多。
 */
Engine.buildIdConfig = function (opts) {
    var notes = [];
    var base = "tabs.id.features.";

    var sources = Sources.list();
    var engineSources = [];
    for (var i = 0; i < sources.length; i++) {
        var one = sources[i];
        /* `key` 就是界面的 `id`：断点按它认"哪条取材做完了"。
         * 以前刻意不带（引擎不需要），但续跑必须带 —— 否则断点里的条目和配置里的
         * 条目只能靠下标对齐，用户删一条就全错位。 */
        engineSources.push({
            key: one.id || "",
            kind: one.kind,
            anchors: one.anchors || "",
            lists: one.lists || [],
            searchType: one.searchType || "users",
            keyword: one.keyword || "",
            videoSource: one.videoSource || "screen",
            videoKeyword: one.videoKeyword || "",
            path: one.path || "",
            expand: one.expand || ""
        });
    }

    var config = {
        task: "id",
        id: {
            sources: engineSources,
            filter: {
                private: Store.getBool(base + "filterPrivate"),
                noAvatar: Store.getBool(base + "filterNoAvatar"),
                langRegion: Store.getEnum(base + "langRegion", "langRegion"),
                nicknameCheck: Store.getEnum(base + "nicknameCheck", "nicknameCheck"),
                /* 四组区间：界面是"最小值 / 最大值"两格，0 表示该侧不设限 */
                follow: { min: Store.getNumber(base + "followMin"), max: Store.getNumber(base + "followMax") },
                fans: { min: Store.getNumber(base + "fansMin"), max: Store.getNumber(base + "fansMax") },
                likes: { min: Store.getNumber(base + "likesMin"), max: Store.getNumber(base + "likesMax") },
                videos: { min: Store.getNumber(base + "videosMin"), max: Store.getNumber(base + "videosMax") }
            },
            output: {
                dir: Engine.ID_DIR,
                historyPath: Engine.ID_DIR + "/uid_extracted.txt",
                dedupeHistory: Store.getBool(base + "dedupeHistory"),
                dryRun: false,
                /* 0 = 不限。引擎另有「单次最长运行」与「解析 uid 独立预算」两道时长护栏 */
                limit: Store.getNumber(base + "extractLimit"),
                /* 抓完之后换数字 uid。默认开（数字 uid 在界面上读不到，不换就得事后另跑），
                 * 每个约多花 2.5 秒 —— 「输出」卡片上给了开关，用户可关。 */
                resolveUid: Store.getBool(base + "resolveUid")
            },
            guard: {
                /* 抓取阶段最长多久（分钟 → 毫秒）。到点收尾，已抓的不丢。 */
                maxRuntimeMs: Math.max(1, Store.getNumber(base + "maxRuntimeMin")) * 60 * 1000
            },
            /**
             * 断点续跑。**只有点「继续」时才为 true**。
             *
             * 引擎侧看到它才会去读断点文件；普通「开始运行」传 false，
             * 于是"想从头跑一次"永远是从头跑（不会被上一轮的断点悄悄接管）。
             */
            resume: {
                enabled: !!(opts && opts.resume),
                path: Engine.ID_PROGRESS_PATH
            }
        },
        runtime: {
            configPath: Engine.CONFIG_PATH,
            dryRun: false,
            maxRuntimeMs: 0
        }
    };

    notes = notes.concat(Engine.unsupportedNotes({ task: "id" }));

    /* 「本地去重」关掉时要说清楚后果：它不只是"少一道过滤"，
     * 而是同一个 ID 会在产物文件里重复出现，下游私信会重复发。 */
    if (!Store.getBool(base + "dedupeLocal")) {
        notes.push("\u672C\u5730\u53BB\u91CD\uFF1A\u5DF2\u5173\u95ED\uFF0C\u540C\u4E00\u4E2A ID \u53EF\u80FD\u91CD\u590D\u5199\u5165");
    }

    return { config: config, notes: notes };
};

/* ------------------------------------------------------------ 视频链路 */

Engine.buildVideoConfig = function () {
    var notes = [];

    var keyword = Store.getText("tabs.video.keyword");
    var stopMin = Store.getNumber("tabs.video.stopMin");
    var stopMax = Store.getNumber("tabs.video.stopMax");
    var intervalMin = Store.getNumber("tabs.video.intervalMin");
    var intervalMax = Store.getNumber("tabs.video.intervalMax");
    var doComment = Store.getBool("tabs.video.actions.comment");

    var pool = readLines(Store.getText("tabs.video.commentTextPath"));
    if (doComment && pool.length === 0) {
        notes.push("\u8BC4\u8BBA\u6587\u672C\u91CC\u6CA1\u6709\u53EF\u7528\u884C\uFF0C"
                   + "\u672C\u6B21\u4F1A\u7528\u5185\u7F6E\u9ED8\u8BA4\u8BC4\u8BBA");
    }

    var config = {
        target: {
            keyword: keyword,
            /* 「停止个数 最小值 ~ 最大值」= 每次运行在这个区间里随机停 ——
             * 固定不变会让每次运行的行为完全一样，反而更容易被看出是脚本。 */
            maxVideos: randomInt(stopMin, stopMax),
            resultTab: "Top",
            pickStrategy: "random"
        },
        /* 界面的「间隔时间（秒）」映射为**每个视频的观看时长**。
         * 引擎目前没有单独的"两个视频之间的停顿"配置，而"看 20 秒再操作"
         * 与"每 20 秒处理一个"在行为上是一回事。 */
        watch: {
            minMs: seconds(intervalMin),
            maxMs: seconds(intervalMax)
        },
        /* 点赞 / 关注：与评论同级的两个动作开关。
         * 界面上「执行操作」是四项多选，用户勾了才做 —— 没勾就一个都不点。 */
        likes: {
            enabled: Store.getBool("tabs.video.actions.like")
        },
        follows: {
            enabled: Store.getBool("tabs.video.actions.follow")
        },
        comments: {
            /* ★ 勾了「评论」才发评论。没勾就只是浏览 ——
             * 引擎侧据此跳过评论动作，而不是照默认值照发。
             * 用户的意图优先于引擎的默认行为。 */
            enabled: doComment,
            avoidRepeatWithinRun: true,
            verifyInList: true
        },
        runtime: {
            configPath: Engine.CONFIG_PATH,
            dryRun: false,
            maxRuntimeMs: 0
        }
    };

    if (pool.length > 0) {
        config.comments.pool = pool;
    }

    notes = notes.concat(Engine.unsupportedNotes({ task: "video" }));
    return { config: config, notes: notes };
};

/**
 * 引擎这次做不到、但用户可能勾了的项。
 *
 * 单独抽出来是因为它只跟「已实现的动作集合」有关，
 * 将来引擎接入了点赞，**只改这一个函数**就够。
 */
Engine.unsupportedNotes = function (task) {
    var notes = [];
    if (task && task.task === "id") {
        return Engine.unsupportedIdNotes();
    }
    /* 点赞与关注已由引擎实现（src/interact.js），不再报"尚未实现"。
     * 只剩私信一项还在等（见 UID私信 任务）。 */
    if (Store.getBool("tabs.video.actions.dm")) {
        notes.push("\u79C1\u4FE1\u52A8\u4F5C\uFF1A\u5F15\u64CE\u5C1A\u672A\u5B9E\u73B0");
    }
    return notes;
};

/**
 * ID 提取里"用户可能配了、但这次不生效"的项。
 *
 * 判据是**偏离默认值**，而不是"有值" —— 这一条很关键：
 * 功能设置里有好几项的默认值本身就是非空的（`regionCodes = "JP#TW#US"`、
 * `aiAgeMax = 20`、`videosMax = 500000`）。若按"有值就报"，
 * 每次运行都会冒出一串"未生效"，把真正需要注意的那条淹没 ——
 * 而 note 的本意是"你表达了意图，这次做不到"，默认值并不代表任何意图。
 */
Engine.unsupportedIdNotes = function () {
    var notes = [];
    var base = "tabs.id.features.";

    /** 这一项被用户改过吗（与默认值不同） */
    function changed(path) {
        return String(Store.get(path)) !== String(Store.defaultOf(path));
    }

    /* AI 三项：需要模型，本次不做。界面上是灰行，理论上改不动；
     * 老配置里可能残留过值，所以仍然按"改过才报"来处理。 */
    if (changed(base + "aiAvatar") && Store.getBool(base + "aiAvatar")) {
        notes.push("AI \u5934\u50CF\u8BC6\u522B\uFF1A\u5C1A\u672A\u63A5\u5165");
    }
    if (changed(base + "aiGender") && Store.getBool(base + "aiGender")) {
        notes.push("AI \u6027\u522B\u8BC6\u522B\uFF1A\u5C1A\u672A\u63A5\u5165");
    }
    if (changed(base + "aiAgeMax") && Store.getNumber(base + "aiAgeMax") > 0) {
        notes.push("AI \u5E74\u9F84\u8BC6\u522B\uFF1A\u5C1A\u672A\u63A5\u5165");
    }

    /* 云端去重：契约已定但服务端没接。降级为本地去重并**说出来**，绝不静默。 */
    if (Store.getBool(base + "cloudDedupe")) {
        notes.push("\u4E91\u7AEF\u53BB\u91CD\uFF1A\u670D\u52A1\u672A\u63A5\u5165\uFF0C\u672C\u6B21\u53EA\u7528\u672C\u5730\u53BB\u91CD");
    }

    /* 视频量门槛：真机实测用户页**只显示 关注/粉丝/获赞 三组数字，没有视频数**。
     * 引擎侧对这条的处理是"放行 + 告知"（见 tiktok-auto/src/filters.js 文件头）。
     * 默认上限 500000 在语义上等于"不限"，所以只有用户真的收窄了才报。 */
    if (changed(base + "videosMin") || changed(base + "videosMax")) {
        notes.push("\u89C6\u9891\u91CF\u95E8\u69DB\uFF1A\u7528\u6237\u9875\u4E0D\u663E\u793A\u8BE5\u6570\u5B57\uFF0C\u672C\u6B21\u4E0D\u53C2\u4E0E\u8FC7\u6EE4");
    }

    /* 无头像靠像素判定，纯黑白照片会被误判 —— 用户勾了就得先知道这个局限。 */
    if (Store.getBool(base + "filterNoAvatar")) {
        notes.push("\u65E0\u5934\u50CF\u68C0\u6D4B\uFF1A\u6309\u50CF\u7D20\u8272\u5F69\u5224\u5B9A\uFF0C\u7EAF\u9ED1\u767D\u7167\u7247\u4F1A\u88AB\u8BEF\u5224");
    }

    /* 「提取区域」刻意**不进 notes**：它在界面上是一行灰字 + 「暂不支持」胶囊，
     * 用户已经看得到；每次运行再报一次只会变成噪音。它的值仍保留在配置里，
     * 将来接上数据源时直接生效。 */

    return notes;
};

/**
 * notes → 一句能放在 toast 里的话（没有就返回空串）。
 *
 * 只取每条的**短名**（中文冒号前的部分）拼起来：三条完整说明拼起来有四十多个字，
 * 那种长度的 toast 用户根本来不及读。完整内容在 run-config.json 里，随时可查。
 */
Engine.summarizeNotes = function (notes) {
    if (!notes || notes.length === 0) { return ""; }
    var names = [];
    for (var i = 0; i < notes.length; i += 1) {
        names.push(String(notes[i]).split("\uFF1A")[0]);
    }
    return names.join("/") + " \u672C\u6B21\u4E0D\u4F1A\u751F\u6548";
};

/* ------------------------------------------------------------ 启动 */

/**
 * 准备一次运行：定位产物 + 构建配置。
 *
 * @param task 当前要跑的任务（含 `task` 字段）；不传按视频链路处理（向后兼容）
 * @returns { ok, scriptPath, config, notes, error }
 *   error 是给用户看的（说清楚"缺什么、放哪"），不是技术异常串。
 */
Engine.prepare = function (task, opts) {
    var path = Engine.locate();
    if (!path) {
        return {
            ok: false,
            error: "\u627E\u4E0D\u5230\u6267\u884C\u5F15\u64CE\u4EA7\u7269\uFF08" + Engine.SCRIPT_RELATIVE + "\uFF09\u3002\n\n"
                 + "\u8BF7\u5728 PC \u4E0A\u6267\u884C node tiktok-auto/tools/build.js \u540E\uFF0C"
                 + "\u5C06 tiktok-auto/dist/tiktok-auto.js \u653E\u5230 \u9879\u76EE\u6839\u76EE\u5F55\u4E0B,\n"
                 + "\u6216\u76F4\u63A5\u63A8\u5230 /sdcard/Download/tiktok-auto.js\u3002"
        };
    }

    var built = Engine.buildConfig(task, opts);

    /* 「关键词为空」是**视频链路**的硬前提（空关键词搜索必失败）。
     * ID 提取不需要关键词 —— 它可以只从粉丝列表或文本文件取材，
     * 所以这条拦截必须按任务分支，否则 ID 提取第一次点运行就会被无理由挡下。 */
    if (task && task.task === "id") {
        if (!built.config.id.sources || built.config.id.sources.length === 0) {
            return {
                ok: false,
                scriptPath: path,
                error: "\u8BF7\u5148\u5728\u300CID\u63D0\u53D6\u300D\u9875\u6DFB\u52A0\u81F3\u5C11\u4E00\u6761\u53D6\u6750\u3002"
            };
        }
        return {
            ok: true,
            scriptPath: path,
            config: built.config,
            notes: built.notes
        };
    }

    if (trimAll(built.config.target.keyword) === "") {
        return {
            ok: false,
            scriptPath: path,
            error: "\u5173\u952E\u8BCD\u4E3A\u7A7A\uFF0C\u8BF7\u5148\u5728\u300C\u89C6\u9891\u529F\u80FD\u300D\u9875\u586B\u5199\u8981\u641C\u7D22\u7684\u5173\u952E\u8BCD\u3002"
        };
    }

    return {
        ok: true,
        scriptPath: path,
        config: built.config,
        notes: built.notes
    };
};

/** 把引擎配置落盘。返回是否成功。 */
Engine.writeConfig = function (config) {
    try {
        files.ensureDir(Engine.DIR + "/");
        files.write(Engine.CONFIG_PATH, JSON.stringify(config, null, 2));
        return true;
    } catch (e) {
        console.log("[engine] 引擎配置落盘失败: " + e);
        return false;
    }
};

/**
 * 唤起引擎（另一个 ScriptEngine，不是当前脚本的线程）。
 *
 * 参数用 `--key value` 的平铺形式传：Rhino 会把数组包装成 {"0":..,"1":..}，
 * 桥那边按数字下标取，两边约定越简单越不容易出错。
 */
Engine.launch = function (runId, scriptPath, opts) {
    try {
        var argv = [
            "--config", Engine.CONFIG_PATH,
            "--state", Engine.STATE_PATH,
            "--stop-flag", Engine.STOP_FLAG_PATH,
            "--log", Engine.LOG_PATH,
            "--run-id", runId
        ];
        /* 只有点「继续」才带这两个参数。普通「开始运行」绝不能带 ——
         * 不然用户想从头跑一次，结果它接着上次跑。 */
        if (opts && opts.resume) {
            argv.push("--resume");
            argv.push("--checkpoint");
            argv.push(Engine.ID_PROGRESS_PATH);
        }
        var handle = engines.execScriptFile(scriptPath || Engine.scriptPath, {
            arguments: argv
        });
        if (!handle) {
            return { ok: false, error: "\u5F15\u64CE\u542F\u52A8\u8FD4\u56DE\u7A7A\uFF08\u53EF\u80FD\u88AB\u7CFB\u7EDF\u62E6\u622A\uFF09" };
        }
        return { ok: true };
    } catch (e) {
        console.log("[engine] 唤起失败: " + e);
        return { ok: false, error: String(e) };
    }
};

/* ------------------------------------------------------------ 日志回读 */

/**
 * 读引擎这次运行写下的日志（D3 的「执行日志」）。
 *
 * 三条原则：
 *   · **一行坏了只丢一行**：jsonl 逐行 parse，坏行跳过 —— 进程被杀时最后一行
 *     常常是半截的，整份 JSON.parse 会直接全丢；
 *   · 只取**最近** LOG_MAX_LINES 行：记录要落盘，日志不能把它撑到几百 KB；
 *   · 读不到就返回空数组，由页面如实说明「本次没有回传日志」，
 *     绝不编一行"看起来像日志"的东西。
 */
Engine.readLog = function () {
    var out = [];
    try {
        if (!files.exists(Engine.LOG_PATH)) { return out; }
        var lines = String(files.read(Engine.LOG_PATH)).split("\n");
        var start = Math.max(0, lines.length - 1 - Engine.LOG_MAX_LINES);
        for (var i = start; i < lines.length; i++) {
            var text = String(lines[i]).replace(/^\s+|\s+$/g, "");
            if (text === "") { continue; }
            try {
                var one = JSON.parse(text);
                if (one && one.text) { out.push(one); }
            } catch (e) {
                /* 半截行：跳过这一行，其余照收 */
            }
        }
    } catch (e2) {
        console.log("[engine] 读取运行日志失败: " + e2);
    }
    return out;
};

/* ------------------------------------------------------------ 状态回读 */

/** 读引擎上报的状态。没有 / 读坏了都返回 null。 */
Engine.readState = function () {
    try {
        if (!files.exists(Engine.STATE_PATH)) { return null; }
        var parsed = JSON.parse(String(files.read(Engine.STATE_PATH)));
        return parsed && typeof parsed === "object" ? parsed : null;
    } catch (e) {
        return null;
    }
};

/** 运行中（含正在收尾）—— 界面据此继续显示状态条 */
Engine.isActiveStatus = function (status) {
    return status === "starting" || status === "running" || status === "stopping";
};

/** 终态 —— 界面据此结束运行态并告知结果 */
Engine.isTerminalStatus = function (status) {
    return status === "finished" || status === "stopped" || status === "failed";
};

/** 请求停止：写停止标志（内容 = runId，引擎比对通过才会停） */
Engine.requestStop = function (runId) {
    try {
        files.ensureDir(Engine.DIR + "/");
        files.write(Engine.STOP_FLAG_PATH, String(runId));
        return true;
    } catch (e) {
        console.log("[engine] 写停止标志失败: " + e);
        return false;
    }
};

/**
 * 引擎是否还活着。
 *
 * 用途只有一个：**兜底判定"引擎没写终态就没了"**（被系统杀掉、被手工停掉）。
 * 查不出来时返回 true（当作还活着）—— 宁可多显示一会儿"运行中"，
 * 也不要误判成"已结束"而把运行态清掉、让用户以为跑完了。
 */
Engine.childAlive = function () {
    try {
        var mine = engines.myEngine();
        var all = engines.all() || [];
        for (var i = 0; i < all.length; i += 1) {
            var one = all[i];
            if (one && String(one.id) !== String(mine.id)) {
                return true;
            }
        }
        return false;
    } catch (e) {
        return true;
    }
};

/** 复位内存态。**不删文件**：状态靠 runId 比对，残留自然失效。 */
Engine.reset = function () {
    Engine.RUN_ID = "";
};


/* ============================== src/session.js ============================== */
/* ============================== src/session.js ==============================
 * 运行会话状态：跑没跑、跑的是哪个脚本、跑了多久。
 *
 * 为什么单独一个模块，而不是塞进 Store：
 *   Store 是**持久化**的配置，而「正在运行」是**进程内**的瞬时状态。
 *   把它写进配置会有两个后果：
 *     ① 上次没点「停止运行」就杀进程，下次启动界面会显示成「运行中」——
 *        可 TikTok 那边根本没人在驱动，用户等半天以为卡住了；
 *     ② 计时起点会被迫落盘，进程重启后算出来的时长是错的。
 *   所以这里只存在于内存里，冷启动一律是「未运行」。
 *
 * 真正的执行由 tiktok-auto 那套脚本负责，本模块只负责
 * 「界面上的运行态」与「给执行侧的那份运行配置」保持一致。
 */

var Session = {};

Session.running = false;
Session.tab = "";
Session.scriptKey = "";
Session.scriptName = "";
Session.startedAt = 0;

/** 本次运行的标识。与引擎上报的状态、停止标志三者比对，缺一不可。 */
Session.runId = "";

/** 引擎上报的阶段文案（"搜索 fashion" / "已完成 2/5"…）。空串表示还没收到。 */
Session.phase = "";

/** 进度计数，由引擎上报。仅用于状态条，不参与判断。 */
Session.done = 0;
Session.total = 0;

/** 已发出停止请求、正在等引擎确认。 */
Session.stopping = false;

/** 发出停止请求的时刻，用于超时兜底（引擎不确认也不能一直等）。 */
Session.stopRequestedAt = 0;

/* 计时器句柄。用 setInterval 而不是 threads.start：
 * UI 模式下 setInterval 的回调跑在主线程的 Looper 上，可以安全改 View；
 * 而 threads.start + ui.run 那条链路在真机上改 TextView 会崩
 * （见 page-mine.js 里 checkUpdateAsync 的注释）。 */
Session.tickHandle = null;

/**
 * 启动一次运行。
 *
 * @param runId 引擎桥的运行标识。界面用它过滤状态文件 ——
 *   设备上可能残留上一轮的状态，不比对就会把旧结果当成本轮结果。
 */
Session.start = function (tab, scriptKey, scriptName, runId) {
    Session.running = true;
    Session.tab = tab;
    Session.scriptKey = scriptKey;
    Session.scriptName = scriptName;
    Session.startedAt = Date.now();
    Session.runId = runId || "";
    Session.phase = "";
    Session.done = 0;
    Session.total = 0;
    Session.stopping = false;
    Session.stopRequestedAt = 0;
};

Session.stop = function () {
    Session.running = false;
    Session.tab = "";
    Session.scriptKey = "";
    Session.scriptName = "";
    Session.startedAt = 0;
    Session.runId = "";
    Session.phase = "";
    Session.done = 0;
    Session.total = 0;
    Session.stopping = false;
    Session.stopRequestedAt = 0;
};

/**
 * 运行条主文案（设计稿 B2：`● UID私信 · 脚本一 · 运行中`）。
 *
 * 三段拼装：任务名 · 脚本短名 · 状态。
 * 脚本短名与任务名相同时**不重复显示**（视频功能页只有一个脚本，
 * 拼出来会变成「视频功能 · 关键词视频功能 · 运行中」，白占一半宽度）。
 *
 * 「正在收尾」是刻意保留的一个中间态：点了停止之后引擎还要几秒才真的停手
 * （要退出当前等待、回到信息流）。这时界面如果说「已停止」，
 * 而 TikTok 还在自己动，用户不知道该信谁 —— 如实说"正在收尾"更对。
 */
Session.barText = function () {
    var taskName = Pages.taskName(Session.tab);
    var short = Pages.shortScriptName(Session.scriptName);
    /* 脚本短名与任务名重合（或已包含任务名，如「视频功能」⊂「关键词视频功能」）时
     * 不再重复一遍：拼出来会变成「视频功能 · 关键词视频功能 · 运行中」，白占一半宽度。 */
    var dup = short === "" || short === taskName || short.indexOf(taskName) >= 0;
    var head = dup ? taskName : (taskName + " \u00B7 " + short);

    if (Session.stopping) { return head + " \u00B7 \u6B63\u5728\u6536\u5C3E"; }
    if (Session.phase) { return head + " \u00B7 " + Session.phase; }
    return head + " \u00B7 \u8FD0\u884C\u4E2D";
};

/** 兼容旧调用点（自检里按这个名字断言过）。语义就是 barText。 */
Session.statusText = function () {
    return Session.barText();
};

/** 已运行毫秒数。未运行时返回 0，避免调用方拿到负数。 */
Session.elapsedMs = function () {
    if (!Session.running || !Session.startedAt) { return 0; }
    return Math.max(0, Date.now() - Session.startedAt);
};

/** 毫秒 → 01:24:37 形态。固定两位，等宽字下不会左右跳。 */
Session.formatElapsed = function (ms) {
    var total = Math.floor(ms / 1000);
    var h = Math.floor(total / 3600);
    var m = Math.floor((total % 3600) / 60);
    var s = total % 60;
    return pad2(h) + ":" + pad2(m) + ":" + pad2(s);
};

function pad2(n) {
    return n < 10 ? "0" + n : String(n);
}

/**
 * 每秒推一次计时。
 *
 * onTick 只做「改一个 TextView 的文字」，不重建界面——
 * 每秒重建整页会让滚动位置归零，用户根本没法边跑边看配置。
 */
Session.startTimer = function (onTick) {
    Session.stopTimer();
    onTick();
    Session.tickHandle = setInterval(function () {
        /* 回调里任何异常都不能让它继续每秒抛一次，否则日志会被刷爆 */
        try {
            onTick();
        } catch (e) {
            console.log("[session] 计时刷新失败: " + e);
            Session.stopTimer();
        }
    }, 1000);
};

Session.stopTimer = function () {
    if (Session.tickHandle !== null) {
        clearInterval(Session.tickHandle);
        Session.tickHandle = null;
    }
};


/* ============================== src/resume.js ============================== */
/**
 * resume.js — 断点续跑的界面侧（读断点、判断能不能续、清空）
 *
 * ## 职责边界
 * 界面**不写**断点 —— 断点是引擎在跑的时候写的（它才知道"这条取材走完了"）。
 * 界面只做三件事：读出来、判断还能不能用、在用户点「继续」时把开关传给引擎。
 * 唯一会写的一处是「清空断点」：覆盖成 `state:"none"`（**不删文件**，
 * `remove(` 命中 MCP 危险调用黑名单，见 `tiktok-auto/tools/build.js`）。
 *
 * ## 为什么判断要放在界面
 * 用户点「继续」之前就得知道"这个断点还用不用得上"，否则会出现
 * 点了继续 → 引擎启动 → 打开 TikTok → 才发现配置变了 → 白折腾一趟。
 * 引擎侧也会再判一次（有人可能直接改配置手起引擎），两处判据一致
 * （指纹算法在 `fingerprint.js`，两份逐字节相同）。
 *
 * ## 与记录页的关系
 * 断点里带 `runId`，记录里也带 `runId` —— 只有两者相等才认为"这条记录就是那个断点"。
 * 不这么做的话，用户会在一堆历史「手动停止」记录上都看到「继续」，
 * 而其中只有最后一条是真的能续的。
 */
var Resume = (function () {
    'use strict';

    var PATH = Engine.ID_PROGRESS_PATH;
    var VERSION = 1;

    function nameOf(key) {
        if (key === 'sources') { return '取材'; }
        if (key === 'filter') { return '过滤条件'; }
        if (key === 'output') { return '输出设置（目录 / 跨轮去重）'; }
        return key;
    }

    /** 读断点。解析不了就当"没有断点"（界面不显示提示条，绝不报错吓人） */
    function read() {
        try {
            if (!files.exists(PATH)) {
                return null;
            }
            var text = String(files.read(PATH) || '');
            if (text.replace(/\s/g, '') === '') {
                return null;
            }
            var cp = JSON.parse(text);
            if (!cp || cp.v !== VERSION) {
                return null;
            }
            return cp;
        } catch (e) {
            console.log("[resume] 断点文件读不懂（当作没有断点）: " + e);
            return null;
        }
    }

    function stoppedAt(cp) {
        var list = cp && cp.sources ? cp.sources : [];
        for (var i = 0; i < list.length; i++) {
            if (list[i].status !== 'done') {
                return list[i].label || '';
            }
        }
        return '';
    }

    function countBy(cp) {
        var list = cp && cp.sources ? cp.sources : [];
        var done = 0;
        for (var i = 0; i < list.length; i++) {
            if (list[i].status === 'done') {
                done += 1;
            }
        }
        return { done: done, total: list.length };
    }

    /**
     * 一次读盘算出"能不能续"，供提示条与记录页共用。
     *
     * @returns {
     *   exists, cp, valid, finished, reason, message, changed[],
     *   extracted, runFile, stoppedAt, doneSources, totalSources
     * }
     */
    function snapshot() {
        var cp = read();
        var out = {
            exists: !!cp,
            cp: cp,
            valid: false,
            finished: false,
            reason: '',
            message: '',
            changed: [],
            extracted: 0,
            runFile: '',
            stoppedAt: '',
            doneSources: 0,
            totalSources: 0
        };
        if (!cp) {
            out.reason = 'no-checkpoint';
            return out;
        }

        out.runFile = cp.runFile || '';
        out.stoppedAt = stoppedAt(cp);
        out.extracted = (cp.counts && typeof cp.counts.extracted === 'number')
            ? cp.counts.extracted : 0;
        var prog = countBy(cp);
        out.doneSources = prog.done;
        out.totalSources = prog.total;

        if (cp.state === 'none') {
            out.reason = 'cleared';
            return out;
        }
        if (cp.state === 'done') {
            out.finished = true;
            out.reason = 'last-complete';
            return out;
        }

        var sig = Fingerprint.ofIdSection(Engine.buildIdConfig().config.id);
        var cmp = Fingerprint.compare(cp.sig, sig);
        if (!cmp.same) {
            var names = [];
            for (var i = 0; i < cmp.changed.length; i++) {
                names.push(nameOf(cmp.changed[i]));
            }
            out.changed = cmp.changed;
            out.reason = 'config-changed';
            out.message = names.join('、') + '改过了，只能重新开始';
            return out;
        }
        if (!out.runFile || !files.exists(out.runFile)) {
            out.reason = 'run-file-missing';
            out.message = '上次的结果文件已被删除';
            return out;
        }

        out.valid = true;
        out.reason = 'ok';
        return out;
    }

    /** 现在能不能点「继续」（还要叠加"当前没有别的任务在跑"） */
    function canResume(snap) {
        var s = snap || snapshot();
        return s.valid === true && Session.running !== true;
    }

    /**
     * 这条运行记录能不能续。
     *
     * 判据必须精确到"就是那次运行"，否则一堆历史记录上都会冒出「继续」：
     *   · 任务必须是 ID 提取
     *   · 结果必须是 stopped（手动停止）或 failed（被杀/异常退出）
     *   · 断点本身还得有效（配置没变、结果文件还在）
     *   · **记录里的 runId 必须等于断点里的 runId**
     */
    function isRecordResumable(record, snap) {
        var s = snap || snapshot();
        if (!record || record.taskKey !== 'id') {
            return false;
        }
        if (record.result !== 'stopped' && record.result !== 'failed') {
            return false;
        }
        if (!s.valid || !s.cp) {
            return false;
        }
        return !!(record.runId && s.cp.runId && record.runId === s.cp.runId);
    }

    /** 提示条上那句副文案 */
    function detail(snap) {
        var s = snap || snapshot();
        if (s.valid) {
            var where = s.stoppedAt ? '停在「' + s.stoppedAt + '」' : '上次没跑完';
            return where + ' · 继续会追加到同一个文件';
        }
        if (s.finished) {
            return '上次已跑完';
        }
        return s.message || '';
    }

    /** 清空断点 = 覆盖成空壳。**不删文件** */
    function clear() {
        try {
            files.write(PATH, JSON.stringify({
                v: VERSION,
                state: 'none',
                updatedAt: Date.now()
            }));
            return true;
        } catch (e) {
            console.log("[resume] 清空断点失败: " + e);
            return false;
        }
    }

    return {
        PATH: PATH,
        read: read,
        snapshot: snapshot,
        canResume: canResume,
        isRecordResumable: isRecordResumable,
        detail: detail,
        nameOf: nameOf,
        clear: clear
    };
}());


/* ============================== src/widgets.js ============================== */
/* ============================== src/widgets.js ==============================
 * 通用组件工厂。
 *
 * 设计稿里的每一类元素（卡片 / 设置行 / 下拉 / 开关 / 胶囊按钮 / 状态标签 /
 * 勾选框 / 页签 / 主按钮）在这里各有一个构造函数，页面只做「拼装」。
 * 目的很直接：同一元素在 5 个页面里必须长得一样，
 * 布局参数一旦散落到页面代码，就会出现「这个页的卡片圆角是 16、那个页是 12」。
 *
 * 所有构造函数都返回 Android View；需要后续改动的额外返回 setter。
 */

var W = {};

/* ---------------------------------------------------------------- 卡片 */

/**
 * 圆角卡片容器（vertical）。
 * active=true 用青蓝描边 35%，false 用白 8% —— 对应设计稿里「已勾选脚本卡」的差异。
 */
W.card = function (active) {
    var card = U.column();
    card.setBackground(active
        ? U.strokeBg(Theme.alpha.cardFillActive, Theme.alpha.cardStrokeActive, Theme.hex.accent, Theme.m.cardRadius)
        : U.strokeBg(Theme.alpha.cardFill, Theme.alpha.cardStroke, "#FFFFFF", Theme.m.cardRadius));
    card.setPadding(U.dp(Theme.m.cardPadding), U.dp(Theme.m.cardPadding),
                    U.dp(Theme.m.cardPadding), U.dp(Theme.m.cardPadding));
    return card;
};

/** 按序把子 View 加进容器，并按 gap 插入间距，避免每处手写 spacer。 */
W.stack = function (container, children, gapDp) {
    var gap = gapDp === undefined ? 12 : gapDp;
    for (var i = 0; i < children.length; i++) {
        if (!children[i]) { continue; }
        if (i > 0 && gap > 0) { container.addView(U.spacer(gap)); }
        container.addView(children[i]);
    }
    return container;
};

/** 区标题（「脚本选择」「功能设置」这类分段标题）。 */
W.sectionTitle = function (label) {
    return U.text(label, Theme.m.sectionSize, Theme.hex.textPrimary, true);
};

/* ------------------------------------------------------------ 顶部标题区 */

/**
 * 页面顶部：大标题 + 副标题 + 右侧设置入口。
 * 5 个页签共用同一个标题区，所以文案由页面传入而不是写死在这里。
 */
W.pageHeader = function (title, subtitle, onTapSettings) {
    var left = U.column();
    U.params(left, 0, -2, 1);
    left.addView(U.text(title, Theme.m.titleSize, Theme.hex.textPrimary, true));
    left.addView(U.spacer(4));
    left.addView(U.text(subtitle, 12, Theme.hex.textMuted, false));

    var header = U.row();
    header.addView(left);

    if (onTapSettings) {
        var gear = U.text("\u2699", 18, Theme.hex.textSecondary, false);
        gear.setGravity(android.view.Gravity.CENTER);
        U.params(gear, 22, 22);
        gear.setOnClickListener(function () { onTapSettings(); });
        header.addView(gear);
    }
    return header;
};

/* ------------------------------------------------------------ 脚本卡 */

/**
 * 脚本卡头部一行：勾选框/单选框 + 脚本名 +（摘要）+ 展开箭头。
 *
 * 勾选与展开是两个独立命中区——合并成一个的话，
 * 用户想展开却把脚本关掉是必然事件。
 *
 * mode: "checkbox"（默认）| "radio"。设计稿的 ID 提取页是单选
 * （「同一时间仅可运行一个脚本」），其余页是可多选的勾选。
 * 互斥由页面负责——组件只管画和报「点完应该是什么状态」。
 *
 * radio 的「再点一下取消」是有意为之：设计稿专门画了「未选择脚本」这一屏
 * （16:23 + 「请先选择要运行的脚本」拦截弹窗），必须有一条路能回到那个状态。
 * 严格单选一旦选过就再也回不去，那一屏就成了永远看不到的死代码。
 *
 * disabled: 运行中不允许切换脚本（设计稿 09 的底部提示就是这么写的）。
 */
W.scriptHeader = function (opts) {
    var isRadio = opts.mode === "radio";
    var disabled = !!opts.disabled;

    var box = isRadio ? W.radio(opts.checked, 18) : W.checkbox(opts.checked, 18);

    /* 名称用「内容宽度 + 弹性占位顶开」，而不是 weight=1。
     * weight=1 的写法在右侧存在 MATCH_PARENT 控件时会被挤成 0 宽（真机踩过），
     * 用 flexible() 占位则无论同行其它控件怎么变都成立。 */
    var nameView = U.text(opts.name, Theme.m.labelSize,
                          disabled ? Theme.hex.textMuted : Theme.hex.textPrimary, true);
    nameView.setSingleLine(true);
    nameView.setEllipsize(android.text.TextUtils.TruncateAt.END);

    var head = U.row();
    head.addView(box.root);
    head.addView(U.hgap(Theme.m.gapInline));
    head.addView(nameView);
    head.addView(U.flexible());

    if (opts.summary) {
        head.addView(U.text(opts.summary, Theme.m.chipSize, Theme.hex.textFaint, false));
        head.addView(U.hgap(6));
    }

    var arrowBox = U.row(false);
    arrowBox.setGravity(android.view.Gravity.CENTER);
    U.params(arrowBox, 16, 16);
    var arrow = W.arrow(opts.expanded);
    arrowBox.addView(arrow.root);
    head.addView(arrowBox);

    box.root.setOnClickListener(function () {
        if (disabled) { return; }
        /* 两种模式都是「取反」——单选组也允许点已选中项来取消，
         * 详见上面 radio 的说明。互斥（同组只留一个）由页面处理。 */
        var next = !box.isChecked();
        box.set(next);
        opts.onToggleCheck(next);
    });

    arrowBox.setOnClickListener(function () {
        /* 展开只影响看到多少设置，不影响「要不要跑」，运行中也不必禁用 */
        opts.onToggleExpand();
    });

    return { root: head, nameView: nameView, arrow: arrow, checkbox: box };
};

/* ---------------------------------------------------------------- 勾选框 */

/**
 * 勾选框。选中 = 青蓝实心 + 白色对勾；未选中 = 透明底 + 灰描边。
 * 用「字符当对勾」而不是 VectorDrawable：省掉资源文件，且离线桩测能直接验证状态。
 */
W.checkbox = function (checked, sizeDp) {
    var size = sizeDp || 16;
    var radius = size <= 16 ? 4 : 5;

    var view = U.text("", 11, Theme.hex.textPrimary, true);
    view.setGravity(android.view.Gravity.CENTER);
    U.params(view, size, size);

    var state = { checked: !!checked };
    function paint() {
        if (state.checked) {
            view.setText("\u2713");
            view.setBackground(U.solidBg(U.argb(Theme.hex.accent), radius));
        } else {
            view.setText("");
            view.setBackground(U.strokeBg(0, 1, Theme.hex.tabIdle, radius));
        }
    }
    paint();

    return {
        root: view,
        set: function (value) { state.checked = !!value; paint(); },
        isChecked: function () { return state.checked; }
    };
};

/* ---------------------------------------------------------------- 单选框 */

/**
 * 单选框（设计稿 01「脚本一」的 16:1072）。
 *
 * 与勾选框的差别不只是外形，更是**语义**：一组里同时只能有一个被选中
 * （设计稿写得很明确——「单选：同一时间仅可运行一个脚本」）。
 * 所以这个组件只负责画与报状态，「互斥」由页面负责清掉同组其它项。
 */
W.radio = function (checked, sizeDp) {
    var size = sizeDp || 18;

    var view = U.text("", Theme.m.chipSize, Theme.hex.textPrimary, true);
    view.setGravity(android.view.Gravity.CENTER);
    U.params(view, size, size);

    /* 选中 = 青蓝实心圆 + 白色圆点；未选中 = 透明底 + 灰描边圆。
     * 圆点用 "●"（U+25CF）而不是画 VectorDrawable：与勾选框同一套思路，
     * 省掉资源文件，且离线桩测能直接断言状态。 */
    var state = { checked: !!checked };
    function paint() {
        if (state.checked) {
            view.setText("\u25CF");
            view.setTextSize(7);
            view.setBackground(U.solidBg(U.argb(Theme.hex.accent), 99));
        } else {
            view.setText("");
            view.setBackground(U.strokeBg(0, 1, Theme.hex.tabIdle, 99));
        }
    }
    paint();

    return {
        root: view,
        set: function (value) { state.checked = !!value; paint(); },
        isChecked: function () { return state.checked; }
    };
};

/* ---------------------------------------------------------------- 箭头 */

/** 展开 / 收起箭头。字符 U+25BE / U+25B4 在 Android 默认字体里必然存在。 */
W.arrow = function (expanded) {
    var view = U.text(expanded ? "\u25B4" : "\u25BE", 12, Theme.hex.textFaint, false);
    view.setGravity(android.view.Gravity.CENTER);
    return {
        root: view,
        set: function (value) { view.setText(value ? "\u25B4" : "\u25BE"); }
    };
};

/**
 * 指向右侧的箭头（运行记录条目 / 可进入下一级的行）。
 *
 * 用 U+203A（单右角引号）而不是 U+2192：后者在部分 Android 字体里带 emoji 变体，
 * 会渲染成彩色箭头（页签图标踩过同一个坑）。U+203A 在默认字体里稳定是字形。
 */
W.chevronRight = function (sizeSp, hex) {
    var view = U.text("\u203A", sizeSp || 18, hex || Theme.hex.textFaint, false);
    view.setGravity(android.view.Gravity.CENTER);
    return view;
};

/* ------------------------------------------------------------ 设置行 */

/**
 * 「左标签 + 右控件」设置行；右控件可省略（此时是纯文案行）。
 *
 * 左侧标签用内容宽度 + flexible() 顶开，**不用 weight=1**：
 * 当右控件自身是 MATCH_PARENT（例如整行输入框）时，
 * weight=1 的标签会被挤成 0 宽，在真机上就是「这一行的标签不见了」。
 */
W.settingRow = function (label, rightView, gapDp) {
    var nameView = U.text(label, Theme.m.labelSize, Theme.hex.textSecondary, false);
    nameView.setSingleLine(true);

    var line = U.row();
    line.addView(nameView);
    line.addView(U.flexible());
    if (rightView) {
        line.addView(U.hgap(gapDp === undefined ? 6 : gapDp));
        line.addView(rightView);
    }
    return line;
};

/* ------------------------------------------------------------ 勾选设置行 */

/**
 * 「勾选框 + 标签 +（可选右侧控件）」设置行。
 *
 * 设计稿里这类行有三种排布：
 *   · 单独一行（过滤私密账户）；
 *   · 一行两个（过滤私密账户 | 过滤无头像账户）；
 *   · 勾选后才出现右侧控件（云端去重 → 表名 + 连通测试）。
 * 第三种由调用方按状态自己拼，前两种用这个函数。
 *
 * 命中区含整个标签：只让 16dp 的方框可点，真机上很难戳中。
 */
/**
 * 勾选行。
 *
 * @param disabled 置灰且不可点。**为「功能还没做，但字段要保留」的场景准备的**：
 *                 给了界面一个"开得起来、却什么也不会发生"的开关，比不给更糟
 *                 （用户会以为它生效了）。置灰至少是诚实的。
 *                 勾选状态**照常显示**——它代表"用户上次的选择"，不是"现在能改的选择"。
 */
W.checkRow = function (label, checked, onToggle, disabled) {
    var box = W.checkbox(checked, 16);
    var off = !!disabled;
    var labelView = U.text(label, Theme.m.labelSize,
                           off ? Theme.hex.textMuted : Theme.hex.textSecondary, false);
    labelView.setSingleLine(true);

    var line = U.row(false);
    line.addView(box.root);
    line.addView(U.hgap(8));
    line.addView(labelView);
    line.setPadding(0, U.dp(4), 0, U.dp(4));

    if (off) {
        line.setAlpha(0.55);
        /* 不可点：这里挂一个**空监听**而不是不挂 —— 不挂的话父容器（卡片）
         * 的点击会继续冒泡上去，用户点这一行会触发别处的动作。
         * 注意 setOnClickListener(function(){}) 与 setOnClickListener(null) 行为不同：
         * 后者等于"没有监听器"，照样冒泡（见 README 铁律）。 */
        line.setOnClickListener(function () { });
    } else {
        line.setOnClickListener(function () {
            var next = !box.isChecked();
            box.set(next);
            onToggle(next);
        });
    }

    return { root: line, isChecked: box.isChecked };
};

/**
 * 灰行：**只读展示 + 「暂不支持」标记**。
 *
 * 专门给"设置项在界面上占着位置、但执行侧还没有能力实现"的项用
 * （提取区域 / AI 头像识别 / AI 性别 / AI 年龄）。
 *
 * 为什么不是"灰掉的勾选框"：勾选框本身就在说"这个可以改"，
 * 灰只是说"现在不能改"，两者叠起来仍然在暗示它是个可选项。
 * 而这里的事实是"它现在根本没有效果" —— 所以不给可操作控件，
 * 只把用户上次填的值显示出来（保留值、将来接上就能用），点一行看原因。
 */
W.mutedRow = function (label, valueText, onTap) {
    var line = U.row(false);
    var labelView = U.text(label, Theme.m.labelSize, Theme.hex.textMuted, false);
    labelView.setSingleLine(true);
    line.addView(labelView);
    line.addView(U.flexible());

    if (valueText) {
        var valueView = U.text(valueText, Theme.m.chipSize, Theme.hex.textFaint, false);
        valueView.setSingleLine(true);
        line.addView(valueView);
        line.addView(U.hgap(6));
    }

    line.addView(W.chip("暂不支持", "mute").root);
    line.setPadding(0, U.dp(4), 0, U.dp(4));

    if (onTap) {
        line.setOnClickListener(onTap);
    } else {
        line.setOnClickListener(function () { });
    }
    return { root: line };
};

/* ------------------------------------------------------------ 胶囊 / 标签 */

/* 胶囊的四套色调集中在这里，W.chip 与 W.repaintChip 共用，
 * 避免「改了一处忘了另一处」导致状态切换后颜色不更新。 */
W.TONES = {
    "default": { fill: 0.06, stroke: 0.10, text: "#CFCCE6" },
    "accent":  { fill: 0.20, stroke: 0,    text: "#7CC7FF" },
    "warn":    { fill: 0.16, stroke: 0,    text: "#F5C24B" },
    "ok":      { fill: 0.16, stroke: 0,    text: "#13DEC4" },
    /* 不可逆操作用 danger，与「未开启」的琥珀色区分开——
     * 两种暖色混用会让用户分不清「提示」和「警告」。 */
    "danger":  { fill: 0.16, stroke: 0,    text: "#FF5470" },
    "mute":    { fill: 0.08, stroke: 0,    text: "#8E8BA8" }
};

W.paintTone = function (view, tone, radiusDp) {
    var t = W.TONES[tone] || W.TONES["default"];
    view.setTextColor(U.argb(t.text));
    view.setBackground(t.stroke > 0
        ? U.strokeBg(t.fill, t.stroke, "#FFFFFF", radiusDp)
        : U.solidBg(U.alphaOf("#FFFFFF", t.fill), radiusDp));
    return view;
};

/**
 * 胶囊元素的统一出口：下拉框、按钮、状态标签都用它，只是色调与圆角不同。
 */
W.chip = function (label, tone, minWidthDp, radiusDp) {
    var view = U.text(label, Theme.m.chipSize, W.TONES["default"].text, true);
    view.setGravity(android.view.Gravity.CENTER);
    view.setSingleLine(true);
    W.paintTone(view, tone || "default", radiusDp === undefined ? Theme.m.chipRadius : radiusDp);
    view.setPadding(U.dp(Theme.m.chipPadH), U.dp(Theme.m.chipPadV),
                    U.dp(Theme.m.chipPadH), U.dp(Theme.m.chipPadV));
    if (minWidthDp) { view.setMinWidth(U.dp(minWidthDp)); }

    return {
        root: view,
        setText: function (v) { view.setText(String(v)); },
        setTone: function (nextTone) { W.paintTone(view, nextTone, Theme.m.chipRadius); }
    };
};

/** 状态标签（全圆角），用于「未登录 / 已安装 v39.5.4 / 已是最新」。 */
W.pill = function (label, tone) {
    var t = W.TONES[tone || "mute"] || W.TONES["mute"];
    var view = U.text(label, Theme.m.chipSize, t.text, true);
    view.setGravity(android.view.Gravity.CENTER);
    view.setSingleLine(true);
    view.setBackground(U.solidBg(U.alphaOf("#FFFFFF", t.fill), Theme.m.pillRadius));
    view.setPadding(U.dp(Theme.m.chipPadH), U.dp(Theme.m.chipPadV),
                    U.dp(Theme.m.chipPadH), U.dp(Theme.m.chipPadV));
    return {
        root: view,
        setText: function (v) { view.setText(String(v)); }
    };
};

/* ------------------------------------------------------------ 下拉框 */

/**
 * 下拉框。
 *
 * 为什么既不用 Spinner 也不用 dialogs.select：
 *   · Spinner 的弹出列表走系统浅色主题，在深色界面里是一块刺眼的白板，
 *     要改得自定义 Adapter 与主题；
 *   · `dialogs.select` 在 UI 模式下**拿不到返回值**（阻塞会死锁，运行时直接返回 undefined），
 *     结果是「选完写回 undefined」，配置被写坏、重启又变回默认值。
 * 所以用自绘的 Dialog.choose：样式统一由 Theme 控制，结果走回调。
 */
W.dropdown = function (group, valuePath, onChange) {
    /* 用 getEnum 而不是 get：它保证拿回一个**合法 key**，
     * 缺失或非法时回退到该枚举的默认项并回写配置。
     * 于是这个胶囊在第一次渲染时就一定有值，不会出现空框。 */
    var chip = W.chip(Store.label(group, Store.getEnum(valuePath, group)), "default", 60);

    chip.root.setOnClickListener(function () {
        Dialog.choose({
            options: Store.options[group],
            currentIndex: Store.indexOfLabel(group, Store.getEnum(valuePath, group)),
            onConfirm: function (index) {
                var key = Store.keyAt(group, index);
                Store.set(valuePath, key);
                chip.setText(Store.label(group, key));
                if (onChange) { onChange(key); }
            }
        });
    });

    return {
        root: chip.root,
        set: function (key) { chip.setText(Store.label(group, key)); }
    };
};

/* ------------------------------------------------------------ 开关 */

/**
 * 二元开关。设计稿用的是「胶囊文字按钮」而不是滑块，
 * 所以这里做成 chip：开 = 青蓝高亮，关 = 灰。
 */
W.toggle = function (on, onChange) {
    var chip = W.chip(on ? Store.label("toggle", "on") : Store.label("toggle", "off"),
                     on ? "accent" : "default", 44);
    var state = !!on;

    chip.root.setOnClickListener(function () {
        state = !state;
        chip.setText(state ? Store.label("toggle", "on") : Store.label("toggle", "off"));
        chip.setTone(state ? "accent" : "default");
        if (onChange) { onChange(state); }
    });

    return {
        root: chip.root,
        isOn: function () { return state; },
        set: function (v) {
            state = !!v;
            chip.setText(state ? Store.label("toggle", "on") : Store.label("toggle", "off"));
            chip.setTone(state ? "accent" : "default");
        }
    };
};

/* ------------------------------------------------------------ 多选开关行 */

/**
 * 「执行操作」那种一行多选：关注 / 私信 / 点赞 / 评论。
 * 每一项独立高亮、互不影响，所以不能复用 W.toggle（它是二元开关）。
 */
W.toggleRow = function (items, onChange) {
    /* 这一行是作为「设置行的右侧控件」使用的，必须包裹内容——
     * 用默认的 fill=true 会占满整行，把左侧标签挤成 0 宽。 */
    var line = U.row(false);
    var chips = {};

    for (var i = 0; i < items.length; i++) {
        (function (item) {
            var chip = W.chip(item.label, item.on ? "accent" : "default", 36);
            var state = !!item.on;

            chip.root.setOnClickListener(function () {
                state = !state;
                chip.setTone(state ? "accent" : "default");
                if (onChange) { onChange(item.key, state); }
            });

            chips[item.key] = {
                root: chip.root,
                isOn: function () { return state; },
                set: function (v) { state = !!v; chip.setTone(state ? "accent" : "default"); }
            };

            if (line.getChildCount() > 0) { line.addView(U.hgap(6)); }
            line.addView(chip.root);
        })(items[i]);
    }

    return { root: line, chips: chips };
};

/* ------------------------------------------------------------ 输入框 */

/**
 * 常驻输入框 —— **直接在栏位里改**，不再「点一下弹出输入框再填」。
 *
 * 上一版为什么绕开常驻 EditText（理由已逐条失效，记在这里免得又被改回去）：
 *   ① 怕 TextWatcher 这种 Java 接口构造不出来 —— 已在目标设备上实测通过：
 *      `new android.text.TextWatcher({...})` 与 `new View.OnFocusChangeListener({...})`
 *      都能构造，真机逐字输入每键都触发回调。
 *   ② 怕忘绑监听 → 「能打字但永远不保存」（用户会报成「没有默认值」）——
 *      监听现在写在本函数内部，全项目只有这一个输入框入口，不存在漏绑的余地。
 *
 * ★ 程序化回写必须防自触发：真机上 `setText` 会**同步**触发 TextWatcher
 *   （实测顺序是 before → on → after 全部跑完，setText 才返回）。
 *   不挡的话「失焦正规化」会把夹紧后的值再存一遍，来回震荡。
 *
 * ★ 数字框在「从尾部退格」的过程中**不写配置**：把 2000 清成 2 会经过 200、20
 *   这些**恰好合法**的中间值，用户清空后走开，配置就停在 2 上。
 *   退格期间不写，失焦时一次性提交（那时文本已定稿；空串则回退原值）。
 *   文本字段不受这条限制 —— 半截文本本身就是「用户正在输入的内容」，没有这个问题。
 *
 * opts:
 *   path          绑定配置路径 → 自动「读初值 / 输入即落盘 / 失焦正规化」
 *   value         未绑定 path 时的初值（一次性取值的场合，如登录页卡密）
 *   placeholder   空值提示
 *   numeric       true → 数字键盘，按数值解析与落盘
 *   widthDp       固定宽度。横向布局里**必须**给：默认 MATCH_PARENT 会把同行标签挤成 0 宽
 *   fill          true → 宽度撑满（独占一行的输入框，如登录页卡密）
 *   align         "right" 等（数字在区间里居中对齐，见下）
 *   onLinkedChange 自己改完**连带改了别的字段**时的回调（只刷兄弟，不刷自己）
 *   onSubmit      软键盘回车
 */
W.inlineField = function (opts) {
    /* 绑定方式有两种：
     *   · `path`  —— 绑 Store 的字段（绝大多数控件）
     *   · `read`/`write` —— 绑"不是 Store 字段"的值（取材清单里的账号/关键词/路径）。
     *     后者必须自己提供读写，因为 Sources 是另一个储物柜。 */
    var hasWriter = typeof opts.write === "function";
    var bound = hasWriter || (typeof opts.path === "string" && opts.path !== "");
    var numeric = !!opts.numeric;

    var edit = new android.widget.EditText(context);
    edit.setTextSize(Theme.m.chipSize);
    edit.setTextColor(U.argb(Theme.hex.textSecondary));
    edit.setHintTextColor(U.argb(Theme.hex.textFaint));
    edit.setHint(opts.placeholder || "");
    edit.setSingleLine(true);
    edit.setPadding(U.dp(8), U.dp(7), U.dp(8), U.dp(7));
    if (numeric) {
        edit.setInputType(android.text.InputType.TYPE_CLASS_NUMBER);
        /* 数字短、盒子窄，居中比左右对齐更稳（设计稿里两种都有，取一致的居中） */
        edit.setGravity(android.view.Gravity.CENTER);
    } else if (opts.align === "right") {
        edit.setGravity(android.view.Gravity.RIGHT);
    }
    edit.setImeOptions(android.view.inputmethod.EditorInfo.IME_ACTION_DONE);
    /* 横向布局里宽度必须显式给死，否则 MATCH_PARENT 会吃掉整行（真机踩过的坑）。
     * fill: true 用于独占一行的输入框（登录页卡密）。 */
    var width = -2;
    if (opts.fill) { width = -1; }
    else if (opts.widthDp) { width = U.dp(opts.widthDp); }
    U.params(edit, width, -2);

    var idleBg = U.strokeBg(Theme.alpha.chipFill, Theme.alpha.chipStroke, "#FFFFFF", Theme.m.chipRadius);
    /* 可编辑之后必须看得出来「现在改的是哪一格」，聚焦时换青蓝描边 */
    var activeBg = U.strokeBg(Theme.alpha.chipFill, 0.55, Theme.hex.accent, Theme.m.chipRadius);
    edit.setBackground(idleBg);

    /* 程序化回写期间置位，挡住 TextWatcher —— 见函数头第 ★ 条 */
    var writing = false;
    /* 上一次的栏位文字，只用来判断「这一下是不是在退格」 */
    var lastText = "";

    function readStore() {
        if (typeof opts.read === "function") {
            var fromCallback = opts.read();
            return fromCallback === undefined || fromCallback === null ? "" : String(fromCallback);
        }
        if (bound && typeof opts.path === "string" && opts.path !== "") {
            return numeric ? String(Store.getNumber(opts.path)) : Store.getText(opts.path);
        }
        return opts.value === undefined || opts.value === null ? "" : String(opts.value);
    }

    function paint() {
        writing = true;
        try {
            edit.setText(readStore());
            /* ★ 用 String(...) 取长度，不要写 `edit.getText().length()`：
             * 真机上 getText() 返回 android.text.Editable（有 length() 方法），
             * 但测试桩返回的是 JS 字符串（length 是属性不是函数）——
             * 写成 `.length()` 会让回写在桩上**每次都抛异常**，
             * 于是「回写之后光标在哪」这类问题在 PC 侧永远测不出来。 */
            edit.setSelection(String(edit.getText()).length);
        } catch (e) {
            console.log("[input] paint 失败 " + opts.path + ": " + e);
        } finally {
            /* 一定要走 finally：抛异常时若把 writing 留在 true，
             * 这个输入框就**永远不会再写配置**了（静默哑掉）。 */
            writing = false;
        }
        lastText = String(edit.getText());
    }

    /** 把栏位文字写进配置。空串 / 非数字一律不写（保留原值，由 paint 兜底显示）。 */
    function commit() {
        if (!bound) { return false; }
        var raw = String(edit.getText()).trim();

        /* 写到哪里：`opts.write` 优先（取材清单这类不在字段表里的值），
         * 否则写 Store（绝大多数控件走这条）。 */
        if (hasWriter) {
            opts.write(raw);
            if (opts.onCommitted) { opts.onCommitted(raw); }
            return true;
        }

        if (numeric) {
            if (raw === "") { return false; }
            var n = Number(raw);
            if (isNaN(n)) { return false; }
            Store.set(opts.path, n);
        } else {
            Store.set(opts.path, raw);
        }
        /* 上界不得小于下界。★ 只让**兄弟**刷新（回调由调用方提供），
         * 绝不能刷自己这一格 —— 用户可能正在其中打字。 */
        if (syncCrossRules() && opts.onLinkedChange) { opts.onLinkedChange(); }
        return true;
    }

    edit.setText(readStore());
    lastText = String(edit.getText());

    edit.addTextChangedListener(new android.text.TextWatcher({
        beforeTextChanged: function () { },
        onTextChanged: function () { },
        afterTextChanged: function (editable) {
            if (writing || !bound) { return; }

            var now = String(editable === null || editable === undefined ? "" : editable);
            var isBackspacing = lastText.length > now.length && lastText.indexOf(now) === 0;
            lastText = now;

            /* 见函数头第 ★ 条：数字框退格期间不落盘，等失焦时一次提交 */
            if (numeric && isBackspacing) { return; }
            commit();
        }
    }));

    /* 失焦：先提交（把退格期间跳过的编辑落地），再回写正规化后的值 ——
     * 没有后一步，用户永远看不到「99999 其实被夹到了 500」。 */
    edit.setOnFocusChangeListener(new android.view.View.OnFocusChangeListener({
        onFocusChange: function (view, hasFocus) {
            edit.setBackground(hasFocus ? activeBg : idleBg);
            if (hasFocus) { return; }
            commit();
            paint();
            if (opts.onBlur) { opts.onBlur(); }
        }
    }));

    var handle = {
        root: edit,
        edit: edit,
        paint: paint,
        commit: commit,
        value: function () { return String(edit.getText()).trim(); }
    };

    /* 登记进「本页待提交输入框」：切页签 / 按开始运行这类**不会先失焦**的动作
     * 之前要整体提交一次，否则「只退格、没失焦就走」的那次编辑会丢。
     * 绑 Store 字段的进 pendingFields（审计会据此判断"这个字段有控件"），
     * 绑 Sources 之类非字段值的进 pendingExtra（不进审计口径）。 */
    if (bound) {
        if (typeof opts.path === "string" && opts.path !== "") {
            W.pendingFields[opts.path] = handle;
        } else {
            W.pendingExtra.push(handle);
        }
    }

    return handle;
};

/* path → 输入框。**每次渲染页面开始时清空**（见 W.beginPage）——
 * 留成全局累积的话，切走的那一页的输入框还挂在表里，
 * 后面任意一次提交都会把它的旧文字重新写回配置，把别处刚改的值顶掉。 */
W.pendingFields = {};

/** 开始渲染一个新页面：清空待提交表。调用方要先 `commitPendingInputs()` 再调这个。 */
W.beginPage = function () {
    W.pendingFields = {};
    W.pendingExtra = [];
};

/* 不绑定配置路径的输入框（例如 ID提取「取材清单」里的账号/关键词/路径）。
 * 与 pendingFields 分开是**必须的**：pendingFields 同时被取值审计当作
 * 「这个字段有界面控件」的证据，而取材字段根本不在字段表里 ——
 * 混在一起会让审计报「绑定了表外路径」。 */
W.pendingExtra = [];

/**
 * 提交当前页面上所有绑定过配置的输入框。
 *
 * 什么时候必须调：**页面要被重建 / 配置要被读取，而用户可能还停在某个输入框里**。
 * Android 里点一个不可聚焦的按钮并不会让 EditText 失焦，所以「按开始运行」时
 * 栏位内容可能还没落盘 —— 这正是「界面显示的值」和「真正跑起来的值」不一致的来源。
 */
W.commitPendingInputs = function () {
    for (var path in W.pendingFields) {
        if (W.pendingFields.hasOwnProperty(path)) {
            W.pendingFields[path].commit();
        }
    }
    for (var i = 0; i < W.pendingExtra.length; i++) {
        W.pendingExtra[i].commit();
    }
};

/**
 * 通用单选胶囊：**不绑 Store 路径**，选完只回调一个下标。
 *
 * 为什么需要它：`W.dropdown` 绑的是 `Store` 的一个枚举路径，
 * 而取材清单存在 `Sources` 里（不是字段），它的"起点 / 深度"这类选择只能走回调。
 *
 * @param opts.label     当前显示的文案
 * @param opts.options   候选文案数组
 * @param opts.index     当前下标（**函数**，点击时现算 —— 渲染之后状态可能已经变了）
 * @param opts.onPick    选中回调 (index)
 */
W.chooser = function (opts) {
    var chip = W.chip(opts.label, opts.tone || "default", opts.minWidthDp || 76);
    chip.root.setOnClickListener(function () {
        var current = typeof opts.index === "function" ? opts.index() : opts.index;
        if (current === undefined || current === null || current < 0) { current = 0; }
        Dialog.choose({
            options: opts.options,
            currentIndex: current,
            onConfirm: function (index) {
                chip.setText(opts.options[index]);
                opts.onPick(index);
            }
        });
    });
    return {
        root: chip.root,
        set: function (text) { chip.setText(text); }
    };
};

/**
 * 文本输入（关键词 / 主播区域 / 国家简码 / 云表名 / 文件路径）。
 *
 * 用 EditText 直接输入而不是 `dialogs.rawInput`：后者在 `"ui";` 模式下
 * 是阻塞式调用、拿不到返回值（老坑），而且多点一步。
 */
W.textField = function (path, placeholder, widthDp) {
    return W.inlineField({
        path: path,
        placeholder: placeholder,
        widthDp: widthDp || 108
    });
};

/**
 * 让跨字段约束立即生效（上界不得小于下界）。
 *
 * 拆成独立的上下限输入框之后，这个约束更容易被触发：
 * 用户可能先把上限改成 50、再回头改下限。没有这一步，界面上就会出现
 * 「下限 500 / 上限 50」这种自相矛盾的组合，要等下一次 load 才被纠正。
 *
 * 返回**是否发生了连带修改** —— 调用方据此决定要不要重绘整页。
 * 大多数情况下只改了自己那一项，不必重绘。
 */
function syncCrossRules() {
    var changed = false;
    for (var i = 0; i < Store.CROSS_RULES.length; i++) {
        var rule = Store.CROSS_RULES[i];
        var low = Store.getNumber(rule.low);
        var high = Store.getNumber(rule.high);
        if (high < low) {
            Store.set(rule.high, low);
            changed = true;
        }
    }
    return changed;
}

/**
 * 数字输入（设计稿里的「停止个数 1 ~ 5」「关注数量 100 ~ 200」都用它）。
 *
 * 第 4 个参数 onLinkedChange 用于「改这一项**连带改了别项**」的情形
 * （见 syncCrossRules）：把休息时间下限调到 2000，被抬齐的上限那一格也得刷新。
 * ★ 回调里只刷**兄弟**那一格，不刷自己 —— 自己这一格正被用户编辑着。
 */
W.numberField = function (path, hint, widthDp, onLinkedChange) {
    return W.inlineField({
        path: path,
        placeholder: hint,
        numeric: true,
        widthDp: widthDp || 56,
        onLinkedChange: onLinkedChange
    });
};

/**
 * 「最小值 ~ 最大值」——一行一个区间，两个数**各自独立、直接在栏位里改**。
 *
 * 与「上下限各占一行」的区别只在排版：
 *   · 两个数各自一个输入框，互不干扰（改最小值不会顺带动最大值）；
 *   · `~` 只是把「这两个数是一对」表达出来，不是把两个值塞进一个控件。
 * 一行放下之后功能设置卡短了一半，四个门槛不用滚很久才看完。
 *
 * 为什么不像开关那样拆成两行：开关是**两个独立的动作**（进行关注、进行私信），
 * 而这里的 min/max 是**同一个量的下界与上界**，分开写会让人以为
 * 「关注量下限」和「关注量上限」是两个互不相干的设置。
 *
 * ★ 联动（syncCrossRules）只刷**兄弟**那一格：用户正在输的那一格绝不能被回写抢输入。
 * 联动也不重建整页 —— 重建会把滚动位置清零，用户刚滚到功能设置区就被弹回顶部。
 */
W.rangeRow = function (pathMin, pathMax, label, separator, widthDp) {
    var minField = null;
    var maxField = null;
    var w = widthDp || 56;

    minField = W.numberField(pathMin, "", w, function () {
        if (maxField) { maxField.paint(); }
    });
    maxField = W.numberField(pathMax, "", w, function () {
        if (minField) { minField.paint(); }
    });

    var line = U.row();
    line.addView(U.text(label, Theme.m.labelSize, Theme.hex.textSecondary, false));
    line.addView(U.flexible());
    line.addView(minField.root);
    line.addView(U.hgap(6));
    line.addView(U.text(separator || "~", Theme.m.labelSize, Theme.hex.textMuted, false));
    line.addView(U.hgap(6));
    line.addView(maxField.root);

    return {
        root: line,
        values: function () {
            return { min: Store.getNumber(pathMin), max: Store.getNumber(pathMax) };
        }
    };
};

/* ------------------------------------------------------------ 文件选择行 */

/**
 * 弹出文件列表并把选中结果写进 store，然后回调刷新。
 *
 * 列文件交给 Device，弹窗交给 Dialog —— 用 `dialogs.select` 的话
 * 在 UI 模式下拿不到返回值，选文件会静默失效（老坑）。
 */
function pickTextFileInto(storePath, onPicked) {
    var list = Device.listTextFiles();
    if (list.length === 0) {
        Dialog.alert("未找到可用文件",
            "把 .txt / .json / .csv 文件放到 /sdcard/Download 下，\n" +
            "回到这里就能选到了。");
        return;
    }
    Dialog.choose({
        title: "选择文件",
        options: list,
        currentIndex: 0,
        onConfirm: function (index) {
            var picked = list[index];
            /* storePath 可以为空：取材清单这类"不在字段表里的路径"只走回调，
             * 不写 Store（否则会往配置里塞一个表外字段）。 */
            if (storePath) { Store.set(storePath, picked); }
            if (onPicked) { onPicked(picked); }
            toast("已选择：" + picked);
        }
    });
}

/**
 * 独立的「选择文件」按钮。
 *
 * 单独抽出来是因为 ID提取页的「使用文本 ID」那一行是
 * 「勾选框 + 弹性占位 + 路径框 + 按钮」的结构，而 filePicker 会自带一个左侧标签，
 * 直接复用会出现同一行两个标签。
 */
W.filePickerButton = function (storePath, onPicked, label) {
    var button = W.chip(label || "\u9009\u62E9\u6587\u4EF6", "accent");
    button.root.setOnClickListener(function () { pickTextFileInto(storePath, onPicked); });
    return button;
};

/**
 * 「路径框 + 选择文件」组合行。设计稿里凡是「随机私信文本 / 已筛 UID 文本」都用它。
 *
 * 路径本身就是个文本值，所以它也是**可直接编辑**的输入框（可以手输/粘贴路径，
 * 不一定非得走「选择文件」）。文件不存在时把字调暗，让「配了路径但文件没放」
 * 一眼看得出来。
 */
W.filePicker = function (label, storePath, buttonLabel) {
    var field = W.inlineField({
        path: storePath,
        placeholder: "\u6587\u672C\u8DEF\u5F84",
        widthDp: 108,
        align: "right"
    });

    function refreshPath() {
        field.paint();
        var p = Store.getText(storePath);
        var exists = false;
        try {
            exists = p !== "" && files.exists(p);
        } catch (e) {
            exists = false;
        }
        field.edit.setTextColor(U.argb(p === ""
            ? Theme.hex.textFaint
            : (exists ? Theme.hex.textSecondary : Theme.hex.textMuted)));
    }
    refreshPath();

    var button = W.filePickerButton(storePath, refreshPath, buttonLabel);

    var nameView = U.text(label, Theme.m.labelSize, Theme.hex.textSecondary, false);
    nameView.setSingleLine(true);

    var line = U.row();
    line.addView(nameView);
    line.addView(U.flexible());
    line.addView(field.root);
    line.addView(U.hgap(6));
    line.addView(button.root);

    return { root: line, field: field, refreshPath: refreshPath };
};

/* ------------------------------------------------------------ 底部渐隐 */

/**
 * 内容区底部渐隐（规格书 §6：y=577 h=80）。
 *
 * 放在内容区与底栏之间，从透明渐变到**页面底色**：
 *   · 内容超出屏幕时，卡片被底栏硬切一刀的观感消失，一眼看出还能滚；
 *   · 内容没超出时它叠在空背景上（透明 → 背景色 = 背景色），看不出多余色块。
 * 绝对定位、不吃点击（否则底栏上面那 80dp 就点不动了）。
 */
W.bottomFade = function () {
    var view = new android.view.View(context);
    view.setBackground(U.fadeBg(Theme.hex.bg));
    view.setClickable(false);
    view.setFocusable(false);
    var lp = new android.widget.FrameLayout.LayoutParams(-1, U.dp(Theme.m.fadeHeight));
    lp.gravity = android.view.Gravity.BOTTOM;
    view.setLayoutParams(lp);
    return view;
};

/** 空态（记录 D2）：图标框 + 主文案 + 副文案，整块居中。 */
W.emptyState = function (iconChar, title, subtitle) {
    var box = U.column();
    box.setGravity(android.view.Gravity.CENTER);

    var iconBox = U.text(iconChar, 28, Theme.hex.tabIdle, false);
    iconBox.setGravity(android.view.Gravity.CENTER);
    iconBox.setBackground(U.tintBg("#FFFFFF", 0.05, 20));
    U.params(iconBox, 64, 64);
    box.addView(iconBox);

    box.addView(U.spacer(16));

    var head = U.text(title, 14, Theme.hex.tabIdle, false);
    head.setGravity(android.view.Gravity.CENTER);
    box.addView(head);
    box.addView(U.spacer(6));

    var sub = U.text(subtitle, Theme.m.hintSize, Theme.hex.textDim, false);
    sub.setGravity(android.view.Gravity.CENTER);
    box.addView(sub);

    /* weight=1 撑满剩余高度 → 整块垂直居中（不能靠 gravity，父容器是滚动的） */
    var outer = U.column();
    U.params(outer, -1, 0, 1);
    outer.setGravity(android.view.Gravity.CENTER);
    outer.addView(box);
    return outer;
};

/* ------------------------------------------------------------ 返回头 */

/**
 * 二级页返回头（规格书 §6：高 44，返回热区 44×44，标题 21 SemiBold）。
 *
 * 热区必须做满 44×44：箭头字形只有 20dp，只让它可点的话真机上很难戳中
 * （触控标准里专门写了「返回热区 44×44」）。
 *
 * @param onBack      返回回调
 * @param onSettings  右侧设置入口（只有 ID提取 C1 有），不传则不渲染
 */
W.backHeader = function (title, onBack, onSettings) {
    var arrow = U.text("\u2039", 22, Theme.hex.textPrimary, false);
    arrow.setGravity(android.view.Gravity.CENTER);

    var hot = U.row(false);
    hot.setGravity(android.view.Gravity.CENTER);
    U.params(hot, Theme.m.backHotSize, Theme.m.backHotSize);
    hot.addView(arrow);
    hot.setOnClickListener(function () { if (onBack) { onBack(); } });

    var head = U.row();
    head.addView(hot);
    head.addView(U.hgap(4));

    var titleView = U.text(title, Theme.m.detailTitleSize, Theme.hex.textPrimary, true);
    titleView.setSingleLine(true);
    titleView.setEllipsize(android.text.TextUtils.TruncateAt.END);
    head.addView(titleView);
    head.addView(U.flexible());

    if (onSettings) {
        var gear = U.text("\u2699", 18, Theme.hex.textSecondary, false);
        gear.setGravity(android.view.Gravity.CENTER);
        U.params(gear, 22, 22);
        gear.setOnClickListener(function () { onSettings(); });
        head.addView(gear);
    }
    return head;
};

/* ------------------------------------------------------------ 状态徽标 */

/**
 * 环形小徽标（任务卡的状态：「空闲 / 运行中 / 未配置」）。
 *
 * 与 W.pill 分开是因为**内边距不同**：pill 是 6/6（给「已安装 v39.5.4」这类
 * 有内容的标签），徽标是 8/3 —— 三四个字的小标签用 6dp 上下留白会胖得像个按钮。
 */
W.badge = function (label, tone) {
    var t = W.TONES[tone || "mute"] || W.TONES["mute"];
    var view = U.text(label, Theme.m.chipSize, t.text, true);
    view.setGravity(android.view.Gravity.CENTER);
    view.setSingleLine(true);
    view.setBackground(U.solidBg(U.alphaOf("#FFFFFF", t.fill), Theme.m.pillRadius));
    view.setPadding(U.dp(Theme.m.badgePadH), U.dp(Theme.m.badgePadV),
                    U.dp(Theme.m.badgePadH), U.dp(Theme.m.badgePadV));
    return {
        root: view,
        setText: function (v) { view.setText(String(v)); },
        setTone: function (next) { W.paintTone(view, next, Theme.m.pillRadius); }
    };
};

/* ------------------------------------------------------------ 任务卡 / 记录条目 */

/**
 * 同色图标框（任务卡 40 / 记录条目 36）。
 * tint 传 hex，alpha 固定取 Theme.alpha.iconBoxFill（14%，设计稿取值）。
 */
function iconBoxTint(hex, sizeDp, radiusDp, iconChar, iconSp) {
    var box = U.text(iconChar, iconSp, hex, false);
    box.setGravity(android.view.Gravity.CENTER);
    box.setBackground(U.tintBg(hex, Theme.alpha.iconBoxFill, radiusDp));
    U.params(box, sizeDp, sizeDp);
    return box;
}

W.taskIconBox = function (hex, iconChar) {
    return iconBoxTint(hex, Theme.m.taskIconBox, Theme.m.taskIconRadius,
                       iconChar, Theme.m.taskIconSize);
};

W.recordIconBox = function (hex, iconChar) {
    return iconBoxTint(hex, Theme.m.recordIconBox, Theme.m.recordIconRadius,
                       iconChar, Theme.m.recordIconSize);
};

/**
 * 任务卡（B1/B2）。
 *
 * 结构：图标框 · [任务名 + 状态徽标] / 当前脚本 / 上次运行 · 运行按钮。
 *
 * 两个必须做对的地方：
 *   ① 点卡片主体 = 进详情页；点「运行」按钮 = 直接跑 —— **两个命中区**。
 *      合成一个的话，用户想进去改配置却把脚本跑起来了。
 *   ② 运行中**不禁用**其他任务的按钮（规格书 §2.3：「按钮仍然可点，
 *      点击后弹 F3 确认，不做禁用」）。禁用会让用户以为"卡死了"。
 *
 * @param opts.onOpen  点卡片主体
 * @param opts.onRun   点运行/停止按钮
 */
W.taskCard = function (opts) {
    var badge = W.badge(opts.badge, opts.badgeTone);

    var nameLine = U.row(false);
    nameLine.addView(U.text(opts.name, Theme.m.taskNameSize, Theme.hex.textPrimary, true));
    nameLine.addView(U.hgap(8));
    nameLine.addView(badge.root);

    var textGroup = U.column();
    textGroup.addView(nameLine);
    textGroup.addView(U.spacer(4));
    textGroup.addView(U.text(opts.scriptLine, Theme.m.chipSize, Theme.hex.textFaint, false));
    textGroup.addView(U.spacer(4));
    textGroup.addView(U.text(opts.lastLine, Theme.m.chipSize, Theme.hex.textDim, false));

    /* 运行按钮：默认渐变，运行中那一个换成次级样式（设计稿 B2 的「停止」）。 */
    var btnLabel = U.text(opts.running ? "\u505C\u6B62" : "\u8FD0\u884C",
                          Theme.m.sectionSize - 1, "#FFFFFF", true);
    btnLabel.setGravity(android.view.Gravity.CENTER);
    var button = new android.widget.FrameLayout(context);
    button.setBackground(opts.running
        ? U.solidBg(U.alphaOf("#FFFFFF", 0.08), Theme.m.pillRadius)
        : U.gradientBg(Theme.hex.accent, Theme.hex.accentDeep, Theme.m.pillRadius));
    U.params(button, Theme.m.taskRunBtnW, Theme.m.taskRunBtnH);
    button.addView(btnLabel);
    if (opts.onRun) { button.setOnClickListener(function () { opts.onRun(); }); }

    var card = U.column();
    card.setBackground(U.strokeBg(Theme.alpha.cardFill, Theme.alpha.cardStroke,
                                  "#FFFFFF", Theme.m.cardRadius));
    card.setPadding(U.dp(Theme.m.cardPadding), U.dp(Theme.m.cardPadding),
                    U.dp(Theme.m.cardPadding), U.dp(Theme.m.cardPadding));

    var line = U.row();
    var iconBox = W.taskIconBox(opts.colorHex, opts.iconChar);
    line.addView(iconBox);
    line.addView(U.hgap(12));
    /* 文本组用 weight=1 撑开：右侧是固定宽 68 的按钮，不会把标签挤成 0 宽
     * （0 宽那类问题只在右侧控件是 MATCH_PARENT 时出现，见 W.settingRow 注释）。 */
    U.params(textGroup, 0, -2, 1);
    line.addView(textGroup);
    line.addView(U.hgap(12));
    line.addView(button);
    card.addView(line);

    /**
     * ★ 点卡片 = 进详情页。**每一块可点区域都要显式挂一次**，不能只挂根容器。
     *
     * 真机踩过（2026-10-13，用户反馈「点任务卡上的脚本进不去参数设置」）：
     * 原先这里写了一句 `line.setOnClickListener(null)`，本意是"行内不挂监听、让气泡到卡片"。
     * 但 AutoX 的桥对 `null` 并不保证是"清掉监听"—— 它很可能装上一个
     * **吃掉点击却什么都不做**的空监听。于是：
     *   · 点「运行」按钮 → 有反应（按钮是它自己的子视图，装着真监听）；
     *   · 点卡片的其他任何地方 → 毫无反应（触摸被那一层吞了，到不了 card）。
     * 两件事实拼起来才知道问题在哪 —— 单看"按钮能用"会以为点击链路是好的。
     *
     * 所以现在 card / 图标框 / 文本组 各挂一次同一个回调：
     * 谁接到都做同一件事，既不依赖气泡顺序，也不怕中间某层被点成 clickable。
     */
    if (opts.onOpen) {
        var openDetail = function () { opts.onOpen(); };
        card.setOnClickListener(openDetail);
        iconBox.setOnClickListener(openDetail);
        textGroup.setOnClickListener(openDetail);
    }
    return { root: card, badge: badge, button: button, iconBox: iconBox, textGroup: textGroup };
};

/**
 * 记录条目（D1）。
 *
 * 结构：图标框 · [任务 · 脚本 + 结果标签] / 时间行 / 结果行 · 右箭头。
 * 结果行按结果分类换色（报错那条是玫瑰红，一眼能在列表里挑出来）。
 */
W.recordRow = function (opts) {
    var titleLine = U.row(false);
    titleLine.addView(U.text(opts.title, Theme.m.labelSize, Theme.hex.textPrimary, true));
    titleLine.addView(U.hgap(8));
    titleLine.addView(W.badge(opts.resultLabel, opts.resultTone).root);

    /* 可选动作槽（现在只有「继续」用它）。
     * 按钮作为子 View 单独挂监听 —— 子 View 会自己消费点击，
     * 不会冒泡到整卡的 onOpen，所以"点按钮续跑、点别处进详情"两件事互不干扰。
     * `W.checkRow` 里处理同一问题的手法可以对照着看。 */
    if (opts.actionLabel) {
        var action = W.smallButton(opts.actionLabel, opts.actionTone || "accent",
                                   function () {
                                       if (opts.onAction) { opts.onAction(); }
                                   });
        titleLine.addView(U.flexible());
        titleLine.addView(action.root);
    }

    var resultColor = opts.resultTone === "danger" ? Theme.hex.danger : Theme.hex.textDim;

    var textGroup = U.column();
    textGroup.addView(titleLine);
    textGroup.addView(U.spacer(4));
    textGroup.addView(U.text(opts.timeLine, Theme.m.chipSize, Theme.hex.textFaint, false));
    if (opts.resultLine) {
        textGroup.addView(U.spacer(4));
        textGroup.addView(U.text(opts.resultLine, Theme.m.chipSize, resultColor, false));
    }

    var line = U.row();
    line.addView(W.recordIconBox(opts.colorHex, opts.iconChar));
    line.addView(U.hgap(12));
    U.params(textGroup, 0, -2, 1);
    line.addView(textGroup);
    line.addView(U.hgap(8));
    line.addView(W.chevronRight(18, Theme.hex.textFaint));

    var card = U.column();
    card.setBackground(U.strokeBg(Theme.alpha.cardFill, Theme.alpha.cardStroke,
                                  "#FFFFFF", Theme.m.recordCardRadius));
    card.setPadding(U.dp(Theme.m.cardPadding), U.dp(Theme.m.cardPadding),
                    U.dp(Theme.m.cardPadding), U.dp(Theme.m.cardPadding));
    card.addView(line);
    if (opts.onOpen) { card.setOnClickListener(function () { opts.onOpen(); }); }
    return card;
};

/* ------------------------------------------------------------ 小按钮 / 标签按钮 */

/**
 * 小按钮（「打开 / 分享 / 复制 / 选择」这类行内操作）。
 * 尺寸 26 高 + 8 圆角，与胶囊（全圆角）区分开：胶囊是"状态/开关"，方块是"动作"。
 */
W.smallButton = function (label, tone, onClick, minWidthDp) {
    var chip = W.chip(label, tone || "default", minWidthDp, Theme.m.chipRadius);
    chip.root.setTextSize(Theme.m.chipSize);
    if (onClick) { chip.root.setOnClickListener(function () { onClick(); }); }
    return chip;
};


/* ------------------------------------------------------------ 主按钮 */

/**
 * 底部主按钮：青蓝→紫渐变，48 高，全圆角。文案随运行态在「开始运行 / 停止运行」间切换。
 */
W.runButton = function (onClick, text) {
    var label = U.text(text || "\u5F00\u59CB\u8FD0\u884C", Theme.m.sectionSize, "#FFFFFF", true);
    label.setGravity(android.view.Gravity.CENTER);

    var button = new android.widget.FrameLayout(context);
    button.setBackground(U.gradientBg(Theme.hex.accent, Theme.hex.accentDeep, Theme.m.pillRadius));
    U.params(button, -1, Theme.m.runBtnHeight);
    button.addView(label);
    if (onClick) { button.setOnClickListener(function () { onClick(); }); }

    return { root: button, label: label };
};

/** 次要说明文字（页面底部提示）。 */
W.hint = function (content, center) {
    var view = U.text(content, Theme.m.hintSize, Theme.hex.textFaint, false);
    if (center) { view.setGravity(android.view.Gravity.CENTER); }
    return view;
};

/**
 * 提示条：标题 + 一行说明 + 右侧动作按钮。
 *
 * 为什么单独做一个组件、而不是用 `W.hint` + `W.smallButton` 临时拼：
 * 同一种提示要出现在「ID提取页顶部」与「记录详情页」两处，拼两次必然长歪；
 * 而且 `W.hint` 没有描边，直接在玻璃背景上会"浮"在卡片外 ——
 * 这个界面的分层靠的就是 `U.strokeBg` 的描边（`W.card` 同理）。
 *
 * @param opts { title, detail, tone:'warn'|'accent'|'mute'|'ok', actions:[{label,tone,onClick}] }
 * @returns { root, setTitle, setDetail }
 */
W.noticeBar = function (opts) {
    var o = opts || {};
    var tone = o.tone || "warn";
    var t = W.TONES[tone] || W.TONES["warn"];

    var box = U.column();
    box.setBackground(U.strokeBg(0.10, 0.24, t.text, Theme.m.cardRadius));
    box.setPadding(U.dp(12), U.dp(12), U.dp(12), U.dp(12));

    var title = U.text(o.title || "", Theme.m.labelSize, t.text, true);
    box.addView(title);

    var detail = null;
    if (o.detail) {
        box.addView(U.spacer(4));
        detail = U.text(o.detail, Theme.m.chipSize, Theme.hex.textDim, false);
        box.addView(detail);
    }

    var actions = o.actions || [];
    if (actions.length > 0) {
        var row = U.row();
        row.addView(U.flexible());
        for (var i = 0; i < actions.length; i++) {
            if (i > 0) { row.addView(U.hgap(8)); }
            /* 用闭包把当前这一项绑住：直接在循环里引用 actions[i] 会因为
             * 点击时才求值而全指向最后一项（这类"全点成同一个"极难发现）。 */
            var btn = W.smallButton(actions[i].label, actions[i].tone || "accent",
                                    (function (one) {
                                        return function () {
                                            if (one && one.onClick) { one.onClick(); }
                                        };
                                    }(actions[i])));
            row.addView(btn.root);
        }
        box.addView(U.spacer(10));
        box.addView(row);
    }

    return {
        root: box,
        setTitle: function (text) { title.setText(text); },
        setDetail: function (text) { if (detail) { detail.setText(text); } }
    };
};

/* ------------------------------------------------------------ 底部页签 */

/* 页签顺序即设计稿从左到右的顺序。
 *
 * ★ 2026-10-13 规格书 §1：底栏只有 **3 个 tab**（任务 / 记录 / 我的）。
 *   原来的「ID提取 / UID私信 / 养号 / 视频功能」四个页签
 *   降级为「任务」tab 里的四张任务卡（见 Pages.TASKS）。
 *
 * 图标一律用 U+25xx 几何块字符，**不要用 U+2709 这类有 emoji 变体的码位**——
 * Android 上即使追加 U+FE0E（文本变体选择符）也常被渲染成彩色 emoji，
 * 在深色界面里非常突兀（实测踩过）。换成 PNG 图标只需改这里的 icon 字段。 */
W.TABS = [
    { key: "tasks",   icon: "\u25A3", label: "\u4EFB\u52A1" },
    { key: "records", icon: "\u25F4", label: "\u8BB0\u5F55" },
    { key: "mine",    icon: "\u25C9", label: "\u6211\u7684" }
];

W.tabBar = function (activeKey, onSelect) {
    var bar = U.row();
    bar.setGravity(android.view.Gravity.CENTER);

    for (var i = 0; i < W.TABS.length; i++) {
        var tab = W.TABS[i];
        var color = tab.key === activeKey ? Theme.hex.accent : Theme.hex.tabIdle;

        var icon = U.text(tab.icon, 16, color, false);
        icon.setGravity(android.view.Gravity.CENTER);
        var label = U.text(tab.label, Theme.m.tabSize, color, true);
        label.setGravity(android.view.Gravity.CENTER);

        var item = U.column();
        item.setGravity(android.view.Gravity.CENTER);
        item.addView(icon);
        item.addView(U.spacer(4));
        item.addView(label);
        U.params(item, 0, Theme.m.tabBarHeight, 1);

        (function (key) {
            item.setOnClickListener(function () { onSelect(key); });
        })(tab.key);

        bar.addView(item);
    }
    return bar;
};

/* ------------------------------------------------------------ 全局运行条 */

/**
 * 全局运行条（规格书 §2.4 / 设计稿 B2 的 30:304）。
 *
 * 位置：内容区**上方**（状态栏之下），仅「运行中」时出现，空闲/完成整条隐藏。
 * 内容：运行点 · {任务名} · 脚本X · 运行中 + 右侧等宽计时。
 * 报错态：整条变玫瑰红、文案换成「执行出错已停止」、右侧「已终止」。
 *
 * 分工是刻意的：**运行条只管状态与导航（可点击跳回运行中的任务），
 * 停止由页面底部的 CTA 负责** —— 条上不放停止按钮，
 * 否则"点一下条"到底会停止还是跳转，用户没法预期。
 *
 * 计时用等宽字：数字每秒在变，比例字宽会让整条轻微抖动。
 */
W.runBar = function (text, elapsed, tone) {
    /* tone: "ok"（运行中）/ "warn"（正在收尾）/ "danger"（报错中断） */
    function toneColor(value) {
        if (value === "warn") { return Theme.hex.warn; }
        if (value === "danger") { return Theme.hex.danger; }
        return Theme.hex.ok;
    }

    var dot = U.text("\u25CF", 8, toneColor(tone), false);

    var label = U.text(text, 12, Theme.hex.textBody, true);
    label.setSingleLine(true);
    label.setEllipsize(android.text.TextUtils.TruncateAt.END);

    var time = U.monoText(elapsed, Theme.m.chipSize, toneColor(tone));

    var bar = U.row();
    bar.setGravity(android.view.Gravity.CENTER_VERTICAL);
    bar.setBackground(U.solidBg(U.alphaOf(tone === "danger" ? Theme.hex.danger : Theme.hex.accent,
                                         Theme.alpha.runBarFill), Theme.m.runBarRadius));
    bar.setPadding(U.dp(Theme.m.runBarPadH), U.dp(Theme.m.runBarPadV),
                   U.dp(Theme.m.runBarPadH), U.dp(Theme.m.runBarPadV));
    bar.addView(dot);
    bar.addView(U.hgap(8));
    /* 文案用 flexible 顶开：计时贴右端，长任务名先被省略号吃掉 */
    U.params(label, 0, -2, 1);
    bar.addView(label);
    bar.addView(U.hgap(8));
    bar.addView(time);

    return {
        root: bar,
        setText: function (v) { label.setText(String(v)); },
        setElapsed: function (v) { time.setText(String(v)); },
        /* 色调要能中途换：运行中是绿的，正在收尾是琥珀，报错中断是玫瑰红 ——
         * 三者都是"还在界面上"，但用户需要一眼看出它们不是一回事。 */
        setTone: function (v) {
            dot.setTextColor(U.argb(toneColor(v)));
            time.setTextColor(U.argb(toneColor(v)));
            bar.setBackground(U.solidBg(
                U.alphaOf(v === "danger" ? Theme.hex.danger : Theme.hex.accent,
                          Theme.alpha.runBarFill), Theme.m.runBarRadius));
        }
    };
};

/* ------------------------------------------------------------ 警示图标 */

/**
 * 弹窗顶部的警示图标（设计稿 16:952 / 16:1481）。
 *
 * 设计稿是一个描边矢量图标。这里改用字符 "!" —— 换成 ⚠(U+26A0) 在 Android 上
 * 会被渲染成彩色 emoji，加 U+FE0E 也压不住（页签图标踩过同一个坑）。
 * 底衬用同色 14% 圆角方块，视觉层级与设计稿一致。
 */
W.warnIcon = function (hex) {
    var view = U.text("!", 20, hex, true);
    view.setGravity(android.view.Gravity.CENTER);
    U.params(view, Theme.m.warnIconSize, Theme.m.warnIconSize);
    view.setBackground(U.solidBg(U.alphaOf(hex, Theme.alpha.warnFill), Theme.m.warnIconRadius));
    return view;
};

/* ------------------------------------------------------------ 弹窗按钮 */

/**
 * 主按钮（渐变色，弹窗内的「去授权 / 知道了 / 登录激活 / 确认」）。
 *
 * 与 W.runButton 的区别只在尺寸：主按钮吃满卡片宽度但只有 46~48 高，
 * 而开始运行按钮固定在页面底部。两者视觉必须一致，所以共用同一套渐变。
 */
W.primaryButton = function (label, heightDp, onClick) {
    var text = U.text(label, 15, "#FFFFFF", true);
    text.setGravity(android.view.Gravity.CENTER);

    var button = new android.widget.FrameLayout(context);
    button.setBackground(U.gradientBg(Theme.hex.accent, Theme.hex.accentDeep, Theme.m.pillRadius));
    U.params(button, -1, heightDp || 46);
    button.addView(text);
    if (onClick) { button.setOnClickListener(function () { onClick(); }); }
    return { root: button, label: text };
};

/** 实心危险按钮（「确认解绑」）：不可逆操作用纯色而不是渐变，视觉上更"重"。 */
W.dangerButton = function (label, heightDp, onClick) {
    var text = U.text(label, 15, "#FFFFFF", true);
    text.setGravity(android.view.Gravity.CENTER);

    var button = new android.widget.FrameLayout(context);
    button.setBackground(U.solidBg(U.argb(Theme.hex.danger), Theme.m.pillRadius));
    U.params(button, -1, heightDp || 44);
    button.addView(text);
    if (onClick) { button.setOnClickListener(function () { onClick(); }); }
    return { root: button, label: text };
};

/** 次级按钮（「取消」）：白 6% 填充 + 10% 描边。 */
W.ghostButton = function (label, heightDp, onClick) {
    var text = U.text(label, 15, Theme.hex.textSecondary, true);
    text.setGravity(android.view.Gravity.CENTER);

    var button = new android.widget.FrameLayout(context);
    button.setBackground(U.strokeBg(0.06, 0.10, "#FFFFFF", Theme.m.pillRadius));
    U.params(button, -1, heightDp || 44);
    button.addView(text);
    if (onClick) { button.setOnClickListener(function () { onClick(); }); }
    return { root: button, label: text };
};

/** 居中的次要文字链（「稍后再说」「购买卡密 · 联系客服」「退出应用」）。 */
W.link = function (label, hex, onClick) {
    var view = U.text(label, 13, hex, false);
    view.setGravity(android.view.Gravity.CENTER);
    /* 触摸目标补到 44dp：纯文字只有 ~16dp 高，直接点很难命中 */
    view.setPadding(U.dp(4), U.dp(12), U.dp(4), U.dp(12));
    if (onClick) { view.setOnClickListener(function () { onClick(); }); }
    return view;
};

/* ------------------------------------------------------------ 遮罩 */

W.mask = function (alpha) {
    var view = new android.view.View(context);
    view.setBackground(U.solidBg(U.alphaOf("#000000",
        alpha === undefined ? Theme.alpha.mask : alpha)));
    return view;
};

/* ------------------------------------------------------------ 容器工具 */

/** 重建页面用。 */
W.clear = function (container) {
    container.removeAllViews();
    return container;
};

/** 竖向滚动容器，页面内容区统一用它兜住超长内容。 */
W.scroller = function () {
    var scroll = new android.widget.ScrollView(context);
    scroll.setVerticalScrollBarEnabled(false);
    scroll.setOverScrollMode(android.view.View.OVER_SCROLL_NEVER);
    return scroll;
};


/* ============================== src/dialog.js ============================== */
/* ============================== src/dialog.js ==============================
 * 自绘弹窗体系：输入、选择、确认、提示、权限拦截。
 *
 * ── 为什么不用 AutoX 的 dialogs 模块 ───────────────────────────────
 * `"ui";` 模式下主线程就是 UI 线程。`dialogs.select(...)` / `dialogs.rawInput(...)`
 * 这类**不带 callback 的阻塞式调用**在这里拿不到返回值 —— 阻塞会死锁，
 * 所以运行时直接返回 undefined。表现是一连串很难查的现象：
 *   · 输入框「只能输一个值」：第一次调用返回 undefined，被当成「取消」，流程直接中断；
 *   · 下拉框选完写回 undefined（`Store.keyAt(group, undefined)`），
 *     配置被写坏，重启后又变回默认值；
 *   · 弹出来的是系统浅色对话框，跟深色界面完全不是一套视觉。
 *
 * 自己画弹窗同时解决这三点：取值走「确定」按钮的回调，
 * 不存在拿不到返回值的问题；样式也统一由 Theme 控制。
 *
 * 弹窗分两类，命名上刻意区分开：
 *   · 询问类（choose / confirm）—— 用户点了才知道结果；
 *   · 拦截类（runBlocked / permissionBlocked）—— 告诉用户「为什么跑不起来」。
 *   后者的标题统一是「无法开始运行」，与设计稿 08 / 12 一致。
 *
 * ⚠️ 这里**没有**输入类弹窗（askText / askNumber 已删除）。
 *    文本与数字一律用页面上的常驻输入框（`W.inlineField`）**直接改**——
 *    少一次点击，也少一层「弹窗里的值有没有被写回去」的不确定性。
 *    保留下来的弹窗都是**非输入**的：选一项、确认一次、被告知一次。
 *
 * 所有弹窗都挂在 Dialog.host（由 main.js 注入）上，同时只允许存在一个。
 */

var Dialog = {};

Dialog.WIDTH = 315;

/* 宿主容器与当前打开的弹窗 */
Dialog.host = null;
Dialog.active = null;

/** 由 main.js 在搭好骨架后注入浮层容器。 */
Dialog.mount = function (host) { Dialog.host = host; };

/**
 * 把弹窗挂到宿主上。
 * 挂之前先关掉已有弹窗——两层弹窗叠着关不掉，是这类自绘 UI 最容易出的岔子。
 */
function present(overlay) {
    if (!Dialog.host) {
        console.log("[dialog] 宿主未注入，弹窗无法显示");
        return null;
    }
    if (Dialog.active) { Dialog.active.close(); }

    var handle = {
        root: overlay,
        close: function () {
            var parent = overlay.getParent();
            if (parent) { parent.removeView(overlay); }
            if (Dialog.active === handle) { Dialog.active = null; }
        }
    };

    Dialog.active = handle;
    Dialog.host.addView(overlay);
    return handle;
}

/* ---------------------------------------------------------------- 骨架 */

/**
 * 弹窗底部按钮行。
 *
 * 设计稿里的弹窗按钮是**等宽铺满**的两枚（16:960 取消 / 确认解绑），
 * 或整行一枚（16:1068 知道了）。所以这里不接受「几个胶囊靠右排」的写法，
 * 一律按等分宽度布局——按钮宽度不等会让两个弹窗看起来不像一套。
 *
 * specs: [{ label, variant: "primary"|"danger"|"ghost", onClick }]
 */
function dialogButtons(specs) {
    var line = U.row();

    for (var i = 0; i < specs.length; i++) {
        var spec = specs[i];
        var height = spec.height || 46;
        var button = spec.variant === "danger" ? W.dangerButton(spec.label, height, spec.onClick)
                   : spec.variant === "ghost"  ? W.ghostButton(spec.label, height, spec.onClick)
                   : W.primaryButton(spec.label, height, spec.onClick);
        /* 宽度 0 + weight 1 = 与同行的兄弟等分剩余宽度 */
        U.params(button.root, 0, height, 1);
        if (i > 0) { line.addView(U.hgap(12)); }
        line.addView(button.root);
    }
    return line;
}

/**
 * 取消 + 确定 的成对按钮，绝大多数询问类弹窗都用它。
 *
 * ⚠️ 「确定」**不预先关窗**，是否关窗交给 onConfirm 自己决定。
 * 早先写成「先 close() 再 onConfirm()」，直接毁掉了输入类弹窗的关键行为：
 * 用户输了非法值，窗口已经关了，只能在原地提示的意图落空 ——
 * 他得重新点开、重新输入。校验逻辑写对了也没用，因为关窗发生得更早。
 */
function cancelConfirmRow(close, onConfirm, confirmLabel, confirmVariant) {
    return dialogButtons([
        { label: "\u53D6\u6D88", variant: "ghost", height: 44, onClick: close },
        { label: confirmLabel || "\u786E\u5B9A", variant: confirmVariant || "primary", height: 44,
          onClick: onConfirm }
    ]);
}

/** 单枚「知道了」。 */
function acknowledgeRow(close, label) {
    return dialogButtons([
        { label: label || "\u77E5\u9053\u4E86", variant: "primary", height: 46,
          onClick: function () { close(); } }
    ]);
}

/**
 * 弹窗骨架：遮罩 + 居中卡片。
 * 返回 { overlay, card }，调用方往 card 里塞内容。
 */
function buildSheet(title) {
    var overlay = new android.widget.FrameLayout(context);
    overlay.setLayoutParams(new android.widget.FrameLayout.LayoutParams(-1, -1));
    overlay.addView(W.mask(), new android.widget.FrameLayout.LayoutParams(-1, -1));

    var card = U.column();
    card.setBackground(U.strokeBg(0.06, 0.12, "#FFFFFF", Theme.m.dialogRadius));
    card.setPadding(U.dp(24), U.dp(24), U.dp(24), U.dp(24));
    /* 卡片必须吞掉点击：否则点卡片会冒泡到遮罩，把弹窗直接关掉 */
    card.setClickable(true);

    var lp = new android.widget.FrameLayout.LayoutParams(U.dp(Dialog.WIDTH), -2);
    lp.gravity = android.view.Gravity.CENTER;
    overlay.addView(card, lp);

    if (title) {
        card.addView(U.text(title, 18, Theme.hex.textPrimary, true));
        card.addView(U.spacer(10));
    }
    return { overlay: overlay, card: card };
}

/** 弹窗副标题（说明文字）。字号与设计稿一致：12sp / 行距 17。 */
function sheetNote(text) {
    var view = U.text(text, 12, Theme.hex.textMuted, false);
    view.setLineSpacing(U.dp(3), 1.0);
    return view;
}

/** 多行说明文字：弹窗里长文案要能换行。 */
function wrappedText(message) {
    var view = U.text(message, 12, Theme.hex.textMuted, false);
    view.setLineSpacing(U.dp(4), 1.0);
    return view;
}

/* ---------------------------------------------------------------- 提示 */

/** 极简提示：标题 + 说明 + 「知道了」。 */
Dialog.alert = function (title, message) {
    var sheet = buildSheet(title);
    var handle = null;

    sheet.card.addView(wrappedText(message));
    sheet.card.addView(U.spacer(20));
    sheet.card.addView(acknowledgeRow(function () { if (handle) { handle.close(); } }));

    handle = present(sheet.overlay);
    return handle;
};

/**
 * 「无法开始运行」拦截弹窗（单按钮形态，设计稿 16:1065）。
 * 与 alert 分开是因为**语义不同**：alert 是告知，这个是拦下了一次操作。
 * 分开之后调用点读起来就是「被拦了，因为……」，不用去猜 title 里该写什么。
 */
Dialog.runBlocked = function (message, onAcknowledge) {
    var sheet = buildSheet("\u65E0\u6CD5\u5F00\u59CB\u8FD0\u884C");
    var handle = null;

    sheet.card.addView(sheetNote(message));
    sheet.card.addView(U.spacer(20));
    sheet.card.addView(acknowledgeRow(function () {
        if (handle) { handle.close(); }
        if (onAcknowledge) { onAcknowledge(); }
    }));

    handle = present(sheet.overlay);
    return handle;
};

/**
 * 「该脚本的执行引擎尚未接入」（拦截弹窗）。
 *
 * 与 runBlocked 分开写，是因为两者要用户做的事完全不同：
 * runBlocked 是"你现在就能修好"（去勾一个脚本），
 * 这个是"暂时做不了"（引擎还没写）。混用一个弹窗会让用户白找一圈。
 */
Dialog.engineMissing = function (scriptName) {
    return Dialog.runBlocked(
        "\u300C" + scriptName + "\u300D\u7684\u6267\u884C\u5F15\u64CE\u5C1A\u672A\u63A5\u5165\u3002\n\n"
        + "\u76EE\u524D\u5DF2\u63A5\u5165\u5F15\u64CE\u7684\u662F\u300C\u89C6\u9891\u529F\u80FD\u300D"
        + "\u9875\u7684\u300C\u5173\u952E\u8BCD\u89C6\u9891\u529F\u80FD\u300D\u3002");
};

/** 「引擎起不来」——缺产物、缺关键词、启动报错。message 里带可操作的指引。 */
Dialog.engineUnavailable = function (message) {
    return Dialog.runBlocked(message);
};

/**
 * F3 切换任务确认（设计稿 30:1011）。
 *
 * 全局单跑（规格书 §2.3）：运行中点别的任务的「运行」**不禁用按钮**，
 * 而是弹这个确认。禁用按钮会让用户以为"卡死了"，
 * 而"先停旧的再起新的"是一个明确的、可以自己决定的后果。
 *
 * 标题里的运行中任务名是**真实读出来的**（Pages.taskName(Session.tab)），
 * 不是固定文案 —— 用户需要知道到底是"谁"要被停掉。
 */
Dialog.switchTask = function (runningName, targetName, onConfirm) {
    var sheet = buildSheet(runningName + "\u6B63\u5728\u8FD0\u884C");
    var handle = null;

    sheet.card.addView(sheetNote(
        "\u5F00\u59CB " + targetName + " \u5C06\u5148\u505C\u6B62\u5F53\u524D\u811A\u672C\uFF08\u5168\u5C40\u5355\u8DD1\uFF09"));
    sheet.card.addView(U.spacer(20));
    sheet.card.addView(cancelConfirmRow(
        function () { if (handle) { handle.close(); } },
        function () {
            if (handle) { handle.close(); }
            /* 先停旧的、再起新的：停止是**请求式**的（写 stop.flag），
             * 不等它回执就起新引擎 —— 两边 runId 不同，
             * 旧引擎的终态回报会被界面按 runId 过滤掉，不会污染新一轮。 */
            App.stopRun();
            if (onConfirm) { onConfirm(); }
        },
        "\u505C\u6B62\u5E76\u5F00\u59CB"
    ));

    handle = present(sheet.overlay);
    return handle;
};

/**
 * H5 停止二次确认（规格书 §10.6）。
 *
 * 悬浮球上的「停止」一定要确认：它浮在别的应用上，误触的概率远高于 App 内的按钮，
 * 而停止的后果是**进度不保留**（下次从开头重跑）。
 * 反过来「运行」不确认 —— 起跑是可逆的（再点一次停止即可），
 * 两个动作的风险不对称，确认门槛也就不该一样。
 */
Dialog.stopScript = function (scriptName, elapsedText, onConfirm) {
    var sheet = buildSheet("\u505C\u6B62\u5F53\u524D\u811A\u672C\uFF1F");
    var handle = null;

    sheet.card.addView(sheetNote(String(scriptName) + " \u5DF2\u8FD0\u884C " + String(elapsedText)));
    sheet.card.addView(U.spacer(6));
    sheet.card.addView(sheetNote("\u505C\u6B62\u540E\u8FDB\u5EA6\u4E0D\u4FDD\u7559\uFF0C\u4E0B\u6B21\u5C06\u4ECE\u5F00\u5934\u91CD\u65B0\u5F00\u59CB"));
    sheet.card.addView(U.spacer(20));
    sheet.card.addView(cancelConfirmRow(
        function () { if (handle) { handle.close(); } },
        function () {
            if (handle) { handle.close(); }
            if (onConfirm) { onConfirm(); }
        },
        "\u505C\u6B62\u8FD0\u884C",
        "danger"
    ));

    handle = present(sheet.overlay);
    return handle;
};

/** H6 退出应用二次确认（规格书 §10.6 / §10.7：停脚本 + 关球 + 退到桌面）。 */
Dialog.exitApp = function (onConfirm) {
    var sheet = buildSheet("\u9000\u51FA\u98DE\u821F\u811A\u672C\uFF1F");
    var handle = null;

    sheet.card.addView(sheetNote("\u5C06\u505C\u6B62\u6B63\u5728\u8FD0\u884C\u7684\u811A\u672C\uFF0C\u5E76\u5173\u95ED\u60AC\u6D6E\u7403"));
    sheet.card.addView(U.spacer(6));
    sheet.card.addView(sheetNote("\u811A\u672C\u8FDB\u5EA6\u4E0D\u4FDD\u7559\uFF0C\u4E0B\u6B21\u8FD0\u884C\u5C06\u4ECE\u5F00\u5934\u91CD\u65B0\u5F00\u59CB"));
    sheet.card.addView(U.spacer(20));
    sheet.card.addView(cancelConfirmRow(
        function () { if (handle) { handle.close(); } },
        function () {
            if (handle) { handle.close(); }
            if (onConfirm) { onConfirm(); }
        },
        "\u9000\u51FA\u5E94\u7528",
        "danger"
    ));

    handle = present(sheet.overlay);
    return handle;
};

/**
 * F5 脚本报错（设计稿 30:1228）。
 *
 * 与 runBlocked / alert 都不同：它有两个出口，而且**两个出口都要给**——
 * 「查看日志」直接进 D3（用户想弄清楚为什么挂了），
 * 「知道了」只是收掉。合成一个按钮会逼用户在"看不到原因"和"被迫跳页"之间二选一。
 */
Dialog.scriptError = function (message, onViewLogs, onDismiss) {
    var sheet = buildSheet();
    var handle = null;

    /* 顶部警示图标：字符 "!" + 玫瑰色 14% 衬底（矢量图标在字符方案里见 W.warnIcon） */
    sheet.card.addView(W.warnIcon(Theme.hex.danger));
    sheet.card.addView(U.spacer(12));
    sheet.card.addView(U.text("\u811A\u672C\u6267\u884C\u51FA\u9519", 18, Theme.hex.textPrimary, true));
    sheet.card.addView(U.spacer(10));
    sheet.card.addView(sheetNote(message || "\u811A\u672C\u5DF2\u505C\u6B62\u8FD0\u884C"));
    sheet.card.addView(U.spacer(20));
    sheet.card.addView(dialogButtons([
        { label: "\u67E5\u770B\u65E5\u5FD7", variant: "ghost", height: 44, onClick: function () {
            if (handle) { handle.close(); }
            if (onViewLogs) { onViewLogs(); }
        } },
        { label: "\u77E5\u9053\u4E86", variant: "primary", height: 44, onClick: function () {
            if (handle) { handle.close(); }
            if (onDismiss) { onDismiss(); }
        } }
    ]));

    handle = present(sheet.overlay);
    return handle;
};

/** 确认：取消 / 确定，结果走回调。 */
Dialog.confirm = function (title, message, onConfirm) {
    var sheet = buildSheet(title);
    var handle = null;

    sheet.card.addView(wrappedText(message));
    sheet.card.addView(U.spacer(20));
    sheet.card.addView(cancelConfirmRow(
        function () { if (handle) { handle.close(); } },
        function () {
            if (handle) { handle.close(); }
            if (onConfirm) { onConfirm(); }
        }
    ));

    handle = present(sheet.overlay);
    return handle;
};

/* ---------------------------------------------------------------- 单选 */

/**
 * 单选弹窗。选项竖排，当前项高亮。
 * 比下拉列表更适合深色界面，也避免了下拉框「选完写回 undefined」那一类问题。
 */
Dialog.choose = function (opts) {
    var sheet = buildSheet(opts.title);
    var handle = null;
    var options = opts.options || [];

    for (var i = 0; i < options.length; i++) {
        var selected = i === opts.currentIndex;
        var item = U.text(options[i], Theme.m.labelSize,
                          selected ? Theme.hex.accentText : Theme.hex.textSecondary,
                          selected);
        item.setGravity(android.view.Gravity.CENTER_VERTICAL);
        item.setBackground(selected
            ? U.solidBg(U.alphaOf("#FFFFFF", Theme.alpha.accentChipFill), Theme.m.chipRadius)
            : U.solidBg(U.alphaOf("#FFFFFF", 0), Theme.m.chipRadius));
        item.setPadding(U.dp(12), U.dp(11), U.dp(12), U.dp(11));

        (function (index, view) {
            view.setOnClickListener(function () {
                if (handle) { handle.close(); }
                if (opts.onConfirm) { opts.onConfirm(index); }
            });
        })(i, item);

        if (i > 0) { sheet.card.addView(U.spacer(6)); }
        sheet.card.addView(item);
    }

    sheet.card.addView(U.spacer(20));
    sheet.card.addView(dialogButtons([
        { label: "\u53D6\u6D88", variant: "ghost", height: 44,
          onClick: function () { if (handle) { handle.close(); } } }
    ]));

    handle = present(sheet.overlay);
    return handle;
};

/* ---------------------------------------------------------------- 权限 */

/**
 * 单行权限：名称 + 状态标签。整行可点，点了直接跳对应设置页。
 *
 * 状态文案只有三种，集中在 W.pill 的 tone 里表达：
 *   已开启          → ok（青绿）
 *   未开启          → warn（琥珀）—— 这是阻断项
 *   未开启（可选）  → mute（灰）—— 不阻断，故意不抢注意力
 * 把「可选」写进标签本身，而不是靠颜色让用户猜，是这里最要紧的一点。
 */
function permissionRow(row) {
    var nameView = U.text(row.name, Theme.m.labelSize, Theme.hex.textPrimary, false);
    nameView.setSingleLine(true);

    var tone = row.granted ? "ok" : (row.optional ? "mute" : "warn");
    var text = row.granted ? "\u5DF2\u5F00\u542F"
                           : (row.optional ? "\u672A\u5F00\u542F\uFF08\u53EF\u9009\uFF09" : "\u672A\u5F00\u542F");
    var status = W.pill(text, tone);

    var line = U.row();
    line.addView(nameView);
    line.addView(U.flexible());
    line.addView(U.hgap(Theme.m.gapInline));
    line.addView(status.root);

    /* 整行都算命中区：可视高度只有 26dp 左右，
     * 不加高会低于 44dp 的最小触摸目标。 */
    line.setPadding(0, U.dp(9), 0, U.dp(9));
    line.setMinimumHeight(U.dp(Theme.m.touchTarget));
    line.setOnClickListener(function () {
        Device.openPermissionSettings(row.key);
    });

    return line;
}

/** 把三行权限按固定顺序铺进卡片。两个权限弹窗共用，避免顺序各写各的。 */
function stackPermissionRows(card) {
    var rows = Device.permissionRows();
    for (var i = 0; i < rows.length; i++) {
        if (i > 0) { card.addView(U.spacer(8)); }
        card.addView(permissionRow(rows[i]));
    }
    return rows;
}

/**
 * 「去授权」该跳哪一项。
 *
 * 规则：先找**阻断项**（未开启且非可选），都开了再退而处理可选的通知。
 * 早先的实现直接取第一个未授权项，会在「无障碍已开、通知没开」时
 * 把用户带到通知设置页 —— 而他真正缺的是悬浮窗。
 */
function firstPendingPermission() {
    var rows = Device.permissionRows();
    var i;
    for (i = 0; i < rows.length; i++) {
        if (!rows[i].granted && !rows[i].optional) { return rows[i]; }
    }
    for (i = 0; i < rows.length; i++) {
        if (!rows[i].granted) { return rows[i]; }
    }
    return null;
}

/** 权限行 + 去授权/稍后再说 的公共尾部。 */
function buildPermissionSheet(title, note) {
    var sheet = buildSheet(title);
    var handle = null;

    sheet.card.addView(sheetNote(note));
    sheet.card.addView(U.spacer(18));
    stackPermissionRows(sheet.card);
    sheet.card.addView(U.spacer(20));

    var go = W.primaryButton("\u53BB\u6388\u6743", 46, function () {
        var pending = firstPendingPermission();
        if (!pending) {
            toast("\u6743\u9650\u5DF2\u9F50\u5168");
            if (handle) { handle.close(); }
            return;
        }
        Device.openPermissionSettings(pending.key);
        /* 跳出去后不自动关闭：用户开了权限再退回来，
         * 留在弹窗上能让他看到状态已经变绿。 */
        toast("\u8BF7\u5F00\u542F\u300C" + pending.name + "\u300D\u540E\u8FD4\u56DE");
    });
    sheet.card.addView(go.root);

    /* 「稍后再说」按设计稿是纯文字，不占按钮位 */
    sheet.card.addView(W.link("\u7A0D\u540E\u518D\u8BF4", Theme.hex.textFaint, function () {
        if (handle) { handle.close(); }
    }));

    handle = present(sheet.overlay);
    return handle;
}

/**
 * 权限检测弹窗（设计稿 7:260）。
 * 只做展示与跳转，不自己改任何状态（检测与执行分离）。
 */
Dialog.showPermissions = function () {
    return buildPermissionSheet("\u9700\u8981\u5F00\u542F\u6743\u9650",
                                "\u4E3A\u6B63\u5E38\u6267\u884C\u811A\u672C\uFF0C\u8BF7\u5148\u6388\u4E88\u4EE5\u4E0B\u6743\u9650");
};

/**
 * 权限拦截弹窗（设计稿 16:436）。
 *
 * 与 showPermissions 的区别不是文案，而是**时机与语气**：
 * 前者是进 App 时的软引导，后者是用户按了「开始运行」却被挡回来；
 * 所以标题是「无法开始运行」，说明也直接点名缺哪两个权限。
 */
Dialog.permissionBlocked = function () {
    return buildPermissionSheet("\u65E0\u6CD5\u5F00\u59CB\u8FD0\u884C",
                                "\u65E0\u969C\u788D\u4E0E\u60AC\u6D6E\u7A97\u6743\u9650\u672A\u5F00\u542F\uFF0C\u811A\u672C\u65E0\u6CD5\u6267\u884C");
};

/* ------------------------------------------------------------ 危险操作确认 */

/**
 * 解绑卡密确认（设计稿 16:951）。
 *
 * 三件事必须同时说清，否则用户点完才后悔：
 *   ① 后果是什么（要重新输入卡密）；② 有没有更严重的连带影响（正在跑的会停）。
 * 确认按钮用实心红而不是渐变青蓝 —— 渐变在这套界面里代表「推荐动作」。
 */
Dialog.confirmUnbind = function (onConfirm) {
    var sheet = buildSheet(null);
    var handle = null;

    sheet.card.addView(W.warnIcon(Theme.hex.danger));
    sheet.card.addView(U.spacer(16));
    sheet.card.addView(U.text("\u786E\u8BA4\u89E3\u7ED1\u5361\u5BC6\uFF1F", 18, Theme.hex.textPrimary, true));
    sheet.card.addView(U.spacer(10));
    sheet.card.addView(sheetNote("\u89E3\u7ED1\u540E\u9700\u91CD\u65B0\u8F93\u5165\u5361\u5BC6\u624D\u80FD\u4F7F\u7528"));
    sheet.card.addView(U.spacer(4));
    sheet.card.addView(sheetNote("\u6B63\u5728\u8FD0\u884C\u7684\u811A\u672C\u5C06\u7ACB\u5373\u505C\u6B62"));
    sheet.card.addView(U.spacer(20));
    sheet.card.addView(cancelConfirmRow(
        function () { if (handle) { handle.close(); } },
        function () {
            if (handle) { handle.close(); }
            if (onConfirm) { onConfirm(); }
        },
        "\u786E\u8BA4\u89E3\u7ED1",
        "danger"
    ));

    handle = present(sheet.overlay);
    return handle;
};

/**
 * 卡密到期弹窗（设计稿 16:1480）。
 * 唯一的出口是「确认」，确认后回到登录页 —— 到期后留在主界面没有任何可做的事。
 */
Dialog.licenseExpired = function (onConfirm) {
    var sheet = buildSheet(null);
    var handle = null;

    sheet.card.addView(W.warnIcon(Theme.hex.warn));
    sheet.card.addView(U.spacer(16));
    sheet.card.addView(U.text("\u6B63\u5728\u8FD0\u884C\u7684\u811A\u672C\u5DF2\u505C\u6B62", 18, Theme.hex.textPrimary, true));
    sheet.card.addView(U.spacer(10));
    sheet.card.addView(sheetNote("\u5361\u5BC6\u5DF2\u5230\u671F\uFF0C\u9700\u91CD\u65B0\u767B\u5F55\u540E\u7EE7\u7EED\u4F7F\u7528"));
    sheet.card.addView(U.spacer(20));
    sheet.card.addView(dialogButtons([
        { label: "\u786E\u8BA4", variant: "primary", height: 46, onClick: function () {
            if (handle) { handle.close(); }
            if (onConfirm) { onConfirm(); }
        } }
    ]));
    sheet.card.addView(U.spacer(10));
    var tail = U.text("\u786E\u8BA4\u540E\u5C06\u8FD4\u56DE\u5361\u5BC6\u767B\u5F55\u754C\u9762",
                      11, Theme.hex.textFaint, false);
    tail.setGravity(android.view.Gravity.CENTER);
    sheet.card.addView(tail);

    handle = present(sheet.overlay);
    return handle;
};


/* ============================== src/floatball.js ============================== */
/* ============================== src/floatball.js ==============================
 * 全局悬浮球（规格书 §10 / 设计稿 H1–H7 `34:*`）。
 *
 * ## 它解决什么
 * 引擎必须待在 TikTok 前台才认得出页面，所以 App 内的「全局运行条」在真正
 * 干活的时候是看不见的。悬浮球浮在所有应用之上，是**跨 App 唯一的控制入口
 * 与运行状态可视处**（规格书 §10 的定位）。
 *
 * ## ★ 窗口层：两个 overlay 窗口，尺寸与位置恒定（2026-10-15 重做）
 *
 * **不要改回"一个窗口、展开时改尺寸"。** 那条路必然"跳"，而且顺序怎么排都躲不掉：
 * 改窗口尺寸/位置由系统（WindowManager，另一个进程）**立刻生效**，
 * 而我们这边的视图重排要等 App 下一帧重绘；中间那几帧，合成器显示的是
 * **上一帧的旧画面被摆到新的窗口矩形里**。用录屏逐帧验证过：展开那一刻球会
 * 从下往上"爬"几级才停 —— 就是用户说的"跳动"。
 * 两次失败的补救（都在真机上试过）：
 *   · 同一个 JS 调用里"先藏球、再改尺寸" —— 藏只是标记，改尺寸已经发出去了，照样跳；
 *   · "藏起来 → 等这一帧画完（onPreDraw）→ 再改尺寸" —— 合成器有 2~3 帧缓冲队列，
 *     它照样能把"藏之前"那一帧摆到新位置上去。
 * ⇒ 结论：只能**根本不改窗口几何**。两个窗口各自建好就永不动窝
 *   （只有用户拖动时球窗口才移，那是用户主动的动作）：
 *     · 球窗口 88×88dp：环 + 球 + 透明热区，永远可触摸；
 *     · 扇形窗口 308×264dp：4 个按钮 + 4 个标签，**折叠时整窗 NOT_TOUCHABLE**
 *       （触摸自动穿透到下面的 App，所以它的透明区不是死区），展开时才可触摸。
 *   于是"展开/收起"= 改显隐 + 改一个 flag，没有任何几何变化，没有任何东西会跳。
 *
 * ## ⚠️ 其他实测出来的约束（踩完才知道）
 * 1. 走**裸 WindowManager**（`addView` / `updateViewLayout` / `removeView`），
 *    而不是 AutoX 的 `floaty.window`：
 *    · `floaty.rawWindow(代码建的 View)` 直接不可用（缺 `toXMLString()`）；
 *    · `floaty` 的窗口会在内容外再套一圈 **12dp 内边距**（去不掉），几何全靠反推；
 *    · `floaty` 同时只能有一个窗口真正绘制（第二个建得出来但画不出来）；
 *    · `floaty` 默认还带一个调整手柄小点。
 *    裸窗口没有这些问题 —— 两个窗口能同时绘制是实测过的（`_probe/fb_two_windows.js`）。
 *    本模块用视图自己的 `setPadding` 复现了那圈 12dp 内边距，
 *    所以"球心在根视图里的坐标"这套算法一个字没改。
 * 2. **窗口的透明区同样会吃掉触摸**（实测：点它透明区里的输入框键盘不弹，
 *    点窗口外就弹）。所以折叠时扇形窗口必须 NOT_TOUCHABLE，否则那是一片死区。
 * 3. 覆盖窗口必须 `FLAG_NOT_FOCUSABLE`（§10.9④），否则会抢 TikTok 的键盘焦点。
 * 4. `WindowManager.LayoutParams` 的 x/y/w/h 都是**像素**，dp 换算只在 `dp()` 里做。
 * 5. **UI 线程禁止 `sleep()`** —— 本模块所有时序一律 `setTimeout` / `setInterval`。
 * 6. 图片只能 `images.read(path).bitmap` + `setImageBitmap(bmp)`；
 *    XML 的 `src="…"` 走的是 drawable 查找，**不吃文件路径**（会 InflateException）。
 *
 * ## 与规格书的对应
 *   §10.1  Ø48 球 / 透明热区 64 / 扇形 R=96 / 子按钮 Ø48 / 夹角 60°20°−20°−60°
 *   §10.3  扇形四个按钮：运行·停止 / 回到 App / 隐藏悬浮球 / 退出应用
 *   §10.4  三态靠**外环**表达（空闲无环 / 运行中青绿 22% / 报错玫瑰 20%），
 *          球内**恒定**是品牌图标（避免"球里是播放键 → 以为点了就运行"的歧义）
 *   §10.5  单击 = 展开收起；拖动 > 8px = 移动；松手吸附最近边缘并记忆位置
 *   §10.11 球在右侧时扇形**镜像向左展开**、标签移到按钮左侧
 */

var FB = {};

/* ------------------------------------------------------------ 常量（对齐 §10.1） */

FB.DIAM = 48;          // 球体直径
FB.HOT = 64;           // 透明热区（球的触控目标比视觉大）
FB.R = 96;             // 扇形半径
FB.SUB = 48;           // 子按钮直径
FB.LABEL_H = 24;       // 标签胶囊高
FB.ANGLES = [60, 20, -20, -60];   // 扇形夹角（以球心为原点，向右展开）
FB.PAD = 12;           // ⚠️ 悬浮窗根视图的固定内边距（实测，不能改）
FB.SLOP = 8;           // 拖动判定阈值：位移 > 8px 才算拖动，否则是单击
FB.EDGE = 12;          // 贴边留白（§10.1 左边距 12）
FB.BRAND = "/sdcard/tiktok_app/brand/FluxRpa_mark_only_412.png";

/**
 * 球的窗口矩形发布给引擎（规格书 §10.9③ 的另一半）。
 *
 * 为什么需要它：球浮在所有应用之上，引擎的**坐标手势**点到球位就点到了球
 * （实测：搜索建议列表的一条正好压住球位 → 点出了扇形面板）。
 * 引擎侧 `ui.js` 的 clickNode 在读这个文件做避让，所以界面这边必须**如实发布**
 * 球的窗口矩形（比球大一圈，因为窗口的透明区同样会吃掉触摸）。
 */
FB.RECT_PATH = "/sdcard/tiktok_app/ball-rect.json";

/* 动画节奏。规格书 §10.1 给的是 180ms 展开动画；这里用「分帧位移」实现，
 * 帧数 × 帧间隔 ≈ 180ms（不用 ValueAnimator：多引一层 Java 接口包装，
 * 换 AutoX 版本就可能失效，而这只是 6 帧的位置插值）。 */
FB.ANIM_FRAMES = 6;
FB.ANIM_STEP_MS = 30;
FB.BREATH_MS = 900;    // 运行中外环呼吸周期

/* ------------------------------------------------------------ 运行期状态 */

/* ------------------- 窗口层：两个 overlay，尺寸恒定 ------------------- */
FB.ballWin = null;     // 球窗口（88×88dp）：常驻、永远可触摸、尺寸只在拖动时变
FB.fanWin = null;      // 扇形窗口句柄占位（真正的视图是 FB.fanRoot）
FB.window = null;      // 兼容别名 = 球窗口的根视图（dumpLayout / 自检里用它）
FB.root = null;        // 球窗口里的根 FrameLayout
FB.fanRoot = null;     // 扇形窗口里的根 FrameLayout
FB.ballLp = null;      // 球窗口 LayoutParams（拖动改它）
FB.fanLp = null;       // 扇形窗口 LayoutParams（改位置与 NOT_TOUCHABLE）
FB.open = false;       // 扇形是否展开
FB.side = "left";      // 球贴哪一边（决定扇形方向）
FB.anchorX = 0;        // 球左上角 X（像素，绝对屏幕坐标）
FB.anchorCy = 0;       // 球心 Y（像素）
FB.dragging = false;   // 本次触摸是否已判定为拖动
FB.breathTimer = null;
FB.breathOn = false;
FB.views = {};         // id → 视图
FB.lastTone = "";       // 上一次的三态，用于避免无谓重建扇形
FB.lastRectKey = "";     // 上一次发布的球位（避免重复写盘）
FB.firstBtn = null;      // 扇形第 1 个按钮（运行/停止）的视图引用，用于就地更新

/* ------------------------------------------------------------ 调试开关 */

/** 调试模式：`/sdcard/tiktok_app/ball-debug` 存在即开启（每 2 秒最多查一次）。 */
FB.debugLastCheck = 0;
FB.debugOn = false;
FB.debugEnabled = function () {
    var now = Date.now();
    if (now - FB.debugLastCheck > 2000) {
        FB.debugLastCheck = now;
        try { FB.debugOn = files.exists("/sdcard/tiktok_app/ball-debug"); } catch (e) { FB.debugOn = false; }
    }
    return FB.debugOn;
};

function logTouch(action, x, y) {
    try {
        files.append('/sdcard/tiktok_app/ball-touch.log',
            Date.now() + ' action=' + action + ' (' + Math.round(x) + ',' + Math.round(y) + ')' +
            ' open=' + FB.open + ' anchor=' + FB.anchorX + ',' + FB.anchorCy + '\n');
    } catch (e) { }
}

/** 一般轨迹（点按钮、走确认、拉前台…），同样只在 ball-debug 打开时落盘。 */
function trace(msg) {
    if (!FB.debugEnabled()) { return; }
    try { files.append('/sdcard/tiktok_app/ball-touch.log', Date.now() + ' ' + msg + '\n'); } catch (e) { }
}

/**
 * 异常轨迹。
 *
 * ★ 悬浮球这一层的异常**不会自己冒出来**：UI 回调里抛错既不结束脚本、也不弹提示，
 *   用户看到的就是"点了没反应"。所以凡是"点了应该发生什么"的路径，都要有人接住
 *   并把异常写下来 —— 否则下一次还是只能靠猜。
 */
function traceError(where, error) {
    var text = where + ' 抛错: ' + error + '\n' + (error && error.stack ? error.stack : '');
    try { console.log('[fb] ' + text); } catch (e0) { }
    if (!FB.debugEnabled()) { return; }
    try { files.append('/sdcard/tiktok_app/ball-touch.log', Date.now() + ' ' + text + '\n'); } catch (e1) { }
    try { files.write('/sdcard/tiktok_app/ball-error.txt', text); } catch (e2) { }
}

/* ------------------------------------------------------------ 布局轨迹（调试用） */

/**
 * 记录「**这一帧球实际画在哪**」。
 *
 * 为什么需要它：展开前后**球心是设计成不动的**（窗口变大、球在窗口内的偏移同步变大，
 * 两者相抵）。所以任何肉眼可见的位移，都只可能来自"两半改动没落在同一帧"——
 * 即窗口已经换了尺寸、而视图还按旧布局摆（或反过来）。那种中间态只存在一两帧，
 * 连拍截图（~250ms/帧）根本抓不到。
 *
 * 而 `getLocationOnScreen()` 读的是**布局结果**，不是我们设进去的值，所以它能把这个
 * 中间态如实反映出来 —— 这正是"能不能看见"的判据。
 */
function absPosOf(view) {
    if (!view) { return "?"; }
    try {
        /* ⚠️ 必须是**真的 Java int[]**：Rhino 把 JS 数组按值转成 Java 数组，
         * 方法写进去的值读不回来 —— 传 [0,0] 永远得到 0,0（白测一轮才发现）。 */
        var loc = java.lang.reflect.Array.newInstance(java.lang.Integer.TYPE, 2);
        view.getLocationOnScreen(loc);
        return java.lang.reflect.Array.getInt(loc, 0) + "," + java.lang.reflect.Array.getInt(loc, 1);
    } catch (e) {
        try { return view.getLeft() + "," + view.getTop(); } catch (e2) { return "?"; }
    }
}

/** 打一张当前快照：窗口矩形 + 球/热区的屏幕绝对位置 + 根视图透明度。 */
function traceFrame(tag) {
    if (!FB.debugEnabled() || !FB.window) { return; }
    var parts = [tag];
    try {
        parts.push("win=" + FB.window.getWidth() + "x" + FB.window.getHeight() +
                   "@" + FB.window.getX() + "," + FB.window.getY());
    } catch (e) { parts.push("win=?"); }
    if (FB.views.ball) {
        parts.push("ballAbs=" + absPosOf(FB.views.ball) +
                   " " + FB.views.ball.getWidth() + "x" + FB.views.ball.getHeight());
    }
    if (FB.views.hot) {
        parts.push("hotAbs=" + absPosOf(FB.views.hot) +
                   " " + FB.views.hot.getWidth() + "x" + FB.views.hot.getHeight());
    }
    try { parts.push("rootAlpha=" + FB.root.getAlpha()); } catch (e2) { }
    trace("frame " + parts.join(" | "));
}

/** 挂一次布局监听：这个视图**每次真正被布局**（含首次）都打一张快照。 */
function watchLayout(tag, view) {
    if (!FB.debugEnabled() || !view) { return; }
    try {
        view.addOnLayoutChangeListener(new android.view.View.OnLayoutChangeListener({
            onLayoutChange: function () { traceFrame(tag); }
        }));
    } catch (e) {
        trace("watchLayout(" + tag + ") 失败: " + e);
    }
}

/* ------------------------------------------------------------ 小工具 */

function dp(v) {
    return Math.round(v * (context.getResources().getDisplayMetrics().density || 1));
}

function screenW() { return device.width; }
function screenH() { return device.height; }

/**
 * 折叠态窗口边长（dp）：热区 + 两侧内边距。
 *
 * ★ 命名带 Dp 后缀是刻意的：这套坐标算错过一次 —— `fanSize()` 原先返回**像素**
 *   而调用方把它当 dp 再用（`place()` 会再乘一次密度），于是展开时球心被算到
 *   根视图外面：球整体下移、四个按钮挤在一起。dp / px 混用不会有任何报错，
 *   只会"看起来不太对"，所以这里用名字把单位写死。
 */
function collapsedSizeDp() { return FB.HOT + FB.PAD * 2; }

/** 扇形展开后窗口需要多大（dp） */
function fanSizeDp() {
    /* 水平：内边距 + 热区 + 扇形半径 + 子按钮半径 + 4dp 间隙 + 最长标签 + 内边距 */
    var labelMax = 96;
    var w = FB.PAD + FB.HOT + FB.R + FB.SUB / 2 + 4 + labelMax + FB.PAD;
    /* 垂直：球心上下各「半径 + 子按钮半径 + 余量」 */
    var h = 2 * (FB.R + FB.SUB / 2 + 12);
    return { w: w, h: h };
}

/**
 * 球心在窗口**根视图**里的坐标（dp）—— 展开/折叠共用这一个公式。
 *
 * 折叠态球心在热区正中；展开态球心垂直居中（扇形上下都要地方）、
 * 水平仍贴原来那一侧（右侧时取镜像）。
 */
function ballCenterInRoot(winWDp, winHDp) {
    var half = FB.HOT / 2;
    var rootW = winWDp - FB.PAD * 2;      /* 根视图被内边距挤掉一圈 */
    var rootH = winHDp - FB.PAD * 2;
    var x = (FB.side === "right") ? (rootW - half) : half;
    /* ⚠️ 是**根视图**的中心，不是窗口的中心：漏掉这个 PAD 会让球整体下移 12dp */
    return { x: x, y: rootH / 2 };
}

/**
 * 把当前悬浮窗的**真实布局**写盘（排障用）。
 *
 * 这条是踩坑之后加的：球的坐标算错过两次（dp/px 混用、根视图中心漏算内边距），
 * 两次都表现为"看起来只是有点歪"，靠肉眼量截图量不准。
 * 有了它，下一次任何"位置不对"都能一眼看出是窗口、根还是某个子视图算错了。
 */
FB.dumpLayout = function (tag) {
    if (!FB.root || !FB.ballLp) { return; }
    var out = ['# ' + tag];
    function winLine(name, lp, view) {
        if (!lp) { return name + ' (无)'; }
        var touchable = !(lp.flags & FLAG_NOT_TOUCHABLE);
        return name + ' ' + lp.width + 'x' + lp.height + ' @ ' + lp.x + ',' + lp.y +
               ' touchable=' + touchable + ' root=' +
               (view ? view.getWidth() + 'x' + view.getHeight() : '?');
    }
    try {
        out.push(winLine('ballWin', FB.ballLp, FB.root));
        out.push(winLine('fanWin ', FB.fanLp, FB.fanRoot));
        out.push('anchor ' + FB.anchorX + ',' + FB.anchorCy + ' side=' + FB.side + ' open=' + FB.open);
        function dumpChildren(prefix, view) {
            if (!view) { return; }
            for (var i = 0; i < view.getChildCount(); i++) {
                var v = view.getChildAt(i);
                var text = '';
                var vis = v.getVisibility();
                try { text = (typeof v.getText === 'function') ? String(v.getText()) : ''; } catch (e) { text = '?'; }
                var shown = (vis === android.view.View.GONE) ? ' GONE' :
                            (vis === android.view.View.INVISIBLE ? ' INVIS' : '');
                out.push('  ' + prefix + '#' + i + ' ' + v.getLeft() + ',' + v.getTop() + ' ' +
                         v.getWidth() + 'x' + v.getHeight() + shown + ' "' + text + '"');
            }
        }
        dumpChildren('ball ', FB.root);
        dumpChildren('fan  ', FB.fanRoot);
    } catch (error) {
        out.push('dump 失败: ' + error);
    }
    try { files.write('/sdcard/tiktok_app/ball-layout.txt', out.join('\n')); } catch (e2) { }
};

/* ------------------------------------------------------------ 落盘（记忆位置） */

/** 当前垂直位置的比例（0~1000），换屏幕比例后仍然合理。 */
FB.yRatio = function () {
    var h = screenH();
    if (!h) { return 500; }
    return Math.max(0, Math.min(1000, Math.round(FB.anchorCy / h * 1000)));
};

FB.savePosition = function () {
    Store.set("ball.side", FB.side);
    Store.set("ball.yRatio", FB.yRatio());
};

/** 从配置恢复锚点位置（球心 X / Y 像素）。 */
FB.restoreAnchor = function () {
    FB.side = Store.getEnum("ball.side", ["left", "right"]);
    var ratio = Store.getNumber("ball.yRatio");
    if (ratio < 100 || ratio > 900) { ratio = 500; }   /* 越界值当默认，别把球顶到屏幕外 */

    FB.anchorCy = Math.round(screenH() * ratio / 1000);
    FB.anchorX = (FB.side === "right")
        ? screenW() - dp(FB.EDGE) - dp(FB.DIAM)
        : dp(FB.EDGE);
    FB.clampAnchor();
};

/** 锚点必须留在屏幕内：用户手滑拖出去，球就再也点不到了。 */
/**
 * 把锚点夹进「两个窗口都能完整显示」的范围。
 *
 * ★ 夹的必须是**锚点**而不是窗口：两个窗口的位置都由锚点推导，分别夹会让它们错位。
 *   代价是球不能被拖到离上下边缘 120dp 以内（扇形半高）—— 这是物理上必须的，
 *   否则扇形窗口会出屏、下面两个按钮点不到。横向不用管：球本来就吸附在左右边缘上。
 */
FB.clampAnchor = function () {
    var maxX = Math.max(0, screenW() - dp(FB.DIAM));
    FB.anchorX = Math.max(0, Math.min(maxX, FB.anchorX));

    var m = dp(fanSizeDp().h / 2) - dp(FB.PAD);   /* 球心到扇形窗口上/下边的最小距离 */
    var minY = Math.max(dp(FB.DIAM) / 2, m);
    var maxY = Math.max(minY, screenH() - m);
    FB.anchorCy = Math.max(minY, Math.min(maxY, FB.anchorCy));
};

/* ------------------------------------------------------------ 视图构建 */

/** 圆形图标按钮（扇形里的四个，或球体本身）。 */
function circleButton(hexFill, gradient, iconChar, iconHex, iconSize) {
    var view = U.text(iconChar, iconSize || 15, iconHex || "#FFFFFF", false);
    view.setGravity(android.view.Gravity.CENTER);
    view.setBackground(gradient
        ? U.gradientBg(Theme.hex.accent, Theme.hex.accentDeep, Theme.m.pillRadius)
        : U.solidBg(U.alphaOf(hexFill, hexFill.indexOf("#FFFFFF") === 0 ? 0.08 : 0.14), Theme.m.pillRadius));
    U.params(view, FB.SUB, FB.SUB);
    return view;
}

/** 标签胶囊（§10.1：高 24、圆角 99、距按钮 4px、11px 字）。 */
function labelPill(text, textHex, bgHex, bgAlpha) {
    var view = U.text(text, Theme.m.chipSize, textHex, true);
    view.setGravity(android.view.Gravity.CENTER);
    view.setBackground(U.solidBg(U.alphaOf(bgHex, bgAlpha), Theme.m.pillRadius));
    view.setPadding(U.dp(10), 0, U.dp(10), 0);
    var lp = new android.widget.FrameLayout.LayoutParams(-2, dp(FB.LABEL_H));
    view.setLayoutParams(lp);
    return view;
}

/** 绝对定位（根是 FrameLayout，用 margin 当坐标）。 */
function place(view, leftDp, topDp, wDp, hDp) {
    var lp = new android.widget.FrameLayout.LayoutParams(
        wDp > 0 ? dp(wDp) : wDp, hDp > 0 ? dp(hDp) : hDp);
    lp.leftMargin = dp(leftDp);
    lp.topMargin = dp(topDp);
    view.setLayoutParams(lp);
    return view;
}

/** 球能不能建：卡密有效 + 悬浮窗权限 + 用户没主动隐藏。 */
FB.canShow = function () {
    if (Store.getBool("ball.hidden")) { return false; }
    if (Service.licenseStatus().status !== "active") { return false; }
    return Device.overlayEnabled();
};

/* ------------------------------------------------------------ 窗口层（两个 overlay，尺寸恒定） */

var TYPE_APPLICATION_OVERLAY = 2038;
var FLAG_NOT_FOCUSABLE        = 0x00000008;
var FLAG_NOT_TOUCHABLE        = 0x00000010;
var FLAG_NOT_TOUCH_MODAL      = 0x00000020;
/* ★ 必须带上它：否则窗口会被状态栏内缩，整套坐标整体下移一个状态栏高度
 * （实测球比锚点低了 48px，正好是状态栏高。AutoX 的 floaty 窗口带这个 flag，所以以前没暴露） */
var FLAG_LAYOUT_IN_SCREEN     = 0x00000100;
var FLAG_LAYOUT_NO_LIMITS     = 0x00000200;
var FLAG_HARDWARE_ACCELERATED = 0x01000000;

var wmService = null;
function wm() {
    if (!wmService) { wmService = context.getSystemService("window"); }
    return wmService;
}

function overlayFlags(touchable) {
    var f = FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCH_MODAL | FLAG_LAYOUT_NO_LIMITS |
            FLAG_LAYOUT_IN_SCREEN | FLAG_HARDWARE_ACCELERATED;
    /* §10.9④：不抢输入焦点，否则会影响 TikTok 的键盘 */
    if (!touchable) { f = f | FLAG_NOT_TOUCHABLE; }
    return f;
}

/** 建一个覆盖窗口（尺寸取 px）。返回它的 LayoutParams，后面拖动/改触摸要用。 */
function addOverlay(view, x, y, w, h, touchable) {
    var lp = new android.view.WindowManager.LayoutParams();
    lp.type = TYPE_APPLICATION_OVERLAY;
    lp.format = -3;                 /* PixelFormat.TRANSLUCENT */
    lp.flags = overlayFlags(touchable);
    lp.gravity = 51;                /* TOP | LEFT，于是 x/y 就是屏幕绝对坐标 */
    lp.x = x; lp.y = y;
    lp.width = w; lp.height = h;
    wm().addView(view, lp);
    return lp;
}

/**
 * ★★ 为什么是**两个**窗口（2026-10-15 重做；这一版之前的做法都错了）
 *
 * 之前是"一个窗口，展开时改尺寸"。它必然"跳"，且**顺序怎么排都躲不掉**：
 *   改窗口尺寸/位置由系统（WindowManager）**立刻生效**，
 *   而我们这边的视图重排要等 App 下一帧重绘；
 *   中间那几帧，合成器显示的是**上一帧的旧画面被摆到新的窗口矩形里**。
 * 用录屏逐帧看得很清楚：展开那一刻球会从下往上"爬"几级才停 —— 就是用户说的"跳动"。
 * 试过的两条补救都不行：
 *   · 先在同一个 JS 调用里把球藏起来再改尺寸 —— 藏只是标记，改尺寸已经发出去了，照样跳；
 *   · 藏起来之后**等这一帧画完**（`onPreDraw`）再改尺寸 —— 合成器有 2~3 帧的缓冲队列，
 *     它照样能把"藏之前"的那一帧摆到新位置上去（实测仍然跳）。
 *
 * ⇒ 唯一干净的办法是**根本不改窗口几何**：
 *   · **球窗口** 88×88dp：常驻、永远可触摸、尺寸与位置只在拖动时变；
 *   · **扇形窗口** 308×264dp：位置随球算好，**折叠时整窗设成 NOT_TOUCHABLE**
 *     （触摸自动穿透到下面的 App，所以它的透明区不会是死区），展开时才可触摸。
 *   于是"展开/收起"只改**显隐**与一个 flag —— 没有任何几何变化，也就没有任何东西会跳。
 *   附带好处：折叠态的"死区"从 176×176px 缩到球窗口那么大，引擎要绕开的范围也小了（见 publishRect）。
 *
 * 两个窗口能同时绘制是**实测过的**（`_probe/fb_two_windows.js`：红块与绿块都出现）。
 * AutoX 的 `floaty.window` 做不到这一点（第二个建得出来但画不出来），所以这里走裸 WindowManager。
 */
FB.ensure = function () {
    if (FB.ballWin) { FB.sync(); return; }
    if (!FB.canShow()) { return; }
    try {
        FB.restoreAnchor();

        /* ① 先建两棵视图树。内边距用视图自己的 padding 复现那圈 12dp，
         *    于是"球心在根视图里的坐标"这套算法一个字都不用改 */
        FB.root = new android.widget.FrameLayout(context);
        FB.root.setPadding(dp(FB.PAD), dp(FB.PAD), dp(FB.PAD), dp(FB.PAD));
        buildBallViews();
        FB.fanRoot = new android.widget.FrameLayout(context);
        FB.fanRoot.setPadding(dp(FB.PAD), dp(FB.PAD), dp(FB.PAD), dp(FB.PAD));
        buildFanViews();

        /* ② 再加窗口：**扇形先加、球后加**。同类型窗口按加入顺序叠放，后加的在上；
         *    球必须在最上层 —— 扇形展开时球的矩形整个落在扇形窗口里，
         *    球若在下层，点它就会被扇形窗口吃掉，**再点一次收不起来**（真机踩过）。
         *    两层的子视图不重叠（扇形按钮离球心 96dp，球窗口只有 88dp），所以不会有遮挡问题。 */
        var f = fanSizeDp();
        FB.fanLp = addOverlay(FB.fanRoot, 0, 0, dp(f.w), dp(f.h), false);
        var c = collapsedSizeDp();
        FB.ballLp = addOverlay(FB.root, 0, 0, dp(c), dp(c), true);
        FB.ballWin = FB.root;          /* 兼容别名：dumpLayout / 自检里用它 */
        FB.window = FB.root;

        positionBallWindow();
        positionFanWindow();
        FB.open = false;
        FB.publishRect();   /* 启动就把球位告诉引擎，别让它去点球 */
        FB.sync();
        attach();
    } catch (e) {
        console.log("[fb] 创建悬浮窗失败: " + e);
        traceError('ensure', e);
        FB.destroy();
    }
};

/** 窗口挂上去之后的收尾（定位、调试监听、留一份布局快照）。 */
function attach() {
    setTimeout(function () {
        if (!FB.ballWin) { return; }
        if (FB.debugEnabled() && FB.root) {
            FB.root.setOnTouchListener(new android.view.View.OnTouchListener({
                onTouch: function (v, event) {
                    trace('root-touch action=' + event.getAction() + ' @' +
                          Math.round(event.getRawX()) + ',' + Math.round(event.getRawY()));
                    return false;
                }
            }));
        }
        FB.dumpLayout('collapsed');
        console.log("[fb] 悬浮球已就绪 side=" + FB.side + " pos=" + FB.anchorX + "," + FB.anchorCy);
    }, 60);
}

FB.destroy = function () {
    FB.stopBreath();
    /* 先告诉引擎"球没了"再关窗：反过来的话，关窗与写文件之间那一瞬
     * 引擎可能刚好读到旧矩形，于是白白绕开一个已经不存在的球。 */
    try {
        files.write(FB.RECT_PATH, JSON.stringify({ hidden: true, updatedAt: Date.now() }));
        FB.lastRectKey = "";
    } catch (e0) { /* 写不进就算了，引擎读不到会当没有球 */ }
    try { if (FB.root) { wm().removeView(FB.root); } } catch (e) { console.log("[fb] 移除球窗口失败: " + e); }
    try { if (FB.fanRoot) { wm().removeView(FB.fanRoot); } } catch (e2) { console.log("[fb] 移除扇形窗口失败: " + e2); }
    FB.ballWin = null;
    FB.fanWin = null;
    FB.window = null;
    FB.ballLp = null;
    FB.fanLp = null;
    FB.root = null;
    FB.fanRoot = null;
    FB.open = false;
    FB.views = {};
    FB.firstBtn = null;
};

/* ------------------------------------------------------------ 扇形几何 */

/**
 * 第 index 个按钮相对「球心」的偏移（dp）。
 * 球在右侧时整体镜像（x 取负）—— 规格书 §10.11：不镜像整组按钮会出屏。
 */
function fanOffset(index) {
    var rad = FB.ANGLES[index] * Math.PI / 180;
    var dx = FB.R * Math.cos(rad);
    var dy = -FB.R * Math.sin(rad);      /* 屏幕 y 向下，故取负 sin */
    return { x: FB.side === "right" ? -dx : dx, y: dy };
}

/* ------------------------------------------------------------ 视图构建（只建一次） */

/**
 * 品牌图标位图**只解码一次**。
 * `images.read()` 要把 412×412 的 PNG 解码成位图，是这一层最贵的一步。
 */
FB.brandBitmap = null;
function brandBitmap() {
    if (FB.brandBitmap) { return FB.brandBitmap; }
    try {
        var img = images.read(FB.BRAND);
        if (img) { FB.brandBitmap = img.bitmap; }
        else { console.log("[fb] 品牌图不存在: " + FB.BRAND); }
    } catch (e) {
        console.log("[fb] 读品牌图失败: " + e);
    }
    return FB.brandBitmap;
}

/**
 * 球窗口里就三件套：呼吸环（Ø60）/ 球体（Ø48）/ 透明热区（Ø64）。
 *
 * 位置**建一次就够**：折叠态与展开态球在根视图里的坐标是同一个
 * （球心永远在球窗口的正中），所以没有"换状态要重摆"这回事。
 * 顺序：环 → 球 → 热区，热区最后加所以盖在最上层收手势。
 */
function buildBallViews() {
    var root = FB.root;
    root.removeAllViews();

    var ring = U.text("", 1, "#FFFFFF", false);
    ring.setBackground(U.solidBg(U.alphaOf(Theme.hex.ok, 0.22), Theme.m.pillRadius));
    /* 建的时候先藏起来：环的颜色/有无完全由 sync() 按运行态决定。
     * 默认可见会让空闲态也挂着一个绿环。 */
    ring.setVisibility(android.view.View.GONE);
    place(ring, (FB.HOT - 60) / 2, (FB.HOT - 60) / 2, 60, 60);
    root.addView(ring);

    var ball = new android.widget.ImageView(context);
    var bmp = brandBitmap();
    if (bmp) { ball.setImageBitmap(bmp); }
    ball.setScaleType(android.widget.ImageView.ScaleType.FIT_XY);
    ball.setBackground(U.solidBg(U.argb(Theme.hex.bg), Theme.m.pillRadius));
    ball.setClipToOutline(true);
    place(ball, (FB.HOT - FB.DIAM) / 2, (FB.HOT - FB.DIAM) / 2, FB.DIAM, FB.DIAM);
    root.addView(ball);

    /* 透明热区：球 Ø48、热区 Ø64 —— §10.1 的"视觉小、触控大" */
    var hot = new android.view.View(context);
    hot.setBackground(U.solidBg(0x00000000, 0));
    place(hot, 0, 0, FB.HOT, FB.HOT);
    hot.setOnTouchListener(new android.view.View.OnTouchListener({
        onTouch: function (v, event) { return onTouch(event); }
    }));
    root.addView(hot);

    FB.views.ring = ring;
    FB.views.ball = ball;
    FB.views.hot = hot;

    watchLayout("ball", ball);
    watchLayout("hot", hot);
}

/**
 * 扇形窗口里是 4 个按钮 + 4 个标签，**建一次、位置也只算一次**
 * （它们只取决于扇形几何与球贴哪一边；换边时由 layoutFanViews() 重摆）。
 */
function buildFanViews() {
    var root = FB.fanRoot;
    root.removeAllViews();
    FB.views.fan = [];
    FB.firstBtn = null;

    var specs = fanSpecs();
    var i;
    for (i = 0; i < specs.length; i++) {
        var spec = specs[i];
        var shape = (spec.kind === "primary") ? primaryState() : spec;
        var danger = !!shape.danger;

        var btn = U.text(shape.icon, 15, shape.iconHex, false);
        btn.setGravity(android.view.Gravity.CENTER);
        btn.setBackground(shape.gradient
            ? U.gradientBg(Theme.hex.accent, Theme.hex.accentDeep, Theme.m.pillRadius)
            : (danger
                ? U.solidBg(U.alphaOf(Theme.hex.danger, shape.solid ? 1 : 0.14), Theme.m.pillRadius)
                : U.solidBg(U.alphaOf("#FFFFFF", 0.08), Theme.m.pillRadius)));
        btn.setVisibility(android.view.View.GONE);

        /* 轨迹里用「标签」而不是 kind：只有第 1 个按钮有 kind，
         * 其余三个会打成 kind=undefined —— 排障时最需要看清"点中的是哪一个"。 */
        var fanTag = (spec.kind === "primary") ? "primary" : String(spec.label);
        (function (action, tag, idx) {
            /* 点按钮 → 执行动作。
             * ⚠️ try/catch 是必须的：UI 回调里抛错在 AutoX 上**不报错、不弹窗、
             *    不结束脚本**，症状就是"点了没反应"。这里把它转成一条可读的轨迹。 */
            btn.setOnClickListener(function () {
                trace('click fan#' + idx + ' ' + tag + ' open=' + FB.open);
                try {
                    action();
                } catch (e) {
                    traceError('扇形按钮#' + idx + '(' + tag + ')', e);
                }
                /* 选完就收起：扇形是个**选择器**，点完还摊着，正好挡住用户此刻要看的东西。
                 * 「停止 / 退出」在 confirmThenAct 里已经收过一次，这里是幂等的。 */
                try { FB.collapse(); } catch (e2) { traceError('收起扇形', e2); }
            });
        })(spec.action, fanTag, i);
        root.addView(btn);

        var pill = labelPill(shape.label, danger ? Theme.hex.danger : "#FFFFFF",
                             danger ? Theme.hex.danger : "#FFFFFF", danger ? 0.14 : 0.10);
        pill.setVisibility(android.view.View.GONE);
        root.addView(pill);

        FB.views.fan.push({ btn: btn, pill: pill });
        if (spec.kind === "primary") { FB.firstBtn = { view: btn, pill: pill }; }
    }
    layoutFanViews();
}

/**
 * 摆扇形里那 8 个视图。只在**建视图**与**换了贴边方向**时调用。
 *
 * ★ 必须走 `place()`：它内部统一做 dp→px。这里原先调的是另一个自己写的 pillParams()，
 *   那里面漏了 dp() —— 于是标签的坐标被当成像素用、全部挤到左上角（按钮是对的）。
 */
function layoutFanViews() {
    var size = fanSizeDp();
    var center = ballCenterInRoot(size.w, size.h);
    var i;
    for (i = 0; i < FB.views.fan.length; i++) {
        var off = fanOffset(i);
        var cx = center.x + off.x;
        var cy = center.y + off.y;
        var item = FB.views.fan[i];

        place(item.btn, cx - FB.SUB / 2, cy - FB.SUB / 2, FB.SUB, FB.SUB);

        /* 标签：向右展开时贴按钮右侧，镜像时贴左侧（§10.11） */
        var label = "";
        try { label = String(item.pill.getText()); } catch (e) { label = ""; }
        var pw = measurePillWidth(item.pill, label);
        var px = (FB.side === "right") ? (cx - FB.SUB / 2 - 4 - pw) : (cx + FB.SUB / 2 + 4);
        place(item.pill, px, cy - FB.LABEL_H / 2, -2, FB.LABEL_H);
    }
}

/**
 * 扇形 8 个视图的显隐。
 * 用 **GONE 而不是 INVISIBLE**：INVISIBLE 仍然占着位置、也仍然会吃掉触摸。
 */
function setFanVisible(on) {
    var vis = on ? android.view.View.VISIBLE : android.view.View.GONE;
    for (var i = 0; i < FB.views.fan.length; i++) {
        FB.views.fan[i].btn.setVisibility(vis);
        FB.views.fan[i].pill.setVisibility(vis);
    }
}

/**
 * 扇形**窗口**能不能吃触摸。
 *
 * 折叠时必须设成不可触摸：扇形窗口有一大片透明区，而**窗口的透明区同样会吃掉触摸**
 * （实测：点它透明区里的输入框，键盘不弹；点窗口外，键盘就弹）。
 * 设成 NOT_TOUCHABLE 之后触摸会穿透到下面的 App —— 于是折叠态没有任何死区。
 */
function setFanTouchable(on) {
    if (!FB.fanLp) { return; }
    FB.fanLp.flags = overlayFlags(on);
    try {
        wm().updateViewLayout(FB.fanRoot, FB.fanLp);
    } catch (e) {
        traceError('setFanTouchable', e);
    }
}

/** 标签宽度：项目里没有测量工具，按字数估算（11px 字 + 两侧 10dp 内边距）。 */
function measurePillWidth(pill, text) {
    var len = String(text).length;
    var ascii = 0, wide = 0, j;
    for (j = 0; j < len; j++) {
        if (String(text).charCodeAt(j) < 128) { ascii += 1; } else { wide += 1; }
    }
    return dp(20) + ascii * dp(7) + wide * dp(11);
}

/**
 * 四个按钮的定义（§10.3）。
 * 第 1 个随运行态切换：空闲/完成后是「运行」，运行中是「停止」。
 */
function fanSpecs() {
    return [
        /* ★ 第 1 个按钮的动作**在点击那一刻现取**当前状态（见 primaryState）。
         *
         * ⚠️ 这里踩过一个"界面全对、日志正常、就是点了没反应"的大坑，务必别再改回去：
         *    早期用一个可变 holder（`FB.firstAction.fn`）存这个动作，由 `applyFirstButton()`
         *    在**三态发生变化时**写入。而"展开扇形"这一步通常是 idle → idle ——
         *    状态根本没变，`sync()` 判定 `changed === false`，于是对**新按钮实例**
         *    从不调用 `applyFirstButton()`，holder 里始终是最初那个空函数。
         *    表现：「运行 / 停止」点了毫无反应，而其余三个按钮（动作内联在下面几行）都正常；
         *    触摸事件收到了、界面也完全正确 —— 只是回调是个空壳，最难查的一类。
         *    ⇒ 动作一律**现算**，不存可变引用，"忘记接线"这种可能就根本不存在了。 */
        { kind: "primary",
          action: function () { primaryState().fn(); } },
        { icon: "\u25A6", label: "\u56DE\u5230 App", iconHex: "#FFFFFF",
          action: function () { App.bringToFront(); } },
        { icon: "\u2298", label: "\u9690\u85CF\u60AC\u6D6E\u7403", iconHex: "#FFFFFF",
          action: function () { FB.hide(); } },
        { icon: "\u2715", label: "\u9000\u51FA\u5E94\u7528", iconHex: Theme.hex.danger, danger: true,
          action: function () { askExit(); } }
    ];
}

/** 第 1 个按钮当前的形态（也定义了它现在该做什么）。 */
function primaryState() {
    var running = !!Session.running;
    return running
        ? { icon: "\u25A0", label: "\u505C\u6B62", iconHex: "#FFFFFF", danger: true, solid: true,
            fn: function () { askStop(); } }
        : { icon: "\u25B6", label: "\u8FD0\u884C", iconHex: "#FFFFFF", gradient: true,
            fn: function () { askRun(); } };
}

/* --------------------------------------------- 展开 / 收起（只改显隐与一个 flag） */

/**
 * 展开 / 收起**只做两件事**：扇形视图的显隐 + 扇形窗口的 NOT_TOUCHABLE 开关。
 *
 * 没有尺寸变化、没有位置变化、没有等待、没有动画 —— 所以不存在"跳"的可能。
 * 这一点是本模块的核心结论：只要**窗口几何不变**，合成器拿到的每一帧缓冲都画在同一个
 * 矩形里，就不可能出现"旧画面被摆到新位置"。详见窗口层那段注释（含两次失败的尝试）。
 *
 * ★ **不做任何过渡动画**（用户 2026-10-14 明确要求去掉）。
 *   规格书 §10.1 写了"展开动画 180ms"，这里是有意识的偏离：那 180ms 淡入会让
 *   "展开"在点击后近 0.3 秒才看清，而这个球的用法是"点一下就到位"。
 *   将来若要恢复动画，在 `setFanVisible(true)` 之后做透明度渐变 —— ⚠️ 但那时
 *   **透明度的写者必须只有这一处**，否则会出现"两个动画互相顶掉"的鬼影（不报错、只有肉眼看得见）。
 */
FB.expand = function () {
    if (FB.open || !FB.ballWin) { return; }
    try {
        FB.open = true;
        positionFanWindow();                     /* 位置随球算（拖动过就更新一下） */
        if (FB.firstBtn) { applyFirstButton(); }  /* 第 1 个按钮跟上当前运行态 */
        setFanVisible(true);
        setFanTouchable(true);
        FB.sync();                               /* 三态外环 */
        FB.publishRect();
        FB.dumpLayout('fan');                    /* 切换之后的真实布局，留一份给排障 */
        trace("expand 完成");
    } catch (error) {
        /* 展开路径上任何一步抛错都必须留下痕迹：真机上它表现为"点了没反应"，
         * 而 AutoX 的 UI 回调异常不会让脚本退出、也不会弹任何提示。 */
        traceError('expand', error);
    }
};

FB.collapse = function () {
    if (!FB.ballWin || !FB.open) { return; }
    try {
        FB.open = false;
        setFanVisible(false);
        setFanTouchable(false);                  /* 整窗不可触摸 → 触摸穿透，不留死区 */
        FB.sync();
        FB.publishRect();
        FB.dumpLayout('collapsed');
        trace("collapse 完成");
    } catch (error) {
        traceError('collapse', error);
    }
};

FB.toggleOpen = function () {
    if (FB.open) { FB.collapse(); } else { FB.expand(); }
};

/* ------------------------------------------------------------ 位置计算 */

/**
 * 由「球锚点」反推某个窗口的左上角（像素）。**两个窗口共用这一处换算。**
 *
 * 球心的屏幕绝对坐标必须始终等于锚点：
 *   球心 = 窗口位置 + 内边距(PAD) + 球心在根视图里的偏移
 * 所以 窗口位置 = 锚点 − PAD − 根内偏移。折叠态与展开态的"根内偏移"不同
 * （折叠在正中、展开要垂直居中给扇形腾地方），于是两个窗口算出来的位置也不同 ——
 * 这没关系：**窗口各自建好之后就再也不动了**。
 */
function originFor(winWDp, winHDp) {
    var c = ballCenterInRoot(winWDp, winHDp);
    return {
        x: Math.round(FB.anchorX + dp(FB.DIAM) / 2 - dp(FB.PAD) - dp(c.x)),
        y: Math.round(FB.anchorCy - dp(FB.PAD) - dp(c.y)),
        w: dp(winWDp),
        h: dp(winHDp)
    };
}

function moveWindow(lp, view, o) {
    if (!lp || !view) { return; }
    lp.x = o.x; lp.y = o.y; lp.width = o.w; lp.height = o.h;
    try {
        wm().updateViewLayout(view, lp);
    } catch (e) {
        traceError('updateViewLayout', e);
    }
}

/** 把球窗口摆到锚点（拖动中与吸附后调用）。尺寸不变，只改位置。 */
function positionBallWindow() {
    var c = collapsedSizeDp();
    moveWindow(FB.ballLp, FB.root, originFor(c, c));
}

/** 把扇形窗口摆到锚点（展开前调用；拖动过之后位置要跟上）。 */
function positionFanWindow() {
    var f = fanSizeDp();
    moveWindow(FB.fanLp, FB.fanRoot, originFor(f.w, f.h));
}

/**
 * 把「引擎必须绕开的矩形」写盘（`ball-rect.json`）。
 *
 * 折叠态**只发球窗口**：扇形窗口那时是 NOT_TOUCHABLE，触摸会穿透到下面的 App，
 * 引擎不必绕开它 —— 这比之前"永远绕开一大块"更准，引擎的点击成功率也更高。
 * 展开态发两个窗口的并集。
 */
FB.publishRect = function () {
    var ball = originFor(collapsedSizeDp(), collapsedSizeDp());
    var rect;
    if (FB.open) {
        var fan = originFor(fanSizeDp().w, fanSizeDp().h);
        var x0 = Math.min(ball.x, fan.x), y0 = Math.min(ball.y, fan.y);
        var x1 = Math.max(ball.x + ball.w, fan.x + fan.w);
        var y1 = Math.max(ball.y + ball.h, fan.y + fan.h);
        rect = { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
    } else {
        rect = { x: ball.x, y: ball.y, w: ball.w, h: ball.h };
    }
    rect.open = !!FB.open;
    rect.updatedAt = Date.now();

    var key = [rect.x, rect.y, rect.w, rect.h, rect.open ? 1 : 0].join(",");
    if (key === FB.lastRectKey) { return; }   /* 只在真的变了才写盘 */
    FB.lastRectKey = key;
    try {
        files.write(FB.RECT_PATH, JSON.stringify(rect));
    } catch (e) {
        console.log("[fb] 发布球位失败: " + e);
    }
};

/* ------------------------------------------------------------ 手势：单击 / 拖动 */

var touchState = { x: 0, y: 0, ax: 0, ay: 0, moved: false, downAt: 0 };

function onTouch(event) {
    var action = event.getAction();
    var rawX = event.getRawX(), rawY = event.getRawY();
    /* 触摸事件日志：**默认关闭**。
     *
     * 球的手势属于"点不出来就完全没线索"的那类问题，所以留了这条日志 ——
     * 但每次触摸都往盘上追加是白白 IO，于是用「调试开关文件」控制：
     *   `adb shell touch /sdcard/tiktok_app/ball-debug` 打开，删掉即关闭。
     * 排查这类问题时它是救命的（CANCEL 与 UP 混在一起那次就是靠它定位的）。 */
    if (FB.debugEnabled()) { logTouch(action, rawX, rawY); }

    if (action === android.view.MotionEvent.ACTION_DOWN) {
        touchState.x = rawX;
        touchState.y = rawY;
        touchState.ax = FB.anchorX;
        touchState.ay = FB.anchorCy;
        touchState.moved = false;
        touchState.downAt = Date.now();
        return true;
    }

    if (action === android.view.MotionEvent.ACTION_MOVE) {
        var dx = rawX - touchState.x;
        var dy = rawY - touchState.y;
        if (!touchState.moved &&
            (Math.abs(dx) > dp(FB.SLOP) || Math.abs(dy) > dp(FB.SLOP))) {
            touchState.moved = true;
            FB.dragging = true;
            /* 拖动时先收起：展开态的窗口很大，拖着走会挡住半个屏幕 */
            if (FB.open) { FB.collapse(true); }
        }
        if (touchState.moved) {
            FB.anchorX = touchState.ax + dx;
            FB.anchorCy = touchState.ay + dy;
            FB.clampAnchor();
            positionBallWindow();
        }
        return true;
    }

    if (action === android.view.MotionEvent.ACTION_CANCEL) {
        /* ★ CANCEL **不是** UP，不能当点击处理 —— 这个坑很隐蔽：
         *   `setSize()` 改窗口尺寸会让 WindowManager 把正在进行的这条触摸流
         *   判为取消，于是每次展开都会紧跟一个 CANCEL。
         *   早期版本把 CANCEL 与 UP 一视同仁，结果就是「展开 → 立刻又收起」，
         *   用户看到的是"点了完全没反应"，而日志里一切正常（事件都收到了）。
         *   取消时只复位状态，不做任何动作。 */
        FB.dragging = false;
        touchState.moved = false;
        return true;
    }

    if (action === android.view.MotionEvent.ACTION_UP) {
        FB.dragging = false;
        var moved = touchState.moved;
        touchState.moved = false;
        if (moved) {
            FB.snapToEdge();
        } else {
            FB.toggleOpen();
        }
        return true;
    }
    return false;
}

/** 松手吸附最近边缘并记忆（§10.5）。 */
FB.snapToEdge = function () {
    var half = screenW() / 2;
    FB.side = (FB.anchorX + dp(FB.DIAM) / 2 < half) ? "left" : "right";
    FB.anchorX = (FB.side === "right")
        ? screenW() - dp(FB.EDGE) - dp(FB.DIAM)
        : dp(FB.EDGE);
    FB.clampAnchor();
    FB.savePosition();
    positionBallWindow();
    positionFanWindow();   /* 位置随球算，早点跟上 */
    layoutFanViews();      /* 贴边方向变了 → 扇形要重新镜像，标签也得换到另一侧 */
    FB.sync();
    FB.publishRect();
};

/* ------------------------------------------------------------ 状态同步（三态外环） */

/**
 * 把球刷成当前运行状态（§10.4）：
 *   空闲 → 无外环；运行中 → 青绿 22% + 呼吸；报错 → 玫瑰 20% 静态。
 * 球内**永远**是品牌图标（不随状态换），状态只靠环表达。
 */
FB.sync = function () {
    if (!FB.window) { return; }
    /* 状态切换期间不改环：此刻它还在展开态的位置上，而 sync() 会把环设成 VISIBLE
     * （运行中），于是切换的空档里会冒出一个"位置不对的绿环"。等落地后再刷。 */
    var ring = FB.views.ring;
    if (!ring) { return; }

    var tone = "idle";
    if (App.failBar) { tone = "error"; }
    else if (Session.running) { tone = "running"; }

    if (tone === "running") {
        ring.setBackground(U.solidBg(U.alphaOf(Theme.hex.ok, 0.22), Theme.m.pillRadius));
        ring.setVisibility(android.view.View.VISIBLE);
        FB.startBreath();
    } else if (tone === "error") {
        FB.stopBreath();
        ring.setBackground(U.solidBg(U.alphaOf(Theme.hex.danger, 0.20), Theme.m.pillRadius));
        ring.setVisibility(android.view.View.VISIBLE);
    } else {
        FB.stopBreath();
        ring.setVisibility(android.view.View.GONE);
    }

    /* 扇形开着时，第 1 个按钮要跟着状态变（运行 ↔ 停止）。
     *
     * ★ 这里是**就地改那一个按钮**，不重建扇形 —— 真机上踩过两次：
     *   ① 无条件重建：本函数每秒被 tickTimer 调一次，用户点下去那一刻正好被重建掉，
     *      点击就丢了（"偶尔点不动"，极难查）；
     *   ② 只在状态变化时重建：仍然会与旧视图叠在一起（建到一半就与残留的叠着），
     *      真机上表现为「运行」和「停止」两个标签同时出现、位置还错位。 */
    var changed = (tone !== FB.lastTone);
    FB.lastTone = tone;
    if (FB.open && changed && FB.firstBtn) {
        applyFirstButton();
    }
};

/**
 * 就地更新扇形第 1 个按钮（图标 / 文字 / 底色）。
 *
 * ★ 它**只改外观，不改行为** —— 行为由 `primaryState()` 在点击时现算
 *   （曾经在这里写 `FB.firstAction.fn = shape.fn`，造成"状态没变就永远没接线"的空回调，
 *    详见 `fanSpecs()` 上的注释）。
 */
function applyFirstButton() {
    var shape = primaryState();

    var view = FB.firstBtn.view;
    view.setText(shape.icon);
    view.setBackground(shape.gradient
        ? U.gradientBg(Theme.hex.accent, Theme.hex.accentDeep, Theme.m.pillRadius)
        : U.solidBg(U.alphaOf(Theme.hex.danger, shape.solid ? 1 : 0.14), Theme.m.pillRadius));

    var pill = FB.firstBtn.pill;
    pill.setText(shape.label);
    var danger = !!shape.danger;
    pill.setTextColor(U.argb(danger ? Theme.hex.danger : "#FFFFFF"));
    pill.setBackground(U.solidBg(U.alphaOf(danger ? Theme.hex.danger : "#FFFFFF",
                                                 danger ? 0.14 : 0.10), Theme.m.pillRadius));

    /* 就地改完再落一份布局快照 —— 否则 ball-layout.txt 永远停在"展开那一刻"，
     * 事后回看会以为按钮一直是「运行」（实际它已经变成「停止」，只是没重新 dump）。 */
}

/**
 * 呼吸动效：外环在 22% ↔ 6% 之间循环。
 * 用 setInterval 而不是 ValueAnimator —— 少引一层 Java 接口包装，
 * 而且这里只需要"看起来在呼吸"，不需要精确的插值曲线。
 */
FB.startBreath = function () {
    if (FB.breathTimer) { return; }
    FB.breathTimer = setInterval(function () {
        if (!FB.window || !FB.views.ring) { FB.stopBreath(); return; }
        FB.breathOn = !FB.breathOn;
        FB.views.ring.setBackground(U.solidBg(
            U.alphaOf(Theme.hex.ok, FB.breathOn ? 0.22 : 0.06), Theme.m.pillRadius));
    }, FB.BREATH_MS);
};

FB.stopBreath = function () {
    if (FB.breathTimer) {
        clearInterval(FB.breathTimer);
        FB.breathTimer = null;
    }
};

/**
 * 呼吸环是否正在跑。
 *
 * 存在的理由：它占一个 `setInterval`，而自检里「运行计时器该起 / 该停」是按
 * interval 总数断言的 —— 球一被建出来（就是它在说"正在运行"），总数就会多一个。
 * 有了这个查询，断言可以写成「总数 − 呼吸环 = 运行计时器」，
 * 而不是把期望值改成 2 这种"把噪声当基准"的写法。
 */
FB.breathing = function () { return !!FB.breathTimer; };

/* ------------------------------------------------------------ 四个按钮的动作 */

/** ① 运行：走与 App 内完全相同的校验链（悬浮球不给自己开后门）。 */
function askRun() {
    var taskKey = App.detail || Session.tab;
    if (!taskKey) {
        /* 没有"当前任务"时（停在任务列表）：回 App 让用户自己挑一个，
         * 比在这里猜一个任务跑起来安全得多（规格书 §2.5 的"已选脚本"校验同理）。 */
        toast("\u8BF7\u5148\u5728\u4EFB\u52A1\u5217\u8868\u9009\u4E00\u4E2A\u811A\u672C");
        App.bringToFront();
        return;
    }
    App.requestRun(taskKey);
}

/* ------------------------------------------------------------ 二次确认（H5 / H6） */

/**
 * ⚠️ 这里做了一处**有意识的偏离**，原因写清楚免得后来者白折腾：
 *
 * 规格书 §10.6 把 H5/H6 画成悬浮球自己的弹窗，我也照做了 —— 用第二个 floaty 窗
 * 承载遮罩 + 卡片。真机上它**建得出来但画不出来**：同屏已经有一个浮窗（球）时，
 * 再开一个全屏浮窗只剩 AutoX 的调整手柄小点，遮罩与卡片都不显示（试过补
 * `setSize`/`setAdjustEnabled(false)`/延后 150ms 创建，都没解决）。
 *
 * 「停止」是球上最要紧的一个键，**绝不能出现点了没反应**。所以改成确定可行的路径：
 *   点停止/退出 → 把 App 切到前台 → 用 App 里那套**已经在真机验证过的**弹窗确认。
 * 代价是多一次"App 跳到前台"，换来的是"这个键一定能用"。
 *
 * 后续若要回到规格书的浮窗形态：要么查清双浮窗的绘制问题（大概率与 AutoX 的
 * 窗口尺寸协商有关），要么把确认做成**在扇形内联**（按钮变成"确认停止？"），
 * 后者完全不需要第二个窗口，其实更稳。
 */
function confirmThenAct(opts) {
    trace('confirmThenAct 进入');
    FB.collapse(true);            /* 先收起扇形：确认期间不该留着一排按钮 */
    setTimeout(function () {
        /* 用户必须看得见确认弹窗，而弹窗画在 App 窗口里。
         * `bringToFront` 失败时 App 不在前台 → 弹窗建得出来但没人看得见
         * （外部表现为"点了停止，什么都没发生"）。所以把成败记进轨迹。 */
        var ok = false;
        try { ok = App.bringToFront(); } catch (e) { traceError('bringToFront', e); }
        trace('confirmThenAct bringToFront=' + ok);
        try {
            opts.dialog();
            trace('confirmThenAct 弹窗已弹出');
        } catch (e2) {
            traceError('confirmThenAct 弹窗', e2);
        }
    }, 150);
}

/** ② 停止：H5 二次确认（规格书 §10.6，停止必须确认、运行不用）。 */
function askStop() {
    var name = Session.scriptName || Pages.taskName(Session.tab);
    var elapsed = Records.formatDuration(Session.elapsedMs());
    confirmThenAct({
        dialog: function () {
            Dialog.stopScript(name, elapsed, function () {
                App.stopRun();
                App.renderScreen();
            });
        }
    });
}

/** ③ 退出应用：H6 二次确认（§10.7：停止脚本 + 关闭悬浮球 + 退出到桌面）。 */
function askExit() {
    confirmThenAct({
        dialog: function () {
            Dialog.exitApp(function () {
                if (Session.running) { App.stopRun(); }
                FB.destroy();
                App.exit();
            });
        }
    });
}

/**
 * 隐藏悬浮球（§10.3 第 3 项）。
 *
 * 规格书没写"隐藏之后怎么再显示"—— 没有恢复入口的话用户就再也找不回来了。
 * 所以这里落盘 `ball.hidden=true`，并在「我的」页给一个开关把它打开（本项目补充）。
 */
FB.hide = function () {
    Store.set("ball.hidden", true);
    FB.destroy();
    toast("\u5DF2\u9690\u85CF\u60AC\u6D6E\u7403\uFF08\u53EF\u5728\u300C\u6211\u7684\u300D\u91CC\u91CD\u65B0\u6253\u5F00\uFF09");
};

/* ------------------------------------------------- hidden 开关的双向同步 */

/** 「我的」页的开关调它：hidden=true 时立刻关掉球。 */
FB.setHidden = function (hidden) {
    Store.set("ball.hidden", !!hidden);
    if (hidden) { FB.destroy(); } else { FB.ensure(); }
};


/* ============================== src/page-id.js ============================== */
/* ============================== src/page-id.js ==============================
 * ID提取页 —— **三段式**（v8 / 2026-10-17）。
 *
 *   ① 取材  从哪儿找人 —— 可累加的取材清单（每条自带起点与深度）
 *   ② 只要这样的账号 —— 过滤条件（所有取材共用）
 *   ③ 输出  上限 / 去重 / 文件
 *
 * ## 为什么不再是"四张脚本卡选一个"
 * v7 及以前是四张卡单选。那四张卡其实是「起点（人从哪来）」×「深度（要不要再展开
 * 一层）」的 4 个**不完整组合**：各缺一块、各有别人没有的一块，合起来才完整。
 * 于是「同一时间仅可运行一个脚本」这条约束本身就在跟用户较劲 ——
 * 想同时抓"关键词视频的作者"和"文本里这批 uid 的粉丝"时，它直接不允许。
 *
 * 现在的模型：
 *   · **五个起点**（指定账号 / 搜索结果 / 某个视频的评论区 / 文本文件 / 当前屏幕）
 *   · **一个深度选项**（不展开 / 再取粉丝 / 再取关注），最多 2 层
 *   · 取材可加多条，**按顺序串行执行**（真机只有一个前台，没有并发可言），
 *     共用同一份去重集合与同一个输出文件
 *
 * ## 每个控件都有唯一含义
 * 选了什么起点才出现什么输入 —— 不会再有"勾上却无所指"的开关。
 * 这是 v7 那次"清语义"留下来的规矩，v8 继续守。
 */

var Pages = Pages || {};

/**
 * 各页脚本清单的集中注册表（main.js 用 key → 中文名翻译）。
 * ID提取已经没有"脚本"这个概念，但仍然注册一个占位条目：
 * 导出配置、运行日志、拦截提示里都会把 key 翻成中文名，
 * 让那套通用机制不必为 id 开特例。
 */
Pages.SCRIPTS_OF = {};
Pages.registerScripts = function (tab, list) {
    Pages.SCRIPTS_OF[tab] = list;
};

/* ★ 引擎声明：`engine` 一填，运行前置校验的第 4 步才会放行。
 * 没有它时点「开始运行」会被 Dialog.engineMissing 拦下 —— 这是有意的设计：
 * **绝不静默跑一个不相关的东西**。ID 提取的引擎侧（task = 'id'）已接入。 */
Pages.ID_SCRIPTS = [{ key: "id", name: "ID提取", engine: "tiktok-auto" }];
Pages.registerScripts("id", Pages.ID_SCRIPTS);

/* ============================================================ ① 取材 */

/** 候选文案数组（下拉要的是纯文案，顺序与 Sources 里的表一致）。 */
function labelsOf(table) {
    var out = [];
    for (var i = 0; i < table.length; i++) { out.push(table[i].label); }
    return out;
}

/** 取某个表里 key 的下标（选了之后要把文案换掉，回调给的是下标）。 */
function indexOfKey(table, key) {
    for (var i = 0; i < table.length; i++) {
        if (table[i].key === key) { return i; }
    }
    return 0;
}

/**
 * 切换"取哪些列表"里的某一项。
 *
 * **最后一个不许取消**：三个都取消，这条取材就没有任何来源可抓 ——
 * 它会变成一条永远跑不出结果的取材，而用户看不出为什么。
 */
function toggleListOf(itemId, key, next) {
    var cur = Sources.find(itemId);
    if (!cur) { return; }

    var list = cur.lists.slice();
    var at = list.indexOf(key);

    if (next && at < 0) {
        list.push(key);
    } else if (!next && at >= 0) {
        if (list.length === 1) {
            Dialog.alert("至少要留一个列表",
                "这条取材要取哪个列表？\n\n三个都取消的话，它就没有任何来源可抓了。");
            Pages.requestRerender();
            return;
        }
        list.splice(at, 1);
    } else {
        return;      /* 状态没变，不必写盘也不必重建 */
    }

    Sources.update(itemId, { lists: list });
    Pages.requestRerender();
}

/** 「取哪些列表」多选行。 */
function buildListPicker(item) {
    var row = U.row();
    for (var i = 0; i < Sources.LISTS.length; i++) {
        (function (entry, at) {
            var on = item.lists.indexOf(entry.key) >= 0;
            var box = W.checkRow(entry.label, on, function (next) {
                toggleListOf(item.id, entry.key, next);
            });
            if (at > 0) { row.addView(U.hgap(10)); }
            row.addView(box.root);
        })(Sources.LISTS[i], i);
    }
    return row;
}

/** 起点下拉（选完要重排输入行，所以必须重建整页）。 */
function buildKindChooser(item) {
    return W.chooser({
        label: Sources.kindLabel(item.kind),
        options: labelsOf(Sources.KINDS),
        index: function () {
            var cur = Sources.find(item.id);
            return indexOfKey(Sources.KINDS, cur ? cur.kind : "anchor");
        },
        onPick: function (i) {
            /* 换起点 → normalize 会把旧起点特有的参数丢掉（见 Sources.normalize 的第 ① 条） */
            Sources.update(item.id, { kind: Sources.KINDS[i].key });
            Pages.requestRerender();
        },
        minWidthDp: 110
    });
}

/** 深度下拉。`screen` 起点已经是最底层，不给这个选项。 */
function buildExpandChooser(item) {
    if (!Sources.canExpand(item.kind)) { return null; }
    return W.chooser({
        label: Sources.expandLabel(item.expand),
        options: labelsOf(Sources.EXPANDS),
        index: function () {
            var cur = Sources.find(item.id);
            return indexOfKey(Sources.EXPANDS, cur ? cur.expand : "");
        },
        onPick: function (i) {
            Sources.update(item.id, { expand: Sources.EXPANDS[i].key });
            Pages.requestRerender();
        },
        minWidthDp: 104
    });
}

/** 一个绑到取材字段的输入框（不是 Store 字段，所以用 read/write 而不是 path）。 */
function sourceField(item, key, placeholder, widthDp) {
    return W.inlineField({
        read: function () {
            var cur = Sources.find(item.id);
            return cur ? cur[key] : "";
        },
        write: function (value) {
            var patch = {};
            patch[key] = value;
            Sources.update(item.id, patch);
        },
        placeholder: placeholder,
        widthDp: widthDp
    });
}

/** 一条取材的输入区 —— **按起点分派**，选了什么才出现什么。 */
function buildSourceInputs(item) {
    var rows = [];

    /* —— 指定账号 —— */
    if (item.kind === "anchor") {
        rows.push(W.settingRow("账号",
            sourceField(item, "anchors", "账号1#账号2#账号3", 148).root, 8));
        rows.push(W.settingRow("取哪些列表", null, 0));
        rows.push(buildListPicker(item));
        rows.push(W.hint("账号留空 = 从当前屏幕上的列表直接抓", false));
    }

    /* —— 搜索结果 —— */
    if (item.kind === "search") {
        rows.push(W.settingRow("搜什么", W.chooser({
            label: item.searchType === "videos" ? "视频作者" : "用户",
            options: labelsOf(Sources.SEARCH_TYPES),
            index: function () {
                var cur = Sources.find(item.id);
                return indexOfKey(Sources.SEARCH_TYPES, cur ? cur.searchType : "users");
            },
            onPick: function (i) {
                Sources.update(item.id, { searchType: Sources.SEARCH_TYPES[i].key });
                Pages.requestRerender();
            },
            minWidthDp: 96
        }).root, 8));
        rows.push(W.settingRow("关键词",
            sourceField(item, "keyword", "关键词", 148).root, 8));
    }

    /* —— 某个视频的评论区 —— */
    if (item.kind === "video") {
        rows.push(W.settingRow("视频从哪来", W.chooser({
            label: item.videoSource === "keyword" ? "关键词搜索" : "当前屏幕",
            options: labelsOf(Sources.VIDEO_SOURCES),
            index: function () {
                var cur = Sources.find(item.id);
                return indexOfKey(Sources.VIDEO_SOURCES, cur ? cur.videoSource : "screen");
            },
            onPick: function (i) {
                Sources.update(item.id, { videoSource: Sources.VIDEO_SOURCES[i].key });
                Pages.requestRerender();
            },
            minWidthDp: 104
        }).root, 8));

        if (item.videoSource === "keyword") {
            rows.push(W.settingRow("搜索关键词",
                sourceField(item, "videoKeyword", "关键词", 148).root, 8));
        } else {
            rows.push(W.hint("当前屏幕 = 用你此刻停在的那条视频的评论区", false));
        }
    }

    /* —— 文本文件 —— */
    if (item.kind === "text") {
        var field = sourceField(item, "path", "文本路径", 108);
        var pathRow = U.row();
        pathRow.addView(U.text("文件", Theme.m.labelSize, Theme.hex.textSecondary, false));
        pathRow.addView(U.flexible());
        pathRow.addView(field.root);
        pathRow.addView(U.hgap(6));
        /* storePath 传 null：只让选择器回调路径，不写 Store（取材字段不在字段表里） */
        pathRow.addView(W.filePickerButton(null, function (picked) {
            Sources.update(item.id, { path: picked });
            field.paint();
        }).root);
        rows.push(pathRow);
        rows.push(W.hint("一行一个 UID；空行与 # 开头的行会被跳过", false));
    }

    /* —— 当前屏幕 —— */
    if (item.kind === "screen") {
        rows.push(W.hint("用你此刻停在的那个列表（粉丝页 / 关注页 / 评论区都行）", false));
    }

    /* —— 深度（所有起点共用，screen 除外） —— */
    var expand = buildExpandChooser(item);
    if (expand) {
        rows.push(W.settingRow("深度", expand.root, 8));
    }

    return rows;
}

/** 一条取材卡片。 */
function buildSourceCard(item, index) {
    var card = W.card(false);

    var head = U.row();
    head.addView(U.text("第 " + (index + 1) + " 条", Theme.m.labelSize, Theme.hex.textPrimary, true));
    head.addView(U.flexible());
    var remove = W.smallButton("删除", "danger", function () {
        Sources.removeAt(index);
        Pages.requestRerender();
    });
    head.addView(remove.root);

    var rows = [head];
    rows.push(U.spacer(4));
    rows.push(W.settingRow("起点", buildKindChooser(item).root, 8));

    var inputs = buildSourceInputs(item);
    for (var i = 0; i < inputs.length; i++) { rows.push(inputs[i]); }

    W.stack(card, rows, 10);
    return card;
}

/** 一条取材都没有时的占位 —— 不用 `W.emptyState`（它靠 weight 撑满整屏，在滚动页里不成立）。 */
function buildSourcesEmpty() {
    var box = U.column();
    box.setBackground(U.strokeBg(0.03, 0.10, "#FFFFFF", Theme.m.cardRadius));
    box.setPadding(U.dp(16), U.dp(22), U.dp(16), U.dp(22));

    var head = U.text("还没有取材", 13, Theme.hex.textSecondary, true);
    head.setGravity(android.view.Gravity.CENTER);
    box.addView(head);
    box.addView(U.spacer(6));

    var sub = U.text("点下面的「添加一条取材」，选从哪儿找人", Theme.m.hintSize,
                     Theme.hex.textFaint, false);
    sub.setGravity(android.view.Gravity.CENTER);
    box.addView(sub);
    return box;
}

/* ============================================== ② 只要这样的账号 */

/** 卡内分组标题（与 v7 一致：比 sectionTitle 轻一档）。 */
function featureGroup(title) {
    var view = U.text(title, 11, Theme.hex.textMuted, true);
    view.setPadding(0, U.dp(8), 0, 0);
    return view;
}

/**
 * ② 过滤：所有取材共用。
 *
 * 这里**一项都不删**（v7 的成果）：私密 / 无头像 / 语言 / 取样范围 / 四组数量门槛。
 * 只有「提取区域」「AI 画像识别」两项当前没有承载者 → 灰行 + 暂不支持
 * （不给一个能开却什么也不会发生的开关）。
 */
function buildAccountFilters() {
    var card = W.card(false);
    var base = "tabs.id.features.";
    var blocks = [];

    blocks.push(featureGroup("账号特征"));

    var privateRow = W.checkRow("过滤私密账户", Store.getBool(base + "filterPrivate"),
                                function (on) { Store.set(base + "filterPrivate", on); });
    var noAvatarRow = W.checkRow("过滤无头像账户", Store.getBool(base + "filterNoAvatar"),
                                 function (on) { Store.set(base + "filterNoAvatar", on); });
    var filterLine = U.row();
    U.params(privateRow.root, 0, -2, 1);
    U.params(noAvatarRow.root, 0, -2, 1);
    filterLine.addView(privateRow.root);
    filterLine.addView(noAvatarRow.root);
    blocks.push(filterLine);

    /* 语言区域 + 取样范围：后者是前者的**取样字段**，不是独立的过滤条件 */
    var langRow = U.row();
    langRow.addView(U.text("语言区域", Theme.m.labelSize, Theme.hex.textSecondary, false));
    langRow.addView(U.hgap(8));
    langRow.addView(W.dropdown("langRegion", base + "langRegion").root);
    langRow.addView(U.flexible());
    langRow.addView(U.text("取样范围", Theme.m.labelSize, Theme.hex.textSecondary, false));
    langRow.addView(U.hgap(8));
    langRow.addView(W.dropdown("nicknameCheck", base + "nicknameCheck").root);
    blocks.push(langRow);

    blocks.push(W.mutedRow("提取区域", Store.getText(base + "regionCodes"), function () {
        Dialog.alert("提取区域 · 暂不支持",
            "TikTok 的用户页**不显示账号所属国家**，没有可靠的地方能读到它，"
            + "所以这一项目前不会生效。\n\n"
            + "你填的国家简码（" + Store.getText(base + "regionCodes") + "）已经保留，"
            + "将来接入地区数据源后会直接生效，不需要重新填。\n\n"
            + "当前版本的过滤只有：私密、无头像、语言，以及下面的四组数量门槛。");
    }).root);

    blocks.push(W.mutedRow("AI 画像识别", "头像 · 性别 · 年龄", function () {
        Dialog.alert("AI 画像识别 · 暂不支持",
            "AI 头像识别 / AI 性别 / AI 年龄需要人脸与属性模型（本地模型或云端接口），"
            + "当前版本没有承载者。\n\n"
            + "这三项原来的设置值都已保留，将来接入后直接生效。\n\n"
            + "把关掉的道理和「提取区域」一样：与其给一个开了也不发生任何事的开关，"
            + "不如明确告诉你它现在不参与。");
    }).root);

    blocks.push(featureGroup("数值门槛"));

    var metrics = [
        { key: "follow", label: "关注量" },
        { key: "fans",   label: "粉丝量" },
        { key: "likes",  label: "获赞量" },
        { key: "videos", label: "视频量" }
    ];
    for (var i = 0; i < metrics.length; i++) {
        var m = metrics[i];
        blocks.push(W.rangeRow(base + m.key + "Min", base + m.key + "Max", m.label, "~").root);
    }

    W.stack(card, blocks, 12);
    return card;
}

/* ============================================== ③ 输出 */

function buildOutput() {
    var card = W.card(false);
    var base = "tabs.id.features.";
    var blocks = [];

    var localBox = W.checkRow("本地去重", Store.getBool(base + "dedupeLocal"),
                              function (on) { Store.set(base + "dedupeLocal", on); });
    var historyBox = W.checkRow("跨轮去重", Store.getBool(base + "dedupeHistory"),
                                function (on) {
        Store.set(base + "dedupeHistory", on);
        Pages.requestRerender();      /* 打开后会多一行说明 */
    });
    var dedupeRow = U.row();
    U.params(localBox.root, 0, -2, 1);
    U.params(historyBox.root, 0, -2, 1);
    dedupeRow.addView(localBox.root);
    dedupeRow.addView(historyBox.root);
    blocks.push(dedupeRow);

    if (Store.getBool(base + "dedupeHistory")) {
        blocks.push(W.hint("跨轮 = 与历史已提取的 ID 比对，重复的跳过", false));
    }

    /* 云端去重：勾选后才出现表名与连通测试 */
    var cloudBox = W.checkRow("云端去重", Store.getBool(base + "cloudDedupe"),
                              function (on) {
        Store.set(base + "cloudDedupe", on);
        Pages.requestRerender();
    });
    if (Store.getBool(base + "cloudDedupe")) {
        var cloudRow = U.row();
        cloudRow.addView(cloudBox.root);
        cloudRow.addView(U.flexible());
        cloudRow.addView(W.textField(base + "cloudTable", "表名：字符", 100).root);
        cloudRow.addView(U.hgap(6));
        var testBtn = W.chip("连通测试", "accent");
        testBtn.root.setOnClickListener(function () {
            var table = Store.getText(base + "cloudTable");
            Dialog.alert("连通测试",
                table === "" ? "请先填写表名。"
                             : "表名：" + table + "\n\n当前未配置云端去重服务地址，无法真实测试。");
        });
        cloudRow.addView(testBtn.root);
        blocks.push(cloudRow);
    } else {
        blocks.push(cloudBox.root);
    }

    /* 提取上限：0 的语义写在文案里 —— 只说"0"，用户会以为是"提取 0 个" */
    var stopRow = U.row();
    stopRow.addView(U.text("提取满", Theme.m.labelSize, Theme.hex.textSecondary, false));
    stopRow.addView(U.flexible());
    stopRow.addView(W.numberField(base + "extractLimit", "提取符合").root);
    stopRow.addView(U.hgap(6));
    stopRow.addView(U.text("个 ID 后停止（0 = 不限）", Theme.m.labelSize, Theme.hex.textMuted, false));
    blocks.push(stopRow);

    /* 运行时长：它现在是**下限**而不是上限 —— 引擎会按提取上限自动放宽
     * （每个收录约 20 秒，见 tiktok-auto/src/idflow.js 的 budgetFor）。
     * 设 100 个却只给 30 分钟，会永远抓不满；所以文案必须说清"会自动放宽"。 */
    var runtimeRow = U.row();
    runtimeRow.addView(U.text("至少运行", Theme.m.labelSize, Theme.hex.textSecondary, false));
    runtimeRow.addView(U.flexible());
    runtimeRow.addView(W.numberField(base + "maxRuntimeMin", "30").root);
    runtimeRow.addView(U.hgap(6));
    runtimeRow.addView(U.text("分钟（按提取上限自动放宽，最多 4 小时）",
        Theme.m.labelSize, Theme.hex.textMuted, false));
    blocks.push(runtimeRow);

    /* 数字 uid：默认开。它要额外下一遍用户主页（约 2.5 秒/个），
     * 只要 handle 的场景可以关掉省时间 —— 以前没有开关，想关只能改配置。 */
    var resolveBox = W.checkRow("同时解析数字 uid", Store.getBool(base + "resolveUid"),
                                function (on) { Store.set(base + "resolveUid", on); });
    blocks.push(resolveBox.root);
    if (Store.getBool(base + "resolveUid")) {
        blocks.push(W.hint("抓完再逐个换成 TikTok 内部的数字 uid，另存一份 uid_map 文件；每个约多花 2~3 秒", false));
    }

    blocks.push(W.hint("结果文件自动命名 uid_日期_时分.txt，存放在 /sdcard/Download/tiktok_app", false));

    W.stack(card, blocks, 12);
    return card;
}

/* ============================================== ⓪ 断点提示条 */

/**
 * 「上次没跑完」的提示条。三种状态各自一套文案与动作：
 *
 * | 状态 | 标题 | 动作 |
 * |---|---|---|
 * | 可续跑 | 上次运行没跑完（已收 N 个） | 继续 / 清空 |
 * | 配置变了 | 上次运行无法继续 | 清空断点 |
 * | 结果文件没了 | 上次运行无法继续 | 清空断点 |
 *
 * 后两种只给「清空断点」——没有别的能做的，说清原因比给一个点了没用的按钮强。
 */
function buildResumeNotice(snap) {
    if (snap.valid) {
        return W.noticeBar({
            title: "上次运行没跑完（已收 " + snap.extracted + " 个）",
            detail: Resume.detail(snap),
            tone: "accent",
            actions: [
                { label: "继续", tone: "accent", onClick: function () { App.resumeRun(); } },
                { label: "清空", tone: "mute", onClick: function () { App.clearCheckpoint(); } }
            ]
        }).root;
    }
    return W.noticeBar({
        title: "上次运行无法继续",
        detail: snap.message || "断点已失效",
        tone: "warn",
        actions: [
            { label: "清空断点", tone: "mute", onClick: function () { App.clearCheckpoint(); } }
        ]
    }).root;
}

/* ============================================== 页面 */

Pages.id = function (rerender) {
    var inner = U.column();
    var blocks = [];

    /* ——— ⓪ 断点提示（有未跑完的才出现）———
     * 放在最上面：用户进这个页最想知道的就是"我上次那轮还没跑完"。
     * 只在没有运行中时出现 —— 跑着的时候点"继续"只会撞上"已有任务在跑"。
     * snapshot 一次读盘，不在下面各处重复读。 */
    var snap = Resume.snapshot();
    if (!Session.running && snap.exists && !snap.finished && snap.reason !== 'cleared') {
        blocks.push(buildResumeNotice(snap));
        blocks.push(U.spacer(Theme.m.gapCard));
    }

    /* ——— ① 取材 ——— */
    blocks.push(W.sectionTitle("取材"));
    blocks.push(W.hint("从哪儿找人。可添加多条，按顺序执行；共用同一份去重与输出", false));

    var list = Sources.list();
    if (list.length === 0) {
        blocks.push(buildSourcesEmpty());
    } else {
        for (var i = 0; i < list.length; i++) {
            blocks.push(buildSourceCard(list[i], i));
        }
    }

    if (list.length < Sources.MAX) {
        var add = W.ghostButton("＋ 添加一条取材", 44, function () {
            if (Sources.count() >= Sources.MAX) { return; }
            Sources.add("anchor");
            Pages.requestRerender();
        });
        blocks.push(add.root);
    } else {
        blocks.push(W.hint("已达上限 " + Sources.MAX + " 条 —— 想加新的先删一条", false));
    }

    /* ——— ② 只要这样的账号 ——— */
    blocks.push(U.spacer(4));
    blocks.push(W.sectionTitle("只要这样的账号"));
    blocks.push(buildAccountFilters());

    /* ——— ③ 输出 ——— */
    blocks.push(U.spacer(4));
    blocks.push(W.sectionTitle("输出"));
    blocks.push(buildOutput());

    /* 运行中的约束提示留在页尾：它约束的是整页，而它只在运行中出现 */
    if (Session.running) {
        blocks.push(U.spacer(4));
        blocks.push(W.hint("运行中不可修改取材 · 请保持无障碍权限开启", true));
    }

    W.stack(inner, blocks, Theme.m.gapPage);

    var scroller = W.scroller();
    scroller.addView(inner);
    return scroller;
};


/* ============================== src/page-dm.js ============================== */
/* ============================== src/page-dm.js ==============================
 * UID私信页（设计稿 3:534 与展开态 7:11）。
 *
 * 结构：脚本选择（2 张卡）→ 功能设置 → 私信 / 评论设置。
 *
 * ⚠️ 设计稿两版的功能设置卡内容不一致：
 *      3:579（折叠态页面）：AI 性别 / 关注上限 / 私信上限 / 休息间隔
 *      7:79 （展开态页面）：进行关注私信 / 关注上限 / 私信上限 / 去重方式
 *    逐版核对过：**「关注上限」与「私信上限」两版都是分开的两行**，
 *    差异只在「有没有那个进行关注/私信的合并开关」。这里两张卡的设置都保留。
 */

var Pages = Pages || {};

Pages.DM_SCRIPTS = [
    { key: "s1", name: "脚本一 \u00B7 已提 UID 私信" },
    { key: "s2", name: "脚本二 \u00B7 自己粉丝私信" }
];

Pages.registerScripts("dm", Pages.DM_SCRIPTS);

/** 脚本一展开后的四行：按什么条件筛、筛完做什么、从哪儿读 UID。 */
function buildDmScript1Detail(rerender) {
    var base = "tabs.dm.scripts.s1.";
    var detail = U.column();
    var rows = [];

    /* UID 私信：勾选后对筛出的 UID 逐个发私信 */
    var doDmBox = W.checkbox(Store.get(base + "doDm", true), 16);
    doDmBox.root.setOnClickListener(function () {
        var next = !doDmBox.isChecked();
        doDmBox.set(next);
        Store.set(base + "doDm", next);
    });
    var doDmLabel = U.text("UID \u79C1\u4FE1", Theme.m.labelSize, Theme.hex.textSecondary, false);
    var doDmRow = U.row();
    doDmRow.addView(doDmBox.root);
    doDmRow.addView(U.hgap(8));
    doDmRow.addView(doDmLabel);
    doDmRow.addView(U.flexible());
    rows.push(doDmRow);

    rows.push(W.settingRow("\u7B5B\u9996\u89C6\u9891\u65E5\u671F",
        W.dropdown("filterDate", base + "filterDate").root, 8));

    rows.push(W.settingRow("\u9996\u89C6\u9891\u70B9\u8D5E / \u9996\u89C6\u9891\u8BC4\u8BBA",
        W.dropdown("firstAction", base + "firstAction").root, 6));

    rows.push(W.filePicker("\u5DF2\u7B5B\u7B26\u5408\u7684 UID \u6587\u672C", base + "uidTextPath", "\u9009\u62E9").root);

    W.stack(detail, rows, 12);
    return detail;
}

function buildDmScriptCard(script, rerender) {
    var base = "tabs.dm.scripts." + script.key + ".";
    var checked = Store.getBool(base + "checked");
    var expanded = Store.getBool(base + "expanded");

    var card = W.card(checked);
    card.addView(W.scriptHeader({
        checked: checked,
        expanded: expanded,
        name: script.name,
        summary: null,
        disabled: Session.running,
        onToggleCheck: function (next) {
            Store.set(base + "checked", next);
            rerender();
        },
        onToggleExpand: function () {
            Store.set(base + "expanded", !expanded);
            rerender();
        }
    }).root);

    if (expanded && script.key === "s1") {
        card.addView(U.spacer(12));
        card.addView(buildDmScript1Detail(rerender));
    }
    return card;
}

/**
 * 功能设置卡（设计稿 3:579 折叠态 / 7:79 展开态）。
 *
 * 三处刻意保留的写法：
 *   · **进行关注 / 进行私信是两个独立开关**（稿子 7:79 把它们合成一个）。
 *     合成一个的话，想单独关掉私信就得连关注一起关。
 *   · **数量用区间**（关注数量 / 私信数量 / 休息时间）：一个量的下界与上界，
 *     一行两项、两个数各自可改。
 *   · **去重方式只出现在展开态卡片上**，这里一并保留（两版稿的并集）。
 */
function buildDmSettings() {
    var card = W.card(false);

    var rows = [
        W.settingRow("AI 性别",
            W.dropdown("aiGender", "tabs.dm.aiGender").root, 6),

        /* ——— 关注 ——— */
        W.settingRow("进行关注",
            W.toggle(Store.getBool("tabs.dm.doFollow"), function (on) {
                Store.set("tabs.dm.doFollow", on);
            }).root, 6),
        W.rangeRow("tabs.dm.followMin", "tabs.dm.followMax", "关注数量", "~").root,

        /* ——— 私信 ——— */
        W.settingRow("进行私信",
            W.toggle(Store.getBool("tabs.dm.doDm"), function (on) {
                Store.set("tabs.dm.doDm", on);
            }).root, 6),
        W.rangeRow("tabs.dm.dmMin", "tabs.dm.dmMax", "私信数量", "~").root,

        /* ——— 休息时间：一个区间的两个端点 ——— */
        W.rangeRow("tabs.dm.restMin", "tabs.dm.restMax", "休息时间（秒）", "~").root,

        W.settingRow("去重方式",
            W.dropdown("dedupeMode", "tabs.dm.dedupeMode").root, 6)
    ];

    W.stack(card, rows, 12);
    return card;
}

/** 私信 / 评论文本设置卡。 */
function buildDmTexts() {
    var card = W.card(false);
    var rows = [
        W.filePicker("\u968F\u673A\u79C1\u4FE1\u6587\u672C", "tabs.dm.dmTextPath").root,
        W.filePicker("\u968F\u673A\u8BC4\u8BBA\u6587\u672C", "tabs.dm.commentTextPath").root
    ];
    W.stack(card, rows, 12);
    return card;
}

Pages.dm = function (rerender) {
    var inner = U.column();
    var blocks = [];

    blocks.push(W.sectionTitle("\u811A\u672C\u9009\u62E9"));
    for (var i = 0; i < Pages.DM_SCRIPTS.length; i++) {
        blocks.push(buildDmScriptCard(Pages.DM_SCRIPTS[i], rerender));
    }

    blocks.push(U.spacer(4));
    blocks.push(W.sectionTitle("\u529F\u80FD\u8BBE\u7F6E"));
    blocks.push(buildDmSettings());

    blocks.push(U.spacer(4));
    blocks.push(W.sectionTitle("\u79C1\u4FE1 / \u8BC4\u8BBA\u8BBE\u7F6E"));
    blocks.push(buildDmTexts());

    /* 本页内容会超出屏幕，末尾留一点余量，避免最后一张卡贴着滚动边界 */
    blocks.push(U.spacer(8));

    W.stack(inner, blocks, Theme.m.gapCard);

    var scroller = W.scroller();
    scroller.addView(inner);
    return scroller;
};

/* ============================== src/page-nurture.js ======================
 * 养号页（设计稿 3:469）。
 *
 * 结构：脚本选择（1 张卡）→ 养号参数卡 → 底部提示（左对齐）。
 *
 * 概率仍是固定档位（下拉），浏览时长与单次操作则是区间：
 * 养号动作的强度直接决定账号安全，概率给几个安全档位比让用户随手填 90% 更负责；
 * 而时长与次数天然有「最少/最多」两个端点，用区间表达最贴切。
 */
Pages.NURTURE_SCRIPTS = [
    { key: "s1", name: "\u968F\u673A\u64CD\u4F5C\u517B\u53F7" }
];

Pages.registerScripts("nurture", Pages.NURTURE_SCRIPTS);

/** 养号参数卡（设计稿 16:2）。 */
function buildNurtureParams() {
    var card = W.card(false);
    var base = "tabs.nurture.";
    var rows = [
        W.rangeRow(base + "browseMin", base + "browseMax", "\u6D4F\u89C8\u65F6\u957F\uFF08\u5206\u949F\uFF09", "~").root,
        W.settingRow("\u70B9\u8D5E\u6982\u7387",
            W.dropdown("likeRate", base + "likeRate").root, 8),
        W.settingRow("\u8BC4\u8BBA\u6982\u7387",
            W.dropdown("commentRate", base + "commentRate").root, 8),
        W.settingRow("\u5173\u6CE8\u6982\u7387",
            W.dropdown("followRate", base + "followRate").root, 8),
        W.rangeRow(base + "actionMin", base + "actionMax", "\u5355\u6B21\u64CD\u4F5C", "~").root
    ];
    W.stack(card, rows, 12);
    return card;
}

Pages.nurture = function (rerender) {
    var inner = U.column();
    var blocks = [];

    blocks.push(W.sectionTitle("\u811A\u672C\u9009\u62E9"));

    for (var i = 0; i < Pages.NURTURE_SCRIPTS.length; i++) {
        var script = Pages.NURTURE_SCRIPTS[i];
        var base = "tabs.nurture.scripts." + script.key + ".";
        var checked = Store.getBool(base + "checked");
        var expanded = Store.getBool(base + "expanded");

        var card = W.card(checked);
        card.addView(W.scriptHeader({
            checked: checked,
            expanded: expanded,
            name: script.name,
            summary: null,
            disabled: Session.running,
            onToggleCheck: function (next) {
                Store.set(base + "checked", next);
                rerender();
            },
            onToggleExpand: function () {
                Store.set(base + "expanded", !expanded);
                rerender();
            }
        }).root);
        blocks.push(card);
    }

    blocks.push(U.spacer(4));
    blocks.push(W.sectionTitle("\u517B\u53F7\u53C2\u6570"));
    blocks.push(buildNurtureParams());

    blocks.push(U.spacer(8));
    /* 设计稿 3:506：这行是左对齐的，不像其它页居中 */
    blocks.push(W.hint("\u968F\u673A\u6D4F\u89C8\u3001\u70B9\u8D5E\u3001\u8BC4\u8BBA\u6A21\u62DF\u771F\u5B9E\u6D3B\u8DC3\u5EA6", false));

    W.stack(inner, blocks, Theme.m.gapPage);

    var scroller = W.scroller();
    scroller.addView(inner);
    return scroller;
};


/* ============================== src/page-video.js ============================== */
/* ============================== src/page-video.js ==============================
 * 视频功能页（设计稿 3:629）。
 *
 * 结构：脚本选择（1 张卡）→ 功能设置 → 私信 / 评论设置。
 *
 * 与 UID私信页的差别在「执行操作」这一行：它是一行多选（关注/私信/点赞/评论），
 * 所以用的是 W.toggleRow 而不是 W.toggle。
 */

var Pages = Pages || {};

/**
 * 视频功能页的脚本。
 *
 * `engine` 指名由哪个执行引擎驱动 —— 目前只有这一页接了 tiktok-auto。
 * 其它页的脚本没有这个字段，点「开始运行」会被拦下并说明原因
 * （见 App.toggleRun 与 Dialog.engineMissing），而不是静默跑一个不相关的东西。
 */
Pages.VIDEO_SCRIPTS = [
    { key: "s1", name: "\u5173\u952E\u8BCD\u89C6\u9891\u529F\u80FD", engine: "tiktok-auto" }
];

Pages.registerScripts("video", Pages.VIDEO_SCRIPTS);

/** 「执行操作」四项的定义。顺序即设计稿从左到右的顺序。 */
Pages.VIDEO_ACTIONS = [
    { key: "follow",  label: "\u5173\u6CE8" },
    { key: "dm",      label: "\u79C1\u4FE1" },
    { key: "like",    label: "\u70B9\u8D5E" },
    { key: "comment", label: "\u8BC4\u8BBA" }
];

function buildVideoScriptCard(rerender) {
    var base = "tabs.video.scripts.s1.";
    var checked = Store.getBool(base + "checked");
    var expanded = Store.getBool(base + "expanded");

    var card = W.card(checked);
    card.addView(W.scriptHeader({
        checked: checked,
        expanded: expanded,
        name: Pages.VIDEO_SCRIPTS[0].name,
        summary: null,
        disabled: Session.running,
        onToggleCheck: function (next) {
            Store.set(base + "checked", next);
            rerender();
        },
        onToggleExpand: function () {
            Store.set(base + "expanded", !expanded);
            rerender();
        }
    }).root);
    return card;
}

/** 功能设置卡（设计稿 3:667）：搜索条件 + 节奏 + 动作开关。 */
function buildVideoSettings() {
    var card = W.card(false);
    var rows = [];

    rows.push(W.settingRow("\u5173\u952E\u8BCD",
        W.textField("tabs.video.keyword", "\u641C\u7D22", 100).root, 6));

    rows.push(W.settingRow("\u4E3B\u64AD\u533A\u57DF",
        W.textField("tabs.video.region", "\u56FD\u5BB6\u7B80\u7801", 100).root, 6));

    /* 停止个数与间隔时间都是区间：一行两项，两个数各自可改 */
    rows.push(W.rangeRow("tabs.video.stopMin", "tabs.video.stopMax",
                         "\u505C\u6B62\u4E2A\u6570", "~").root);

    rows.push(W.rangeRow("tabs.video.intervalMin", "tabs.video.intervalMax",
                         "\u95F4\u9694\u65F6\u95F4\uFF08\u79D2\uFF09", "~").root);

    /* 动作开关：四个独立，改了立即落盘 */
    var actionItems = [];
    for (var i = 0; i < Pages.VIDEO_ACTIONS.length; i++) {
        var action = Pages.VIDEO_ACTIONS[i];
        actionItems.push({
            key: action.key,
            label: action.label,
            on: Store.getBool("tabs.video.actions." + action.key)
        });
    }
    rows.push(W.settingRow("\u6267\u884C\u64CD\u4F5C",
        W.toggleRow(actionItems, function (key, on) {
            Store.set("tabs.video.actions." + key, on);
        }).root, 6));

    W.stack(card, rows, 12);
    return card;
}

/** 文本设置卡：私信与评论内容文件。 */
function buildVideoTexts() {
    var card = W.card(false);
    var rows = [
        W.filePicker("随机私信内容 1-3", "tabs.video.dmTextPath").root,
        W.filePicker("随机评论内容 1-3", "tabs.video.commentTextPath").root
    ];
    W.stack(card, rows, 12);
    return card;
}

Pages.video = function (rerender) {
    var inner = U.column();
    var blocks = [];

    blocks.push(W.sectionTitle("\u811A\u672C\u9009\u62E9"));
    blocks.push(buildVideoScriptCard(rerender));

    blocks.push(U.spacer(4));
    blocks.push(W.sectionTitle("\u529F\u80FD\u8BBE\u7F6E"));
    blocks.push(buildVideoSettings());

    blocks.push(U.spacer(4));
    blocks.push(W.sectionTitle("\u79C1\u4FE1 / \u8BC4\u8BBA\u8BBE\u7F6E"));
    blocks.push(buildVideoTexts());

    /* 内容超出屏幕，末尾留余量避免最后一张卡贴着滚动边界 */
    blocks.push(U.spacer(8));

    W.stack(inner, blocks, Theme.m.gapCard);

    var scroller = W.scroller();
    scroller.addView(inner);
    return scroller;
};


/* ============================== src/page-tasks.js ============================== */
/* ============================== src/page-tasks.js ==============================
 * 任务列表（规格书 B1 / B2，设计稿 30:102 / 30:203）。
 *
 * ## 这一页是整个改版的核心
 * 底栏从「5 个页签」变成「3 个 tab」之后，原来的 ID提取 / UID私信 / 养号 / 视频功能
 * **降级为这里的四张任务卡**，各自的页面成了二级页（见 Pages.DETAILS）。
 * 所以这一页不只是"多了一个列表"：它是新的入口层级。
 *
 * ## 任务清单与「脚本清单」是两张表
 *   · `Pages.TASKS`     —— 四张卡（名称 / 图标 / 颜色），**顺序即设计稿顺序**；
 *   · `Pages.SCRIPTS_OF`—— 每个任务下的脚本（各页自己注册，见 page-id/page-dm/page-video）。
 * 任务卡要显示「当前：xxx」，就得把两张表拼起来 —— 拼接逻辑集中在
 * `Pages.checkedScript()`，`App.currentTask()` 也复用它，避免两处各判一遍单选。
 */

var Pages = Pages || {};

/**
 * 四个任务。key 与旧的页签 key、以及配置路径 `tabs.<key>.*` **完全一致** ——
 * 这不是巧合：老用户的配置一条都不用搬家（见 Store.MIGRATIONS[5]）。
 *
 * 颜色取设计稿任务卡图标框的衬底色（14% 透明底 + 同色字形）：
 *   ID提取 #2EA6FF / UID私信 #9482FF / 养号 #12DEC4 / 视频功能 #F5C24A
 * 图标一律用 U+25xx 几何块字符（彩色 emoji 的坑见 W.TABS 注释）。
 */
Pages.TASKS = [
    { key: "id",      name: "ID\u63D0\u53D6",   icon: "\u25A4", colorHex: Theme.hex.accent },
    { key: "dm",      name: "UID\u79C1\u4FE1",  icon: "\u25A5", colorHex: Theme.hex.violet },
    { key: "nurture", name: "\u517B\u53F7",     icon: "\u25D4", colorHex: Theme.hex.ok },
    { key: "video",   name: "\u89C6\u9891\u529F\u80FD", icon: "\u25B6", colorHex: Theme.hex.warn }
];

/** 二级页的标题（返回头上显示的就是它）。 */
Pages.DETAIL_TITLES = {
    id: "ID\u63D0\u53D6",
    dm: "UID\u79C1\u4FE1",
    nurture: "\u517B\u53F7",
    video: "\u89C6\u9891\u529F\u80FD"
};

Pages.taskOf = function (key) {
    for (var i = 0; i < Pages.TASKS.length; i++) {
        if (Pages.TASKS[i].key === key) { return Pages.TASKS[i]; }
    }
    return null;
};

Pages.taskName = function (key) {
    var task = Pages.taskOf(key);
    return task ? task.name : String(key || "");
};

/**
 * 某个任务**当前选中的脚本**（没选返回 null）。
 *
 * 单选规则由各页自己保证（ID提取页是 `Pages.toggleIdScript`），
 * 这里只做"第一个勾上的就是它"的读取 —— 与 `App.currentTask()` 的旧逻辑一致，
 * 但接受任意任务 key，而不是只认当前 tab。
 */
Pages.checkedScript = function (taskKey) {
    /* ★ v8：ID提取没有"脚本"这个概念了 —— 它的配置是**取材清单**。
     * 所以"已配置" = 清单非空，而不是"某张卡的 checked 为真"（那些字段已删除）。
     * 两个名字分开给：
     *   · `name` 给拦截弹窗用（「ID提取的执行引擎尚未接入」比塞一整段摘要更像人话）；
     *   · `detail` 给任务卡的「当前：…」用（那里正需要"从哪儿取材"这个信息）。 */
    if (taskKey === "id") {
        if (Sources.isEmpty()) { return null; }
        /* 引擎声明仍然从 SCRIPTS_OF 读：将来 ID提取 接入执行引擎时，
         * 在 `Pages.ID_SCRIPTS` 上加一个 `engine` 字段就够了，这里不用改。 */
        var idEntry = (Pages.SCRIPTS_OF["id"] || [])[0] || {};
        return {
            key: "id",
            name: Pages.taskName("id"),
            detail: Sources.summary(),
            engine: idEntry.engine || "",
            task: "id",
            taskName: Pages.taskName("id")
        };
    }

    var list = Pages.SCRIPTS_OF[taskKey] || [];
    for (var i = 0; i < list.length; i++) {
        var entry = Store.getBool("tabs." + taskKey + ".scripts." + list[i].key + ".checked");
        if (entry) {
            return {
                key: list[i].key,
                name: list[i].name,
                detail: list[i].name,
                engine: list[i].engine || "",
                task: taskKey,
                taskName: Pages.taskName(taskKey)
            };
        }
    }
    return null;
};

/** 该任务是否正在被驱动。运行态是全局单跑，所以只要 Session.tab 对上就是它。 */
Pages.taskIsRunning = function (taskKey) {
    return !!Session.running && Session.tab === taskKey;
};

/**
 * 任务卡的状态徽标（设计稿：空闲 灰 / 运行中 绿 / 未配置 琥珀）。
 *
 * 「未配置」= 这个任务当前没有任何脚本被选中。ID提取页默认一个都不选
 * （设计稿 16:23 专门画了"未选择脚本"那一屏），所以它一进来就是琥珀色 ——
 * 这正是要给用户的信号：想跑先选一个。
 */
Pages.taskState = function (taskKey) {
    if (Pages.taskIsRunning(taskKey)) {
        return { badge: "\u8FD0\u884C\u4E2D", tone: "ok" };
    }
    if (!Pages.checkedScript(taskKey)) {
        return { badge: "\u672A\u914D\u7F6E", tone: "warn" };
    }
    return { badge: "\u7A7A\u95F2", tone: "mute" };
};

/** 任务卡的「当前：xxx」一行。 */
Pages.taskScriptLine = function (taskKey) {
    var script = Pages.checkedScript(taskKey);
    if (!script) {
        /* v8：ID提取没有"脚本"了，它的空态是"还没添加取材" */
        return "\u5F53\u524D\uFF1A" + (taskKey === "id" ? "\u672A\u6DFB\u52A0\u53D6\u6750" : "\u672A\u9009\u62E9\u811A\u672C");
    }
    /* detail 才是"从哪儿取材"（ID提取用清单摘要，其它任务与 name 相同） */
    return "\u5F53\u524D\uFF1A" + (script.detail || script.name);
};

/* ------------------------------------------------------------ 任务卡 */

function buildTaskCard(task) {
    var state = Pages.taskState(task.key);
    var running = Pages.taskIsRunning(task.key);

    return W.taskCard({
        name: task.name,
        iconChar: task.icon,
        colorHex: task.colorHex,
        badge: state.badge,
        badgeTone: state.tone,
        scriptLine: Pages.taskScriptLine(task.key),
        lastLine: Records.lastRunLine(task.key),
        running: running,
        /* 点卡片主体 → 进该任务的详情页 */
        onOpen: function () {
            App.openDetail(task.key);
        },
        /* 点「运行」→ 直接跑这个任务当前选中的脚本（不必先切页签再点底部按钮）。
         * 运行中的那一个按钮是「停止」：它停的是**全局运行**，
         * 点别的任务的「运行」也不会被禁用 —— 由 App.requestRun 弹 F3 确认（规格书 §2.3）。 */
        onRun: function () {
            if (running) {
                App.stopRun();
                App.renderScreen();
                return;
            }
            App.requestRun(task.key);
        }
    }).root;
}

/* ------------------------------------------------------------ 页面 */

/** B1/B2：任务列表（运行态只是同一个页面的另一种状态）。
 *
 * ⚠️ 这里**不画**页面标题区：标题区由路由层统一加（App.renderContent 的
 * 「一级 tab」分支），页面自己再加一次就会渲染出两遍。
 * 页面只负责"这一 tab 的内容"。
 */
Pages.tasks = function () {
    var inner = U.column();
    var blocks = [];

    var section = U.column();
    section.addView(W.sectionTitle("\u4EFB\u52A1"));
    section.addView(U.spacer(4));
    /* 区说明是刻意保留的：全局单跑是这一页最需要被知道的一条规则 ——
     * 四张卡上都有「运行」按钮，不写清楚没人知道它们互斥。 */
    section.addView(U.text("\u5168\u5C40\u5355\u8DD1\uFF1A\u540C\u4E00\u65F6\u95F4\u4EC5\u53EF\u8FD0\u884C\u4E00\u4E2A\u811A\u672C",
                           Theme.m.hintSize, Theme.hex.textDim, false));
    blocks.push(section);
    blocks.push(U.spacer(Theme.m.gapCard));

    for (var i = 0; i < Pages.TASKS.length; i++) {
        blocks.push(buildTaskCard(Pages.TASKS[i]));
        if (i < Pages.TASKS.length - 1) { blocks.push(U.spacer(Theme.m.gapCard)); }
    }

    /* 末尾余量：最后一张卡贴着底栏时会被渐隐压住 */
    blocks.push(U.spacer(8));

    W.stack(inner, blocks, 0);

    var scroller = W.scroller();
    scroller.addView(inner);
    return scroller;
};


/* ============================== src/page-records.js ============================== */
/* ============================== src/page-records.js ==============================
 * 运行记录（规格书 D1/D2/D3，设计稿 30:871 / 30:958 / 30:1241）。
 *
 * D1 是「记录」tab 的一级页，D3 是它的二级页（点任一条进）。
 * D2 是 D1 的空态 —— **空态是设计稿专门画的一屏**，不是"没数据就不显示"：
 * 一个空页面看起来像坏了，空态告诉用户"去哪能产生记录"。
 *
 * 记录本身由 `Records` 模块负责读写（见 src/records.js），
 * 这一层只负责画：不猜字段、不编文案 —— 没有的东西就不渲染那一行。
 */

var Pages = Pages || {};

/** 「脚本一 · 粉丝页提 ID」→「脚本一」。卡上只放得下短名，全名在详情页。 */
Pages.shortScriptName = function (name) {
    var text = String(name || "");
    var cut = text.indexOf(" \u00B7 ");
    return cut > 0 ? text.substring(0, cut) : text;
};

/** 记录条目 / 详情页统一用「任务 · 脚本」当标题。 */
Pages.recordTitle = function (record) {
    var task = record.taskName || Pages.taskName(record.taskKey);
    var script = Pages.shortScriptName(record.scriptName);
    return script === "" ? task : (task + " \u00B7 " + script);
};

/** 记录用的任务色/图标（与任务卡一致，列表里一眼能对上号）。 */
function recordVisual(record) {
    var task = Pages.taskOf(record.taskKey);
    return {
        colorHex: task ? task.colorHex : Theme.hex.accent,
        iconChar: task ? task.icon : "\u25A3"
    };
}

/* ------------------------------------------------------------ 日志行 */

/**
 * 日志行的配色（规格书：INFO 灰 / WARN 琥珀 / ERROR 玫瑰红）。
 * STEP 归到 INFO：它是流程节点，不是异常。
 */
function logColor(level) {
    if (level === "WARN") { return Theme.hex.warn; }
    if (level === "ERROR") { return Theme.hex.danger; }
    return Theme.hex.textFaint;
}

function pad2(n) { return n < 10 ? "0" + n : String(n); }

/** 时间戳 → HH:MM:SS（日志行前缀，等宽显示才对齐）。 */
function logClock(ms) {
    var d = new Date(ms || 0);
    return pad2(d.getHours()) + ":" + pad2(d.getMinutes()) + ":" + pad2(d.getSeconds());
}

/**
 * 一条日志行。
 *
 * 用**等宽字体**并且手动补空格对齐 level：设计稿里 `10:24:01  INFO   启动脚本`
 * 的 level 是定宽的，用比例字体会让每一行的正文起点参差不齐。
 */
function buildLogLine(entry) {
    var raw = String(entry.level || "INFO").toUpperCase();
    var level = raw;
    while (level.length < 5) { level += " "; }
    var text = logClock(entry.t) + "  " + level + "  " + String(entry.text || "");
    var view = U.monoText(text, Theme.m.logSize, logColor(raw));
    U.params(view, -1, -2, 0);
    return view;
}

/* ------------------------------------------------------------ D1 记录列表 */

function buildRecordRow(record, snap) {
    var visual = recordVisual(record);
    var result = Records.RESULT[record.result] || Records.RESULT.failed;
    var resumable = Resume.isRecordResumable(record, snap);

    return W.recordRow({
        title: Pages.recordTitle(record),
        iconChar: visual.iconChar,
        colorHex: visual.colorHex,
        resultLabel: result.label,
        resultTone: result.tone,
        timeLine: Records.timeLine(record),
        resultLine: Records.resultLine(record),
        /* 只有"这条记录就是那个没跑完的断点"时才给「继续」。
         * 判据在 Resume.isRecordResumable 里（含 runId 精确匹配）——
         * 否则一串历史「手动停止」记录上都会冒出「继续」，而只有最后一条能真续。 */
        actionLabel: resumable ? "\u7EE7\u7EED" : "",
        actionTone: "accent",
        onAction: function () { App.resumeRun(record); },
        onOpen: function () { App.openRecord(record.id); }
    });
}

/** D1：记录列表（有记录时）。 */
Pages.records = function () {
    var inner = U.column();
    var blocks = [];
    var list = Records.list();
    /* 断点只读一次：50 条记录各读一次盘是没必要的浪费 */
    var snap = Resume.snapshot();

    /* 标题区由路由层统一加（见 App.renderContent）——页面再加一次就会渲染两遍 */
    var section = U.column();
    section.addView(W.sectionTitle("\u8FD0\u884C\u8BB0\u5F55"));
    section.addView(U.spacer(4));
    /* 「共 N 条 · 点任一条查看执行日志」——条数是真实的，空列表走 D2 那一屏 */
    section.addView(U.text("\u5171 " + list.length + " \u6761 \u00B7 \u70B9\u4EFB\u4E00\u6761\u67E5\u770B\u6267\u884C\u65E5\u5FD7",
                           Theme.m.hintSize, Theme.hex.textDim, false));
    blocks.push(section);
    blocks.push(U.spacer(Theme.m.gapCard));

    for (var i = 0; i < list.length; i++) {
        blocks.push(buildRecordRow(list[i], snap));
        if (i < list.length - 1) { blocks.push(U.spacer(Theme.m.gapCard)); }
    }
    blocks.push(U.spacer(8));

    W.stack(inner, blocks, 0);

    var scroller = W.scroller();
    scroller.addView(inner);
    return scroller;
};

/** D2：记录空态。 */
Pages.recordsEmpty = function () {
    var inner = U.column();

    /* 标题区同样由路由层提供；空态只剩「区标题 + 空态块」 */
    inner.addView(W.sectionTitle("\u8FD0\u884C\u8BB0\u5F55"));
    inner.addView(W.emptyState("\u25F4",
        "\u8FD8\u6CA1\u6709\u8FD0\u884C\u8BB0\u5F55",
        "\u53BB\u300C\u4EFB\u52A1\u300D\u6807\u7B7E\u9009\u4E00\u4E2A\u811A\u672C\u8DD1\u8D77\u6765"));

    return inner;
};

/* ------------------------------------------------------------ D3 运行详情 */

/**
 * 结果摘要卡。
 * 三行都是**有条件渲染**的：结果文案/结果文件只有引擎回传了才有，
 * 没有就不画那一行 —— 空着的一行会让用户以为"数据丢了"。
 */
function buildSummaryCard(record) {
    var card = W.card(false);
    var rows = [];
    var result = Records.RESULT[record.result] || Records.RESULT.failed;

    var titleRow = U.row();
    var title = U.text(Pages.recordTitle(record), Theme.m.taskNameSize,
                       Theme.hex.textPrimary, true);
    title.setSingleLine(true);
    title.setEllipsize(android.text.TextUtils.TruncateAt.END);
    U.params(title, 0, -2, 1);
    titleRow.addView(title);
    titleRow.addView(U.hgap(8));
    titleRow.addView(W.badge(result.label, result.tone).root);
    rows.push(titleRow);

    rows.push(U.text(Records.timeLine(record), Theme.m.chipSize, Theme.hex.textFaint, false));

    if (record.resultText) {
        rows.push(U.text(record.resultText, Theme.m.chipSize, Theme.hex.textDim, false));
    }

    if (record.resultFile) {
        pushFileRows(rows, "\u7ED3\u679C\u6587\u4EF6", record.resultFile);
    }
    if (record.mapFile) {
        pushFileRows(rows, "uid \u6620\u5C04\uFF08username\u2192\u6570\u5B57 uid\uFF09", record.mapFile);
    }

    W.stack(card, rows, 10);
    return card;
}

/**
 * 一份产物文件：说明行 + 路径行（点路径打开）+ 打开/分享两个按钮。
 *
 * 抽成函数是因为现在有两份产物（结果文件 + uid 映射文件），
 * 各自都要能打开和分享 —— 光在界面上写一句「已生成 uid 映射」而取不到文件，
 * 等于让用户自己去翻 /sdcard。
 */
function pushFileRows(rows, caption, path) {
    rows.push(U.text(caption, Theme.m.chipSize, Theme.hex.textFaint, false));

    var fileRow = U.row();
    var pathText = U.text(path, Theme.m.chipSize, Theme.hex.accentText, false);
    pathText.setSingleLine(true);
    pathText.setEllipsize(android.text.TextUtils.TruncateAt.MIDDLE);
    U.params(pathText, 0, -2, 1);
    fileRow.addView(pathText);
    fileRow.addView(U.hgap(8));
    fileRow.addView(W.smallButton("\u6253\u5F00", "accent", function () {
        App.openResultFile(path);
    }).root);
    fileRow.addView(U.hgap(6));
    fileRow.addView(W.smallButton("\u5206\u4EAB", "default", function () {
        App.shareResultFile(path);
    }).root);
    rows.push(fileRow);
}

/** 日志卡：标题行（执行日志 + 复制）+ 日志行。 */
function buildLogCard(record) {
    var card = W.card(false);
    var logs = record.logs || [];

    var head = U.row();
    head.addView(U.text("\u6267\u884C\u65E5\u5FD7", Theme.m.labelSize, Theme.hex.textSecondary, true));
    head.addView(U.flexible());
    head.addView(W.smallButton("\u590D\u5236", "default", function () {
        App.copyLogs(record);
    }).root);
    card.addView(head);

    card.addView(U.spacer(10));

    if (logs.length === 0) {
        /* 如实说明，而不是画一张空卡片。日志来自引擎的 --log 通道（见 Engine.readLog），
         * 没接引擎的任务本来就不会有日志。 */
        card.addView(U.text("\u672C\u6B21\u8FD0\u884C\u6CA1\u6709\u56DE\u4F20\u65E5\u5FD7",
                            Theme.m.chipSize, Theme.hex.textDim, false));
        return card;
    }

    for (var i = 0; i < logs.length; i++) {
        if (i > 0) { card.addView(U.spacer(6)); }
        card.addView(buildLogLine(logs[i]));
    }
    return card;
}

/**
 * D3：运行详情。
 * 记录被清理掉（超过 Records.MAX 或被手工清空）时，**不能白屏** ——
 * 给一句"这条记录已不在本地"和一条回到列表的路。
 */
Pages.recordDetail = function (record) {
    var inner = U.column();

    inner.addView(W.backHeader("\u8FD0\u884C\u8BE6\u60C5", function () { App.closeRecord(); }));

    if (!record) {
        inner.addView(U.spacer(Theme.m.gapPage));
        inner.addView(W.emptyState("\u25F4",
            "\u8FD9\u6761\u8BB0\u5F55\u5DF2\u4E0D\u5728\u672C\u5730",
            "\u8BB0\u5F55\u4EC5\u4FDD\u7559\u6700\u8FD1 " + Records.MAX + " \u6761"));
        var scroller0 = W.scroller();
        scroller0.addView(inner);
        return scroller0;
    }

    inner.addView(U.spacer(Theme.m.gapCard));
    /* 这条记录还能接着跑 → 在看日志的地方也放一个入口（列表行那个是"一眼可见"，
     * 这个是"看完日志顺手继续"）。判据与列表行同一份。 */
    var snap = Resume.snapshot();
    if (Resume.isRecordResumable(record, snap)) {
        inner.addView(W.noticeBar({
            title: "\u8FD9\u6B21\u8FD0\u884C\u6CA1\u8DD1\u5B8C\uFF08\u5DF2\u6536 " + snap.extracted + " \u4E2A\uFF09",
            detail: Resume.detail(snap),
            tone: "accent",
            actions: [{
                label: "\u7EE7\u7EED",
                tone: "accent",
                onClick: function () { App.resumeRun(record); }
            }]
        }).root);
        inner.addView(U.spacer(Theme.m.gapCard));
    }
    inner.addView(buildSummaryCard(record));
    inner.addView(U.spacer(Theme.m.gapCard));
    inner.addView(buildLogCard(record));
    inner.addView(U.spacer(8));

    var scroller = W.scroller();
    scroller.addView(inner);
    return scroller;
};


/* ============================== src/page-login.js ============================== */
/* ============================== src/page-login.js ==============================
 * 卡密登录页（设计稿 16:257 登录 / 16:288 校验失败 / 16:1491 校验中）。
 *
 * 它不是某个页签，而是**未激活时的整个界面**：
 * 没有页签栏、没有开始运行按钮，唯一的出口是登录成功或退出应用。
 * 所以由 main.js 的 screen 路由决定显示它还是显示主界面。
 *
 * 三态共用一个构建函数，靠 Pages.LICENSE_VIEW.state 分叉：
 *   idle       输入框灰底、按钮「登录激活」、提示「卡密为一次性激活凭证…」
 *   verifying  按钮半透明 + 「登录中…」、提示换成「正在校验卡密，请稍候…」
 *   failed     输入框红边、下方红字「卡密无效或已过期，请检查后重试」
 * 三态的差异全部落在「样式」上，结构完全一致 —— 拆成三个函数会立刻产生三份漂移。
 *
 * 输入框与页面上的其它输入框是**同一个组件**（`W.inlineField`），
 *    并且**同样绑配置路径**（`license.draftCode`）：
 *    手打 16 位卡密时被系统回收进程，重开还能接着填。
 *    提交成功后草稿会被清掉，`license.code` 成为唯一副本。
 */

var Pages = Pages || {};

/** 登录页的界面状态。三态与失败文案只活在内存里：重启后回到 idle 是对的。 */
Pages.LICENSE_VIEW = {
    state: "idle",     /* idle | verifying | failed */
    message: ""
};

Pages.LICENSE_RESET = function () {
    Pages.LICENSE_VIEW.state = "idle";
    Pages.LICENSE_VIEW.message = "";
};

/* ------------------------------------------------------------ 子块 */

/** 品牌区：渐变 Logo + 应用名 + 副标题。 */
function buildBrandBlock() {
    var logoText = U.text("\u25B6", 26, "#FFFFFF", true);
    logoText.setGravity(android.view.Gravity.CENTER);
    var logo = new android.widget.FrameLayout(context);
    logo.setBackground(U.gradientBg(Theme.hex.accent, Theme.hex.accentDeep, Theme.m.loginLogoRadius));
    U.params(logo, Theme.m.loginLogoSize, Theme.m.loginLogoSize);
    logo.addView(logoText);

    var brand = U.column(false);
    brand.addView(logo);
    brand.addView(U.spacer(12));
    brand.addView(U.text("\u98DE\u821F\u811A\u672C", 28, Theme.hex.textPrimary, true));
    brand.addView(U.spacer(6));
    brand.addView(U.text("TikTok \u81EA\u52A8\u5316\u811A\u672C \u00B7 \u8BF7\u767B\u5F55\u540E\u4F7F\u7528",
                         12, Theme.hex.textMuted, false));
    return brand;
}

/**
 * 卡密输入框。失败态换成红边 + 红底，其余与常态一致。
 *
 * ★ 绑定 `license.draftCode`：**没提交的半截输入也要落盘**。
 *   之前的做法是「只在点登录时读一次、不进配置」，代价是手打 16 位卡密时
 *   被系统回收进程就得从头再打一遍。
 */
function buildLicenseInput(state) {
    var input = W.inlineField({
        path: "license.draftCode",
        placeholder: "\u8BF7\u8F93\u5165\u5361\u5BC6",
        fill: true
    });

    /* 卡密是分组的大写字母数字串，等宽字更容易逐位核对 */
    input.root.setTypeface(android.graphics.Typeface.MONOSPACE);
    input.root.setTextSize(14);

    if (state === "failed") {
        input.root.setBackground(U.strokeBg(0.06, 0.45, Theme.hex.danger, 10));
    } else {
        input.root.setBackground(U.strokeBg(0.05, 0.12, "#FFFFFF", 10));
    }
    return input;
}

/**
 * 登录 / 校验中 按钮。
 * 校验中时把渐变整体压到 45% 透明度，并在文字前加一个「◌」——
 * 不加这个视觉差，用户会以为可以连点。
 */
function buildSubmitButton(state) {
    var verifying = state === "verifying";
    var label = verifying ? "\u25CC \u767B\u5F55\u4E2D\u2026" : "\u767B\u5F55\u6FC0\u6D3B";

    var text = U.text(label, 16, "#FFFFFF", true);
    text.setGravity(android.view.Gravity.CENTER);

    var button = new android.widget.FrameLayout(context);
    /* 不用 W.primaryButton：它没有「禁用态」这个概念，而这里必须有 */
    var bg = U.gradientBg(Theme.hex.accent, Theme.hex.accentDeep, Theme.m.pillRadius);
    if (verifying) { bg.setAlpha(Math.round(255 * 0.45)); }
    button.setBackground(bg);
    U.params(button, -1, Theme.m.loginBtnHeight);
    button.addView(text);

    if (!verifying) {
        button.setOnClickListener(function () {
            App.submitLicense(inputCode());
        });
    }
    return { root: button, label: text };
}

/* 取输入框里的原始串。登录页只有一个输入框，用页面级引用比层层回传更省事。 */
var licenseInputRef = null;
function inputCode() {
    return licenseInputRef ? licenseInputRef.value() : "";
}

/* ------------------------------------------------------------ 页面 */

/**
 * 登录页主体。
 * 不接收 rerender —— 三态切换由 App 统一走 renderScreen()，
 * 页面自己重绘会绕开「切屏」这条唯一的路径。
 */
Pages.login = function () {
    var view = Pages.LICENSE_VIEW;
    var state = view.state;

    var inner = U.column();
    inner.setPadding(U.dp(20), U.dp(28), U.dp(20), U.dp(20));

    inner.addView(buildBrandBlock());
    inner.addView(U.spacer(28));

    /* —— 卡密输入卡 —— */
    var card = U.column();
    card.setBackground(U.strokeBg(0.04, 0.08, "#FFFFFF", Theme.m.cardRadius));
    card.setPadding(U.dp(16), U.dp(16), U.dp(16), U.dp(16));

    var input = buildLicenseInput(state);
    licenseInputRef = input;
    card.addView(input.root);
    card.addView(U.spacer(14));
    card.addView(buildSubmitButton(state).root);
    card.addView(U.spacer(14));

    /* 提示位在三态里说三件不同的事，共用同一行位置 */
    if (state === "failed") {
        var err = U.text(view.message || "\u5361\u5BC6\u65E0\u6548\u6216\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u68C0\u67E5\u540E\u91CD\u8BD5",
                         11, Theme.hex.danger, false);
        err.setGravity(android.view.Gravity.CENTER);
        card.addView(err);
    } else if (state === "verifying") {
        var waiting = U.text("\u6B63\u5728\u6821\u9A8C\u5361\u5BC6\uFF0C\u8BF7\u7A0D\u5019\u2026",
                             11, Theme.hex.accentText, false);
        waiting.setGravity(android.view.Gravity.CENTER);
        card.addView(waiting);
    } else {
        var safe = U.text("\u5361\u5BC6\u4E3A\u4E00\u6B21\u6027\u6FC0\u6D3B\u51ED\u8BC1\uFF0C\u8BF7\u52FF\u6CC4\u9732\u7ED9\u4ED6\u4EBA",
                          11, Theme.hex.textFaint, false);
        safe.setGravity(android.view.Gravity.CENTER);
        card.addView(safe);
    }

    card.addView(U.spacer(12));
    card.addView(W.link("\u8D2D\u4E70\u5361\u5BC6 \u00B7 \u8054\u7CFB\u5BA2\u670D",
                        Theme.hex.accentText, function () { App.showPurchaseInfo(); }));
    card.addView(U.spacer(4));
    card.addView(W.link("\u9000\u51FA\u5E94\u7528", Theme.hex.textMuted, function () { App.exit(); }));

    inner.addView(card);

    var scroller = W.scroller();
    scroller.addView(inner);
    return scroller;
};


/* ============================== src/page-mine.js ============================== */
/* ============================== src/page-mine.js ==============================
 * 我的页（设计稿 7:289）。
 *
 * 结构：卡密 → 应用 → 关于 三段。
 * 与其它页签的差别：本页没有「开始运行」按钮，底部只有页签栏。
 *
 * 数据来源都是真实的：
 *   · 卡密状态/到期时间  → Service.licenseStatus()
 *   · TikTok 安装与版本  → Device.tiktok()
 *   · 脚本版本          → Service.SCRIPT_VERSION（构建时注入）
 *   · 检查更新          → Service.checkUpdate()
 */

var Pages = Pages || {};

/** 卡密登录卡：已登录给脱敏卡密 + 解绑；未登录/已过期给「去登录」。 */
function buildLicenseCard(rerender) {
    var card = W.card(false);
    var rows = [];
    var display = Service.licenseDisplay();

    rows.push(W.settingRow("\u5361\u5BC6\u72B6\u6001",
        W.pill(display.text, display.tone).root, 6));

    rows.push(W.settingRow("\u5361\u5BC6\u5230\u671F\u65F6\u95F4",
        monoChip(display.expireAt, display.expireAt === "\u2014").root, 6));

    if (display.status === "active") {
        /* 已登录：脱敏展示，只露前 4 后 4 —— 卡片码不该完整出现在截图里 */
        var masked = Service.formatCode(Service.normalizeCode(Service.licenseStatus().code));
        if (masked.length > 9) {
            masked = masked.substring(0, 4) + "-****-****-" + masked.substring(masked.length - 4);
        }

        var codeView = U.text(masked, Theme.m.chipSize, Theme.hex.textSecondary, false);
        codeView.setSingleLine(true);
        codeView.setBackground(U.strokeBg(Theme.alpha.chipFill, Theme.alpha.chipStroke, "#FFFFFF", Theme.m.chipRadius));
        codeView.setPadding(U.dp(6), U.dp(6), U.dp(6), U.dp(6));

        /* 「解绑」而不是「退出登录」：这个动作的后果比退出更重
         * （正在跑的脚本会被停掉），文案要与弹窗里的说法一致。 */
        var unbind = W.chip("\u89E3\u7ED1", "danger");
        unbind.root.setOnClickListener(function () {
            Dialog.confirmUnbind(function () {
                /* 顺序有意义：先停运行，再清卡密，最后切回登录页。
                 * 反过来的话，停运行那一刻界面已经不在主界面上了。 */
                App.stopRun();
                Service.logout();
                toast("\u5DF2\u89E3\u7ED1\u5361\u5BC6");
                App.showLogin();
            });
        });

        var row = U.row();
        row.addView(codeView);
        row.addView(U.flexible());
        row.addView(U.hgap(6));
        row.addView(unbind.root);
        rows.push(row);
    } else {
        /* 未登录 / 已过期：主界面里没有可做的事，引导回登录页 */
        var go = W.chip("\u53BB\u767B\u5F55", "accent");
        go.root.setOnClickListener(function () { App.showLogin(); });
        rows.push(W.settingRow("\u5361\u5BC6", go.root, 6));
    }

    W.stack(card, rows, 12);
    return card;
}

/** 等宽小胶囊，用于日期 / 版本号这类需要对齐阅读的值。 */
function monoChip(value, muted) {
    var view = U.monoText(value, Theme.m.chipSize,
                          muted ? Theme.hex.textFaint : Theme.hex.textSecondary);
    view.setSingleLine(true);
    view.setBackground(U.strokeBg(Theme.alpha.chipFill, Theme.alpha.chipStroke, "#FFFFFF", Theme.m.chipRadius));
    view.setPadding(U.dp(6), U.dp(6), U.dp(6), U.dp(6));
    return { root: view, setText: function (v) { view.setText(String(v)); } };
}

/**
 * 悬浮球开关卡（规格书 §10 的补充项）。
 *
 * 规格书 §10.3 里有「隐藏悬浮球」，但**没写隐藏之后怎么再显示** ——
 * 没有恢复入口的话，用户点一次隐藏就再也找不回这个跨 App 唯一的控制入口了。
 * 所以这里补一个开关，并且它是**双向**的：
 *   · 关掉 → 立刻关球 + 落盘 `ball.hidden`（下次启动也不会再冒出来）；
 *   · 打开 → 立刻 `FB.ensure()`（当场就能看到球出现在屏幕上）。
 *
 * 权限没给时会如实说明球建不出来 —— 规格书 §10.9① 写着悬浮窗权限
 * "唯一实际用途"就是这个球，所以这里必须讲清楚，而不是让用户对着开关纳闷。
 */
function buildFloatBallCard() {
    var card = W.card(false);
    var rows = [];

    var allowed = Device.overlayEnabled();
    var shown = !Store.getBool("ball.hidden") && allowed;

    var toggle = W.toggle(shown, function (on) {
        if (on && !Device.overlayEnabled()) {
            /* 没权限就别落一个"开了但看不见"的状态：直接引导去授权 */
            toast("\u8BF7\u5148\u5F00\u542F\u60AC\u6D6E\u7A97\u6743\u9650");
            Device.openPermissionSettings("overlay");
            return;
        }
        FB.setHidden(!on);
        toast(on ? "\u5DF2\u663E\u793A\u60AC\u6D6E\u7403" : "\u5DF2\u9690\u85CF\u60AC\u6D6E\u7403");
    });
    rows.push(W.settingRow("\u60AC\u6D6E\u7403", toggle.root, 6));

    /* 权限缺失时补一行说明（否则用户会以为开关坏了） */
    if (!allowed) {
        rows.push(W.hint("\u9700\u5F00\u542F\u300C\u60AC\u6D6E\u7A97\u6743\u9650\u300D\u624D\u80FD\u663E\u793A\u60AC\u6D6E\u7403", false));
    } else {
        /* 球的位置是用户拖出来的，写清"可拖动"能省掉一轮困惑 */
        rows.push(W.hint("\u53EF\u62D6\u52A8\u5230\u4EFB\u610F\u8FB9\u7F18\uFF0C\u677E\u624B\u81EA\u52A8\u5438\u9644\u5E76\u8BB0\u4F4F\u4F4D\u7F6E", false));
    }

    W.stack(card, rows, 10);
    return card;
}

/** 应用下载卡：按 TikTok 的真实安装状态显示「未安装/下载」或「已安装版本/更新」。 */
function buildAppCard() {
    var card = W.card(false);
    var info = Device.tiktok();

    var label = U.text("TikTok \u5BA2\u6237\u7AEF", Theme.m.labelSize, Theme.hex.textSecondary, false);

    var statusView = info.installed
        ? W.pill("\u5DF2\u5B89\u88C5 " + Device.formatVersion(info.versionName), "ok")
        : W.pill("\u672A\u5B89\u88C5", "mute");

    var action = W.chip(info.installed ? "\u66F4\u65B0" : "\u4E0B\u8F7D", "accent");
    action.root.setOnClickListener(function () {
        installFromLocalApk(info);
    });

    /* 左侧标签用内容宽度，中间用 flexible() 顶开，右侧控件自然靠边 */
    var row = U.row();
    row.addView(label);
    row.addView(U.flexible());
    row.addView(statusView.root);
    row.addView(U.hgap(6));
    row.addView(action.root);

    card.addView(row);
    return card;
}

/**
 * 从本机 APK 安装/更新 TikTok。
 *
 * 为什么不做成「点一下自动下载」：没有可依赖的官方下载源，
 * 硬塞一个第三方地址既不安全也会失效。改成扫描本机已有的 APK，
 * 让用户自己放包——这是能真正跑通的路径。
 */
function installFromLocalApk(info) {
    var dirs = ["/sdcard/Download", "/sdcard/Download/apk", "/sdcard/apk"];
    var found = [];

    for (var i = 0; i < dirs.length; i++) {
        var names = [];
        try {
            names = files.listDir(dirs[i]);
        } catch (e) {
            names = [];
        }
        for (var j = 0; j < names.length; j++) {
            if (/\.apk$/i.test(names[j])) { found.push(dirs[i] + "/" + names[j]); }
        }
    }

    if (found.length === 0) {
        Dialog.alert("未找到安装包",
            "把 TikTok 的 APK 放到 /sdcard/Download 下即可在这里安装。\n\n" +
            (info.installed ? "当前已安装：" + Device.formatVersion(info.versionName) : "当前未安装。"));
        return;
    }

    Dialog.choose({
        title: info.installed ? "选择更新包" : "选择安装包",
        options: found,
        currentIndex: 0,
        onConfirm: function (index) {
            launchInstaller(found[index]);
        }
    });
}

/** 把选中的 APK 交给系统安装器。 */
function launchInstaller(apkPath) {
    var ok = false;
    try {
        /* app.viewFile 交给系统安装器处理；不用 FileUriExposed 的裸 file:// Intent，
         * 那在 Android 7+ 会直接抛异常。 */
        app.viewFile(apkPath);
        ok = true;
    } catch (e) {
        console.log("[mine] 调起安装器失败: " + e);
    }
    toast(ok ? "已交给系统安装器" : "无法调起安装器，请手动点击该 APK");
}

/** 版本信息卡：脚本版本 / 更新日志 / 检查更新。 */
function buildVersionCard() {
    var card = W.card(false);
    var rows = [];

    rows.push(W.settingRow("\u811A\u672C\u7248\u672C",
        monoChip(Service.SCRIPT_VERSION, false).root, 6));

    var changelog = W.chip("\u67E5\u770B", "accent");
    changelog.root.setOnClickListener(function () {
        Dialog.alert("更新日志", Service.CHANGELOG.join("\n"));
    });
    rows.push(W.settingRow("\u66F4\u65B0\u65E5\u5FD7", changelog.root, 6));

    var statusPill = W.pill("\u68C0\u67E5\u4E2D\u2026", "mute");
    rows.push(W.settingRow("\u68C0\u67E5\u66F4\u65B0", statusPill.root, 6));

    function refresh() {
        statusPill.setText("\u68C0\u67E5\u4E2D\u2026");
        checkUpdateAsync(function (result) {
            statusPill.setText(updateText(result));
        });
    }
    statusPill.root.setOnClickListener(refresh);

    /* 进页面自动查一次：设计稿这里直接显示结论（「已是最新」），
     * 停在「检查中…」会让用户以为卡住了。走独立线程，不阻塞界面。 */
    refresh();

    W.stack(card, rows, 12);
    return card;
}

/** 检查更新的结论文案。集中一处，避免「自动查」和「手动查」两条路径说法不一致。 */
function updateText(result) {
    if (result.hasUpdate) { return "\u53D1\u73B0 " + result.latest; }
    if (result.source === "unknown") { return "\u68C0\u67E5\u5931\u8D25"; }
    return "\u5DF2\u662F\u6700\u65B0";
}

/**
 * 检查更新。
 *
 * ⚠️ 默认路径**必须同步返回**，不能无脑起线程：
 *    真机实测，`threads.start` + `ui.run` 这条链路里改 View 会直接崩，
 *    报 `Cannot find function setAndNotify in object P7.b@...`（TextView 的内部通知）。
 *    而 updateEndpoint 为空时 checkUpdate() 是纯本地计算、不发网络请求，
 *    本来就没什么可异步的——起线程只是白白引入跨线程改 UI 的风险。
 *    只有真配了远端端点、会发 HTTP 时，才走线程。
 */
function checkUpdateAsync(callback) {
    if (!Service.CONFIG.updateEndpoint) {
        callback(Service.checkUpdate());
        return;
    }
    threads.start(function () {
        var result = Service.checkUpdate();
        ui.run(function () { callback(result); });
    });
}

/**
 * 我的页。
 * 与其它四页不同，本页**不需要 rerender** —— 页内唯一的动态刷新是
 * 「检查更新」的状态标签，它是就地改文字（改完不重建，滚动位置才不会丢）。
 */
Pages.mine = function () {
    var inner = U.column();
    var blocks = [];

    blocks.push(W.sectionTitle("\u5361\u5BC6"));
    blocks.push(buildLicenseCard());

    blocks.push(U.spacer(4));
    blocks.push(W.sectionTitle("\u5E94\u7528"));
    blocks.push(buildAppCard());

    /* 悬浮球单独一张卡：它是"跨 App 控制入口"的开关，
     * 混进 TikTok 客户端那张卡里会被当成"TikTok 的设置"（规格书 §10 补的恢复入口） */
    blocks.push(U.spacer(4));
    blocks.push(W.sectionTitle("\u60AC\u6D6E\u7403"));
    blocks.push(buildFloatBallCard());

    blocks.push(U.spacer(4));
    blocks.push(W.sectionTitle("\u5173\u4E8E"));
    blocks.push(buildVersionCard());

    /* 设备信息放在最后一行，排障时一眼能看到当前跑在什么机器上 */
    blocks.push(W.hint(Device.deviceLabel() + " \u00B7 " + Device.appVersionName(), false));

    /* —— 退出应用 ——
     * ★ 为什么要有这个入口：以前主界面里**没有**退出，用户想关掉只能按返回或 HOME。
     *   而按 HOME 是"退到后台"，不是关闭 —— 悬浮球会继续浮在桌面和别的 App 上面
     *   （它本来就是为了在 TikTok 里操作才存在的）。用户看到球还在，就会认为"关不掉"。
     *   给一个明确的出口：停脚本 → 关球 → 退到桌面，三件事一次做完。
     *   靠 `events.on("exit")` 和 Activity 轮询也能清，但那些是兜底，不该是用户唯一的办法。 */
    blocks.push(U.spacer(8));
    var exitLink = W.link("\u9000\u51FA\u5E94\u7528\uFF08\u505C\u811A\u672C \u00B7 \u5173\u60AC\u6D6E\u7403\uFF09",
        Theme.hex.textMuted, function () {
            Dialog.exitApp(function () {
                FB.destroy();
                App.exit();
            });
        });
    blocks.push(exitLink);

    W.stack(inner, blocks, Theme.m.gapCard);

    var scroller = W.scroller();
    scroller.addView(inner);
    return scroller;
};


/* ============================== src/main.js ============================== */
/* ============================== src/main.js ==============================
 * 入口：搭骨架、路由（tab + 二级页）、运行态、启动流程。
 *
 * 骨架只搭一次（根 FrameLayout + 光晕 + 浮层宿主），之后所有刷新都只重建 body：
 *   · 主界面：全局运行条 / 页面内容 / 开始运行按钮 / 页签栏 四个宿主容器；
 *   · 登录页：整块 body 就是登录内容，没有页签也没有按钮。
 * 不整体重建根布局——那会让光晕图层反复重建，肉眼可见地闪。
 *
 * ## 路由只有两层（2026-10-13 改版）
 *   一级：三个 tab —— 任务 / 记录 / 我的（设计稿底栏只有三个图标）
 *   二级：任务详情（id/dm/nurture/video 四个任务，各自一页）/ 运行详情（某条记录）
 * 二级页保留底栏与「开始运行」CTA；运行详情没有 CTA（它只是看，不驱动）。
 *
 * ⚠️ 本脚本必须以 "ui"; 指令开头（build.js 负责写在第一行）。
 */

var App = {};

App.ROOT_TAG = "feizhou-root";
App.RUN_CONFIG_PATH = "/sdcard/tiktok_app/run-config.json";

/** 当前显示的是哪一屏：主界面还是卡密登录页。 */
App.screen = "app";

/**
 * 一级页：tab → 页面构建函数。顺序与 W.TABS 一致。
 *
 * 记录页在这里做「有记录 / 空态」的分流：两者是同一页的两种状态
 * （设计稿 D1/D2），分流点放在路由层而不是页面内部 ——
 * 页面函数只管画自己那一种，不必先判断"我有数据吗"。
 */
App.TAB_PAGES = {
    tasks:   function () { return Pages.tasks(); },
    records: function () { return Records.list().length > 0 ? Pages.records() : Pages.recordsEmpty(); },
    /* 我的页不需要 rerender：页内唯一会变的是「检查更新」的状态标签，
     * 它是就地改文字，不重建 —— 重建会把滚动位置清零。 */
    mine:    function () { return Pages.mine(); }
};

/** 一级页的标题区文案（设计稿：副标题各不相同）。 */
App.TAB_HEADERS = {
    tasks:   ["\u98DE\u821F\u811A\u672C", "TikTok \u81EA\u52A8\u5316\u811A\u672C \u00B7 \u9009\u62E9\u4EFB\u52A1"],
    records: ["\u98DE\u821F\u811A\u672C", "TikTok \u81EA\u52A8\u5316\u811A\u672C \u00B7 \u8FD0\u884C\u8BB0\u5F55"],
    mine:    ["\u98DE\u821F\u811A\u672C", "TikTok \u81EA\u52A8\u5316\u811A\u672C \u00B7 \u6211\u7684"]
};

/** 二级页：任务详情。每个任务一页，都是可滚动的长页。 */
App.DETAIL_PAGES = {
    id:      function (rerender) { return Pages.id(rerender); },
    dm:      function (rerender) { return Pages.dm(rerender); },
    nurture: function (rerender) { return Pages.nurture(rerender); },
    video:   function (rerender) { return Pages.video(rerender); }
};

App.body = null;
App.overlayHost = null;
App.runBar = null;

/**
 * 上一次运行的终态（内存，不落盘）。
 * 布局与状态条同位：未运行时它就是那一条"上次运行：…"。
 * 不落盘的理由与运行态相同 —— 冷启动后该是干净的。
 */
App.lastRunResult = null;

/**
 * 报错态运行条（设计稿 F5 的 30:1119：整条变玫瑰红 + 文案「执行出错已停止」）。
 *
 * 只在「失败结束、且用户还没关掉 F5」这一刻存在。
 * 关掉之后就整条隐藏 —— 与规格书 §2.4 的「空闲/完成时整条隐藏」一致，
 * 但报错那一刻必须留着：它是"这次跑挂了"最直观的证据。
 */
App.failBar = null;

/**
 * 二级页的运行详情（记录 id）。**只存内存、不落盘**：
 * 冷启动后回到"某一条历史记录"没有意义，而记录本身可能已被清理。
 */
App.recordId = "";

/**
 * 引擎"没写终态就没了"的判定宽限期。
 * 引擎刚起来时还没出现在引擎列表里，头几秒不判定，免得刚启动就被判成已退出。
 */
App.CHILD_GRACE_MS = 4000;

/**
 * 发出停止请求后等引擎确认的上限。
 * 超时就当它已经停了：用户按了停止，界面不能一直卡在"正在收尾"上。
 */
App.STOP_TIMEOUT_MS = 8000;

/**
 * 本次运行的 runId，在唤起引擎之前就定下来。
 *
 * 单独存一份是因为它要在两处用到 —— 写进 run-config（追溯）与传给引擎（比对），
 * 而 `Session.start` 只在引擎**已经起来之后**才会被调用，顺序上不能倒过来。
 */
App.pendingRunId = "";

/** 本次运行是否已提示过「引擎需要 TikTok 保持前台」。来回切窗口时只提醒一次。 */
App.backgroundWarned = false;

/* ------------------------------------------------------------ 光晕背景 */

/**
 * 复刻设计稿背景的两团径向光晕。
 * 用绝对定位的圆形 View 叠在根 FrameLayout 上，位置取自设计稿坐标。
 */
function buildGlowLayer() {
    var layer = new android.widget.FrameLayout(context);
    layer.setLayoutParams(new android.widget.FrameLayout.LayoutParams(-1, -1));

    var specs = [
        { hex: Theme.hex.accent, alpha: Theme.alpha.glowA, size: 440, x: -40, y: -70 },
        { hex: Theme.hex.accentDeep, alpha: Theme.alpha.glowB, size: 420, x: 40, y: 120 }
    ];

    for (var i = 0; i < specs.length; i++) {
        var spec = specs[i];
        var glow = new android.view.View(context);
        glow.setBackground(U.glowBg(spec.hex, spec.alpha));
        var lp = new android.widget.FrameLayout.LayoutParams(U.dp(spec.size), U.dp(spec.size));
        lp.leftMargin = U.dp(spec.x);
        lp.topMargin = U.dp(spec.y);
        layer.addView(glow, lp);
    }

    /* 光晕只是氛围，不能吃掉点击事件 */
    layer.setClickable(false);
    layer.setFocusable(false);
    return layer;
}

/* ------------------------------------------------------------ 页面骨架 */

/**
 * 定高占位块。注意入参是**像素**而不是 dp ——
 * 状态栏与导航栏高度从系统取回来就已经是 px，再 dp() 一次会放大两倍多。
 */
function pxPlaceholder(heightPx) {
    var view = new android.view.View(context);
    view.setLayoutParams(new android.widget.LinearLayout.LayoutParams(-1, Math.round(heightPx)));
    return view;
}

/** 竖向铺开并撑满剩余高度，供内容区使用。 */
function fillColumn() {
    var column = U.column();
    var lp = new android.widget.LinearLayout.LayoutParams(-1, 0);
    lp.weight = 1;
    column.setLayoutParams(lp);
    return column;
}

App.build = function () {
    var root = new android.widget.FrameLayout(context);
    root.setBackground(U.screenBackground());
    root.addView(buildGlowLayer());

    App.body = U.column();
    App.body.setLayoutParams(new android.widget.FrameLayout.LayoutParams(-1, -1));
    root.addView(App.body);

    App.overlayHost = new android.widget.FrameLayout(context);
    root.addView(App.overlayHost);

    return root;
};

/* ------------------------------------------------------------ 主界面 */

/**
 * 上一次运行的结论行。点一下消失 —— 确认过了就不必一直占着位置。
 */
function buildLastResultRow() {
    var row = U.row();
    row.setPadding(U.dp(Theme.m.contentPadding), U.dp(10),
                   U.dp(Theme.m.contentPadding), 0);

    var text = U.text("\u4E0A\u6B21\u8FD0\u884C\uFF1A" + (App.lastRunResult.message || ""),
                      11, Theme.hex.textFaint, false);
    text.setSingleLine(true);
    text.setEllipsize(android.text.TextUtils.TruncateAt.END);

    row.addView(text);
    row.addView(U.flexible());
    row.setOnClickListener(function () {
        App.lastRunResult = null;
        App.renderScreen();
    });
    return row;
}

/**
 * 把正在被驱动的目标应用切回前台。
 *
 * 引擎靠"看到 TikTok 在前台"来定位页面，所以**它在跑的时候 TikTok 必须留在前台**。
 * 用户切回界面看进度这件事本身很自然，但它会让引擎瞬间"瞎掉"。
 * 与其在文档里写"运行中请勿切走"（没人会记得），不如给一个一键切回去的入口。
 */
App.backToTarget = function () {
    var info = Device.tiktok();
    if (!info.installed) {
        toast("\u672A\u68C0\u6D4B\u5230 TikTok \u5BA2\u6237\u7AEF");
        return false;
    }
    try {
        app.launchPackage(info.packageName);
        return true;
    } catch (e) {
        console.log("[app] 切回目标应用失败: " + e);
        toast("\u5207\u56DE TikTok \u5931\u8D25");
        return false;
    }
};

/**
 * 界面回到前台时的提醒。
 *
 * 只在**引擎正在跑**且**本次运行还没提醒过**时说一次：
 * 用户来回切窗口时反复弹同一个提示是纯打扰。
 *
 * ⚠️ 2026-10-13 文案改了：运行条现在点一下是**跳回运行中的任务详情页**
 * （规格书 §2.4「运行条 = 状态与导航」），不再是「切回 TikTok」。
 * 旧的提示语会让用户点着运行条去找 TikTok，越点越糊涂。
 */
App.noticeIfRunningInBackground = function () {
    if (!Session.running || App.backgroundWarned) { return; }
    App.backgroundWarned = true;
    toast("\u8FD0\u884C\u4E2D\uFF1A\u5F15\u64CE\u9700\u8981 TikTok \u4FDD\u6301\u5728\u524D\u53F0\uFF0C"
        + "\u5207\u5230\u672C\u754C\u9762\u4F1A\u8BA9\u5B83\u8BA4\u4E0D\u51FA\u9875\u9762");
};

/**
 * 主界面：全局运行条 → 页面内容 → 开始运行 → 页签栏。
 *
 * 运行条放在内容区**上面**（设计稿 §2.4：x=20, y=70, w=335, h=44，状态栏之下）：
 * 它要在任何时候都可见 —— 包括用户切到别的 tab 去看记录的时候，
 * 这正是"全局单跑"的可见性来源。
 */
App.renderAppScreen = function (body) {
    body.addView(pxPlaceholder(Device.statusBarHeight()));

    /* 运行条：两种来源，同一个位置。
     *   ① 正在跑 → 绿点 + 任务名/脚本 + 计时（点击跳回运行中那个任务的详情页）；
     *   ② 刚跑挂且用户还没关掉 F5 → 整条玫瑰红 +「执行出错已停止」+「已终止」。
     * 空闲/正常完成时整条不存在，连那 10dp 间距也一并省掉 ——
     * 一个空容器带着 padding 仍然会占位，是很容易忽略的一处空隙。 */
    App.runBar = null;
    var barText = "";
    var barTime = "";
    var barTone = "ok";

    if (Session.running) {
        barText = Session.barText();
        barTime = Session.formatElapsed(Session.elapsedMs());
        barTone = Session.stopping ? "warn" : "ok";
    } else if (App.failBar) {
        barText = App.failBar.text;
        barTime = App.failBar.time;
        barTone = "danger";
    }

    if (barText !== "") {
        var statusHost = U.column();
        statusHost.setPadding(U.dp(Theme.m.contentPadding), U.dp(10),
                              U.dp(Theme.m.contentPadding), 0);
        App.runBar = W.runBar(barText, barTime, barTone);
        /* ★ 状态条整条可点击 = 「跳回运行中的任务」。
         *   引擎是靠"看到 TikTok 在前台"来定位页面的；用户切到记录 tab 看一眼，
         *   前台就变了。与其在文档里写"运行中请勿切走"，不如给一个一键跳回去的入口。 */
        App.runBar.root.setOnClickListener(function () { App.backToRunning(); });
        statusHost.addView(App.runBar.root);
        body.addView(statusHost);
    } else if (App.lastRunResult) {
        /* 未运行但上一轮刚结束：留一行结果。
         * 人守在手机前看的是 TikTok 自动操作，跑完那一刻他多半没看着界面 ——
         * 切回来能立刻知道"上一轮跑成什么样了"，而不是面对一个干净的界面猜。 */
        body.addView(buildLastResultRow());
    }

    /* 内容区外面套一层 FrameLayout：底部渐隐要**叠**在内容上（设计稿 §6：
     * y=577 h=80），直接加进竖向 body 会变成另起一行、占掉 80dp 高度。 */
    var contentWrap = new android.widget.FrameLayout(context);
    var wrapParams = new android.widget.LinearLayout.LayoutParams(-1, 0);
    wrapParams.weight = 1;
    contentWrap.setLayoutParams(wrapParams);

    var contentHost = U.column();
    contentHost.setLayoutParams(new android.widget.FrameLayout.LayoutParams(-1, -1));
    contentHost.setPadding(U.dp(Theme.m.contentPadding), U.dp(Theme.m.contentPadding),
                           U.dp(Theme.m.contentPadding), 0);
    contentWrap.addView(contentHost);
    contentWrap.addView(W.bottomFade());
    body.addView(contentWrap);

    var runHost = new android.widget.FrameLayout(context);
    body.addView(runHost);

    var tabHost = new android.widget.FrameLayout(context);
    body.addView(tabHost);
    /* 底部导航背景横跨整宽，所以背景挂在 tabHost 上而不是 body */
    tabHost.setBackground(U.solidBg(U.alphaOf(Theme.hex.tabBar, 0.96)));

    App.contentHost = contentHost;
    App.runHost = runHost;
    App.tabHost = tabHost;

    App.renderContent();
    App.renderRunArea();
    App.renderTabs();
};

/**
 * 重建页面内容区。
 *
 * 三条分支对应三层东西：
 *   ① 运行详情（App.recordId）—— 它自带返回头，不再加标题区；
 *   ② 任务详情（App.detail）—— 返回头 + 该任务的长页；
 *   ③ 一级 tab —— 标题区 + 该 tab 的页面。
 *
 * ★ 重建前先 `commitPendingInputs()`：输入框现在是可以**直接编辑**的常驻控件，
 *   用户完全可能还停在某一格里就点了别处（切 tab、勾复选框触发重建）。
 *   不先提交就重建，那一格的编辑会随视图一起消失 —— 而这正是
 *   「界面显示的值」和「真正跑起来的值」不一致的来源。
 */
App.renderContent = function () {
    W.commitPendingInputs();
    W.beginPage();

    var rerender = function () { ui.run(function () { App.renderContent(); }); };
    /* 页面内部（例如「使用文本 ID」勾选后右端多出按钮）需要整页重建时用它 */
    Pages.requestRerender = rerender;

    var host = App.contentHost;
    host.removeAllViews();

    /* —— ② 运行详情 —— */
    if (App.recordId) {
        var detailPage = Pages.recordDetail(Records.find(App.recordId));
        U.params(detailPage, -1, 0, 1);
        host.addView(detailPage);
        return;
    }

    /* —— ② 任务详情 —— */
    if (App.detail) {
        host.addView(W.backHeader(Pages.DETAIL_TITLES[App.detail] || "",
                                  function () { App.closeDetail(); },
                                  function () { Device.openPermissionSettings("a11y"); }));
        host.addView(U.spacer(Theme.m.gapTight));

        var builder = App.DETAIL_PAGES[App.detail];
        if (!builder) {
            /* 不认识的详情 key（配置被手改过）→ 直接回任务列表，
             * 而不是渲染一个空白页让用户以为界面坏了。 */
            App.detail = "";
            Store.set("activeDetail", "");
            App.renderContent();
            return;
        }
        var page = builder(rerender);
        var pageParams = new android.widget.LinearLayout.LayoutParams(-1, 0);
        pageParams.weight = 1;
        page.setLayoutParams(pageParams);
        host.addView(page);
        return;
    }

    /* —— ③ 一级 tab —— */
    var header = App.TAB_HEADERS[App.activeTab] || App.TAB_HEADERS.tasks;
    host.addView(W.pageHeader(header[0], header[1], function () {
        Device.openPermissionSettings("a11y");
    }));
    host.addView(U.spacer(Theme.m.gapPage));

    var tabBuilder = App.TAB_PAGES[App.activeTab] || App.TAB_PAGES.tasks;
    var tabPage = tabBuilder();
    var tabParams = new android.widget.LinearLayout.LayoutParams(-1, 0);
    tabParams.weight = 1;
    tabPage.setLayoutParams(tabParams);
    host.addView(tabPage);
};

/**
 * 重建「开始运行 / 停止运行」按钮区。
 *
 * 只有**任务详情页**有这一块（设计稿：B1/B2/D1/D2/D3/E1 都没有）。
 * 分工是刻意的：任务卡上的「运行」按钮负责"直接从列表起跑"，
 * 底部 CTA 负责"在详情页调好参数后起跑/停止"。 */
App.renderRunArea = function () {
    var host = App.runHost;
    host.removeAllViews();

    if (App.recordId || !App.detail) { return; }

    var wrapper = U.column();
    wrapper.setPadding(U.dp(Theme.m.contentPadding), U.dp(12), U.dp(Theme.m.contentPadding), U.dp(12));

    var button = W.runButton(function () { App.toggleRun(); },
                             Session.running ? "\u505C\u6B62\u8FD0\u884C" : "\u5F00\u59CB\u8FD0\u884C");
    wrapper.addView(button.root);

    host.addView(wrapper);
};

/** 重建页签栏（含底部安全区）。 */
App.renderTabs = function () {
    var host = App.tabHost;
    host.removeAllViews();

    var column = U.column();
    column.addView(W.tabBar(App.activeTab, function (key) {
        if (key === App.activeTab) { return; }
        App.switchTab(key);
    }));

    /* 全面屏手势机型 navBarHeight() 返回 0，此时给 24dp 余量，
     * 否则页签文字会贴到手势条上。 */
    var safe = Device.navBarHeight();
    column.addView(pxPlaceholder(safe > 0 ? safe : U.dp(24)));

    host.addView(column);
};

/** 全屏重建。切屏与运行态变化都走它，不在别处零散重建。 */
App.renderScreen = function () {
    var body = App.body;
    body.removeAllViews();
    if (App.screen === "login") {
        body.addView(pxPlaceholder(Device.statusBarHeight()));
        var login = Pages.login();
        var lp = new android.widget.LinearLayout.LayoutParams(-1, 0);
        lp.weight = 1;
        login.setLayoutParams(lp);
        body.addView(login);
        return;
    }
    App.renderAppScreen(body);
};

App.switchTab = function (key) {
    /* 切 tab = 退出二级页：底栏是"这一层"的导航，
     * 按了它还停在详情页里会让人以为导航坏了。 */
    App.detail = "";
    App.recordId = "";
    Store.set("activeDetail", "");
    App.activeTab = key;
    Store.set("activeTab", key);
    App.renderScreen();
    console.log("[app] 切换到 tab " + key);
};

/* ------------------------------------------------------------ 二级页导航 */

/** 进某个任务的详情页（C1/C6/C8/C9）。 */
App.openDetail = function (taskKey) {
    if (!App.DETAIL_PAGES[taskKey]) { return; }
    App.recordId = "";
    App.detail = taskKey;
    if (App.activeTab !== "tasks") {
        App.activeTab = "tasks";
        Store.set("activeTab", "tasks");
    }
    Store.set("activeDetail", taskKey);
    App.renderScreen();
    console.log("[app] 打开任务详情 " + taskKey);
};

App.closeDetail = function () {
    App.detail = "";
    Store.set("activeDetail", "");
    App.renderScreen();
};

/** 进某条运行记录的详情（D3）。 */
App.openRecord = function (recordId) {
    if (!recordId) { return; }
    App.recordId = recordId;
    App.detail = "";
    if (App.activeTab !== "records") {
        App.activeTab = "records";
        Store.set("activeTab", "records");
    }
    Store.set("activeDetail", "");
    App.renderScreen();
};

App.closeRecord = function () {
    App.recordId = "";
    App.renderScreen();
};

/**
 * 点运行条 → 跳回**正在运行的那个任务**的详情页。
 *
 * 为什么是"跳回任务页"而不是"切回 TikTok"：运行条是全局的，
 * 用户在记录 tab 上看到它、点一下，最想问的是"谁在跑 / 跑成什么样了"。
 * 至于把 TikTok 拉回前台 —— 那是**引擎自己的事**（它必须待在前台），
 * 界面这一下只解决"我在哪"。
 */
App.backToRunning = function () {
    if (Session.running && Session.tab) {
        App.openDetail(Session.tab);
        return;
    }
    /* 报错态的那一下：直接去看日志（F5 的「查看日志」走的是同一个入口） */
    var failedId = App.failBar ? App.failBar.recordId : "";
    App.failBar = null;
    if (failedId) {
        App.openRecord(failedId);
        return;
    }
    App.renderScreen();
};

/* ------------------------------------------------------------ 运行态 */

/**
 * 每秒刷新计时，并顺带做两件巡检。
 *
 * 只改状态条上的那两个 TextView，不重建界面 ——
 * 每秒重建整页会让滚动位置归零，用户根本没法边跑边看配置。
 *
 * 两件巡检：
 *   ① 卡密到期（设计稿 F4）：到期那一刻停掉运行并弹窗，而不是等用户下一次操作才发现。
 *   ② **引擎状态**：这是"界面上的运行态"与"真正在跑的东西"唯一的一致性来源。
 * 两者都放在这里而不是另起定时器，因为「运行中」本来就是它们唯一需要的触发条件。
 */
App.tickTimer = function () {
    if (!Session.running) { return; }

    if (Service.licenseStatus().status !== "active") {
        /* 先让引擎停手（否则它会继续操作 TikTok），然后**立刻复位界面**：
         * 这一刻要传递的信息是"你已经不能跑了"，不是"正在收尾"，
         * 再挂一个转圈的运行态反而让人以为还有救。 */
        Engine.requestStop(Session.runId);
        Session.stop();
        Session.stopTimer();
        App.renderScreen();
        Dialog.licenseExpired(function () { App.showLogin(); });
        return;
    }

    App.pollEngine();
    FB.sync();

    /* pollEngine 可能已经把运行结束了（终态），此时状态条已经不存在 */
    if (App.runBar && Session.running) {
        App.runBar.setElapsed(Session.formatElapsed(Session.elapsedMs()));
        App.runBar.setText(Session.barText());
        App.runBar.setTone(Session.stopping ? "warn" : "ok");
    }
};

/**
 * 读引擎上报的状态，驱动界面的运行态。
 *
 * ★ 必须比对 runId：状态文件是设备上的共享文件，上一轮运行留下的内容还在。
 *   不比对就会出现「刚点开始运行，界面立刻显示上一轮的进度」。
 */
App.pollEngine = function () {
    var state = Engine.readState();

    if (state && state.runId === Session.runId) {
        /* 看到过它，才有资格在后来说"它不见了" —— 见下面的兜底判定 */
        if (Engine.childAlive()) { Engine.sawChild = true; }

        if (Engine.isTerminalStatus(state.status)) {
            App.finishRun(state);
            return;
        }
        if (state.phase) { Session.phase = state.phase; }
        Session.done = state.done || 0;
        Session.total = state.total || 0;
        if (state.status === "stopping") { Session.stopping = true; }
    } else if (Engine.childAlive()) {
        /* 引擎在跑但还没写出状态：正常的启动间隙，什么都不做 */
        Engine.sawChild = true;
    }

    /* —— 兜底一：点了停止但引擎迟迟不确认 —— */
    if (Session.stopping && Date.now() - Session.stopRequestedAt > App.STOP_TIMEOUT_MS) {
        App.finishRun({
            status: "stopped",
            message: "\u5DF2\u53D1\u51FA\u505C\u6B62\u8BF7\u6C42\uFF08\u5F15\u64CE\u672A\u786E\u8BA4\uFF09"
        });
        return;
    }

    /* —— 兜底二：引擎没写终态就没了（被系统杀掉 / 被人手工停掉）——
     * 只在"确实看到过它、现在它不见了"时判定。`engines.all()` 在不同运行时里
     * 的可见性不完全一致，没看到过就当作"查不出来"，宁可多显示一会儿运行中，
     * 也不要误判成已结束把运行态清掉。 */
    if (!Session.stopping &&
        Engine.sawChild &&
        Date.now() - Session.startedAt > App.CHILD_GRACE_MS &&
        !Engine.childAlive()) {
        App.finishRun({
            status: "failed",
            message: "\u5F15\u64CE\u5DF2\u9000\u51FA\uFF08\u672A\u6536\u5230\u7ED3\u675F\u4FE1\u53F7\uFF09"
        });
    }
};

/**
 * 把界面拉回前台。
 *
 * 引擎跑起来时前台是 TikTok（它在那边操作），用户看不到界面上的进度；
 * 跑完把界面切回来，用户才不用自己去最近任务里把它翻出来。
 *
 * 为什么不用 `app.launchPackage(包名)`：那会打开 AutoX 的**主界面**，
 * 而不是"正在运行的这个脚本界面"。用当前 Activity 的类名 + REORDER_TO_FRONT
 * 才能精准命中同一个界面；它本来就在前台时，该调用无副作用。
 *
 * 失败不抛：拉不回前台只是少了点便利，不该影响"运行已结束"这件正事。
 */
App.bringToFront = function () {
    try {
        var className = activity.getClass().getName();
        app.startActivity({
            action: "android.intent.action.VIEW",
            packageName: String(context.getPackageName()),
            className: className,
            flags: android.content.Intent.FLAG_ACTIVITY_REORDER_TO_FRONT
        });
        return true;
    } catch (e) {
        console.log("[app] 拉回前台失败: " + e);
        return false;
    }
};

/**
 * 结束运行态。
 *
 * 顺序有讲究：先**攒一条运行记录**（此刻 Session 里还有本次运行的信息，
 * `Session.stop()` 一跑就全没了），再复位状态并重建界面（状态条消失、
 * 按钮变回"开始运行"），然后把界面拉回前台，最后提示结果 ——
 * 反过来的话提示会挂在一个还没被拆掉的界面上。
 *
 * 失败终态额外做两件事（规格书 §2.3 / §2.4）：
 *   · 运行条留在原地**变成玫瑰红**（「执行出错已停止」+「已终止」），
 *     用户关掉 F5 之后才隐藏；
 *   · 弹 F5，并把「查看日志」接到刚写下的那条记录上。
 */
App.finishRun = function (state) {
    var result = {
        status: state.status || "failed",
        message: state.message || "",
        summary: state.summary || null
    };

    /* ★ 记录必须在 Session.stop() 之前攒：任务/脚本/起始时间都在 Session 里。 */
    var record = App.writeRecord(result);
    App.lastRunResult = result;

    Session.stop();
    Session.stopTimer();

    if (result.status === "failed" && record) {
        App.failBar = {
            text: Pages.shortScriptName(record.scriptName) + " \u00B7 \u6267\u884C\u51FA\u9519\u5DF2\u505C\u6B62",
            time: "\u5DF2\u7EC8\u6B62",
            recordId: record.id
        };
    } else {
        App.failBar = null;
    }

    App.renderScreen();
    FB.sync();                     /* 失败 → 红环；正常 → 回空闲无环 */
    App.bringToFront();

    if (result.status === "failed") {
        Dialog.scriptError(result.message || "", function () {
            /* 「查看日志」→ 清掉报错条，再进 D3 */
            var id = App.failBar ? App.failBar.recordId : "";
            App.failBar = null;
            if (id) { App.openRecord(id); } else { App.renderScreen(); }
        }, function () {
            /* 「知道了」→ 报错条也随之消失（这一次的事已经被告知过了） */
            App.failBar = null;
            App.renderScreen();
        });
        console.log("[app] 运行结束（失败）：" + result.message);
        return;
    }

    /* toast 而不是弹窗：万一前台没能切回来（用户在别的应用里），
     * 系统 Toast 仍然看得见；而弹窗会挡着用户正在做的事。 */
    toast(result.message || "\u8FD0\u884C\u7ED3\u675F");
    console.log("[app] 运行结束：" + result.status + " / " + result.message);
};

/**
 * 把这次运行写进运行记录（D1/D3 的数据来源）。
 *
 * 只写**真实知道的东西**：任务/脚本来自 Session，结果文案来自引擎终态，
 * 日志来自引擎的 --log 通道（`Engine.readLog()`）。引擎没回传的字段留空，
 * D3 那边对应的一行就不渲染 —— 不编一个看起来合理的值。
 */
App.writeRecord = function (result) {
    if (!Session.tab) { return null; }

    var endedAt = Date.now();
    var record = Records.add({
        taskKey: Session.tab,
        taskName: Pages.taskName(Session.tab),
        scriptKey: Session.scriptKey,
        scriptName: Session.scriptName,
        result: Records.resultOf(result.status).key,
        startedAt: Session.startedAt,
        endedAt: endedAt,
        durationMs: Math.max(0, endedAt - Session.startedAt),
        resultText: result.message || "",
        resultFile: result.summary && result.summary.resultFile ? result.summary.resultFile : "",
        /* ID提取勾了「同时解析数字 uid」时，引擎还会另写一份 username→uid 的映射文件。
         * 以前这里只传 resultFile，映射文件虽然在手机上，界面上却看不到路径、
         * 点不开也分享不了 —— 等于白生成。 */
        mapFile: result.summary && result.summary.mapFile ? result.summary.mapFile : "",
        /* runId：记录页要靠它和断点里的 runId 对上，才知道"这条记录就是那个没跑完的"。
         * 不带的话，一串历史「手动停止」记录上都会冒出「继续」。 */
        runId: Session.runId || "",
        logs: Engine.readLog()
    });
    console.log("[records] 已记录本次运行：" + record.id + " / " + record.result);
    return record;
};

/**
 * 取当前任务详情页里选中的那个脚本，没选返回 null。
 *
 * 从 v6 起「当前任务」= **当前打开的那个任务详情页**（App.detail）。
 * 一级页（任务列表）没有"当前任务"这回事 —— 四张卡各有各的「运行」按钮，
 * 各带各的 taskKey（见 App.requestRun）。这正是"每个任务单独启动"的落点。
 */
App.currentTask = function () {
    /* ★ 读配置之前先把「用户可能还在编辑」的输入框内容落地。
     * Android 里点一个不可聚焦的按钮**不会**让 EditText 失焦，
     * 所以「按开始运行」这一刻栏位内容很可能还没进配置。 */
    W.commitPendingInputs();

    if (!App.detail) { return null; }
    return Pages.checkedScript(App.detail);
};

/**
 * 把当前配置落盘成交给执行侧的运行配置。
 *
 * 这里写的是**给人看、给事后追溯用**的快照（含界面完整配置、本次生效的引擎配置、
 * 以及"哪些勾了但本次不会生效"）。引擎真正读的是 engine-config.json ——
 * 分成两份是因为两边的读者不同：一个排查问题的人需要全貌，引擎只需要它能懂的那部分。
 */
App.exportRunConfig = function (checked, plan) {
    var payload = {
        generatedAt: Service.today(),
        scriptVersion: Service.SCRIPT_VERSION,
        licenseStatus: Service.licenseStatus().status,
        tasks: checked,
        engine: {
            /* ★ 用 pendingRunId 而不是 Session.runId：
             *   本函数在 `Session.start()` **之前**被调用，那时会话里还是上一轮的 runId。
             *   记错这一次的标识，事后追溯就会被误导到别的运行记录上。 */
            runId: App.pendingRunId,
            scriptPath: plan ? plan.scriptPath : "",
            configPath: Engine.CONFIG_PATH,
            statePath: Engine.STATE_PATH,
            stopFlagPath: Engine.STOP_FLAG_PATH,
            config: plan ? plan.config : null,
            notes: plan ? plan.notes : []
        },
        config: Store.current(),
        /* ★ v8：取材清单**不在** `Store.FIELDS` 里（它是不定长列表，走独立 storage key），
         *   所以 `config: Store.current()` 里没有它。但"这一轮到底从哪取的材"
         *   恰恰是事后追溯最需要的一条，必须单独带上。 */
        sources: Sources.list()
    };
    try {
        var dir = App.RUN_CONFIG_PATH.substring(0, App.RUN_CONFIG_PATH.lastIndexOf("/"));
        files.ensureDir(dir + "/");
        files.write(App.RUN_CONFIG_PATH, JSON.stringify(payload, null, 2));
        return true;
    } catch (e) {
        console.log("[app] 运行配置落盘失败: " + e);
        return false;
    }
};

/**
 * **所有**「开始运行」的唯一入口（底部 CTA 与四张任务卡上的「运行」都走它）。
 *
 * 前置校验顺序**照规格书 §2.5 实现**，任一步不过就拦截：
 *   ① 卡密有效？    → 否：不做提示，直接回 A1
 *   ② 无障碍+悬浮窗？→ 否：弹 F2
 *   ③ 已选脚本？    → 否：弹 F1
 *   ④ 引擎接入？    → 否：弹「引擎尚未接入」（**本项目自己的补丁**：
 *                      规格书假设所有脚本都已实现，而这里有四个任务还没接引擎。
 *                      静默跑一个不相关的东西比明确告知糟糕得多，所以保留这一关）
 *   ⑤ 已有脚本在跑？ → 是：弹 F3「停止并开始」；否：直接启动
 *
 * 顺序不能随手改：卡密排第一是因为它不通时**别的都无从谈起**（且要回登录页），
 * 权限排第二是因为它比"选脚本"更难自己发现（缺口在系统设置里）。
 *
 * @param taskKey 要运行哪个任务（任务卡上的按钮直接给，不必先切到那个页）
 */
App.requestRun = function (taskKey, opts) {
    /* ① 卡密：失效就直接回登录页，不弹提示 —— 那里才有可做的事 */
    if (Service.licenseStatus().status !== "active") {
        App.showLogin();
        return;
    }

    /* ② 阻断性权限（无障碍 + 悬浮窗） */
    if (!Device.blockingPermissionsGranted()) {
        Dialog.permissionBlocked();
        return;
    }

    /* ③ 该任务当前选中的脚本 */
    var script = Pages.checkedScript(taskKey);
    if (!script) {
        /* v8：ID提取没有"脚本"了，它的空态是"还没添加取材" ——
         * 对用户说"请先选择要运行的脚本"会让他到处找那不存在的脚本。 */
        Dialog.runBlocked(taskKey === "id"
            ? "\u8BF7\u5148\u6DFB\u52A0\u4E00\u6761\u53D6\u6750"
            : "\u8BF7\u5148\u9009\u62E9\u8981\u8FD0\u884C\u7684\u811A\u672C");
        return;
    }

    /* ④ 引擎是否接入（见函数头注释） */
    if (!script.engine) {
        Dialog.engineMissing(script.name);
        return;
    }

    /* ⑤ 全局单跑：运行中点别的任务不禁用按钮，而是弹 F3 确认（规格书 §2.3） */
    if (Session.running) {
        Dialog.switchTask(Pages.taskName(Session.tab), Pages.taskName(taskKey), function () {
            App.startRun(script, opts);
        });
        return;
    }

    /* ⑦ 有没跑完的断点、而用户点的是普通「开始运行」→ 先问一句。
     *
     * 不问的话，用户会静默丢掉上一轮的进度（断点被新一轮覆盖），
     * 而且界面上完全看不出来发生过这件事。用「选一个」而不是「确认/取消」：
     * 两个选项都是用户可能真心想要的，只给"确定/取消"会让人没法表达"我要从零开始"。
     *
     * 只有 ID 提取有断点，别的任务直接走原路。
     */
    if (taskKey === "id" && !(opts && opts.resume)) {
        var pending = Resume.snapshot();
        if (pending.valid) {
            Dialog.choose({
                title: "\u4E0A\u6B21\u8FD0\u884C\u8FD8\u6CA1\u8DD1\u5B8C",
                options: [
                    "\u7EE7\u7EED\u4E0A\u6B21\uFF08\u5DF2\u6536 " + pending.extracted + " \u4E2A\uFF09",
                    "\u4ECE\u96F6\u5F00\u59CB\uFF08\u65AD\u70B9\u4F5C\u5E9F\uFF09"
                ],
                currentIndex: 0,
                onConfirm: function (index) {
                    if (index === 0) {
                        App.resumeRun();
                        return;
                    }
                    App.startRun(script, opts);
                }
            });
            return;
        }
    }

    App.startRun(script, opts);
};

/**
 * 继续上次没跑完的那一轮（提示条、记录行、记录详情都走这里）。
 *
 * **不自己重跑一遍卡密/权限检查** —— 交给 `requestRun` 统一做。
 * 续跑如果绕过卡密校验，就等于开了一个"卡密过期也能跑"的后门。
 *
 * @param record 可选。从某条运行记录点进来时传，用来核对"这条记录是不是那个断点"
 */
App.resumeRun = function (record) {
    if (Session.running) {
        toast("\u5DF2\u6709\u4EFB\u52A1\u5728\u8FD0\u884C\uFF0C\u8BF7\u5148\u505C\u6B62");
        return;
    }

    var snap = Resume.snapshot();
    if (!snap.exists || snap.finished || snap.reason === "cleared") {
        Dialog.alert("\u6CA1\u6709\u53EF\u7EE7\u7EED\u7684\u8FD0\u884C",
                     "\u4E0A\u6B21\u7684\u8FD0\u884C\u5DF2\u7ECF\u7ED3\u675F\uFF0C\u6216\u65AD\u70B9\u5DF2\u88AB\u6E05\u7A7A\u3002");
        return;
    }
    if (!snap.valid) {
        Dialog.alert("\u65AD\u70B9\u65E0\u6CD5\u7EE7\u7EED",
                     (snap.message || "\u65AD\u70B9\u5DF2\u5931\u6548") +
                     "\n\n\u6E05\u7A7A\u65AD\u70B9\u540E\u53EF\u4EE5\u91CD\u65B0\u5F00\u59CB\u3002");
        return;
    }
    /* 从记录点进来时必须核对 runId：断点只保留最后一份，可能是后来那一轮的 */
    if (record && (!record.runId || !snap.cp || record.runId !== snap.cp.runId)) {
        Dialog.alert("\u8FD9\u6761\u8BB0\u5F55\u4E0D\u80FD\u7EE7\u7EED",
                     "\u65AD\u70B9\u5DF2\u88AB\u4E4B\u540E\u7684\u8FD0\u884C\u8986\u76D6\u3002");
        return;
    }

    App.requestRun("id", { resume: true });
};

/** 清空断点（覆盖成 state:'none'，不删文件） */
App.clearCheckpoint = function () {
    if (!Resume.clear()) {
        toast("\u6E05\u7A7A\u65AD\u70B9\u5931\u8D25");
        return;
    }
    App.renderScreen();
    toast("\u65AD\u70B9\u5DF2\u6E05\u7A7A\uFF0C\u4E0B\u6B21\u4ECE\u5934\u5F00\u59CB");
};

/**
 * 底部 CTA 的唯一入口：没在跑就尝试开始（跑当前详情页那个任务的脚本），在跑就停。
 * 校验逻辑与任务卡共用 `App.requestRun`，避免两处各写一遍顺序。
 */
App.toggleRun = function () {
    if (Session.running) {
        App.stopRun();
        App.renderScreen();
        return;
    }
    if (!App.detail) { return; }
    App.requestRun(App.detail);
};

/**
 * 真正进入运行态：准备引擎 → 落盘配置 → **唤起引擎** → 建状态条 → 起计时。
 *
 * 顺序不能换：配置必须先落盘（引擎一起来就读它），
 * 计时必须在唤起成功之后才开始（否则引擎没起来，界面却在计时，是最难解释的一种状态）。
 */
App.startRun = function (task, opts) {
    var plan = Engine.prepare(task, opts);
    if (!plan.ok) {
        Dialog.engineUnavailable(plan.error);
        return;
    }

    /* runId 要在写配置之前定下来：它会被同时写进 run-config（追溯）与引擎参数（比对） */
    App.pendingRunId = Engine.newRunId();

    if (!App.exportRunConfig([{ tab: task.task, script: task.key, name: task.name }], plan)) {
        toast("\u8FD0\u884C\u914D\u7F6E\u5199\u5165\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u5B58\u50A8\u6743\u9650");
        return;
    }
    if (!Engine.writeConfig(plan.config)) {
        toast("\u5F15\u64CE\u914D\u7F6E\u5199\u5165\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u5B58\u50A8\u6743\u9650");
        return;
    }

    var launched = Engine.launch(App.pendingRunId, plan.scriptPath, opts);
    if (!launched.ok) {
        Dialog.engineUnavailable("\u5F15\u64CE\u542F\u52A8\u5931\u8D25\uFF1A" + launched.error);
        return;
    }

    Session.start(task.task, task.key, task.name, App.pendingRunId);
    Engine.sawChild = false;
    App.lastRunResult = null;
    App.failBar = null;
    App.backgroundWarned = false;

    /* 运行条要能点击跳回**正在跑的那个任务**，所以顺手把它带进那个任务的详情页：
     * 用户刚点了「运行」，看到的应该是"它跑起来了"，而不是停在列表上猜。 */
    if (App.detail !== task.task || App.activeTab !== "tasks") {
        App.recordId = "";
        App.detail = task.task;
        App.activeTab = "tasks";
        Store.set("activeTab", "tasks");
        Store.set("activeDetail", task.task);
    }

    console.log("[app] 已唤起引擎 " + plan.scriptPath + " runId=" + App.pendingRunId);
    App.renderScreen();
    FB.sync();                     /* 球的外环变青绿 + 开始呼吸（规格书 §10.4） */
    Session.startTimer(App.tickTimer);

    /* notes 是"你勾了、但引擎这次做不到"的项。**如实告知**，
     * 完整内容也写进了 run-config.json 供事后核对。 */
    var summary = Engine.summarizeNotes(plan.notes);
    if (summary) { toast(summary); }
};

/**
 * 停运行。
 *
 * 分两步、且**不立刻复位**：先向引擎发出停止请求，界面进入「正在收尾」，
 * 等引擎上报 stopped（或超时）才真正结束。
 *
 * 为什么不做成"点一下就当停了"：引擎收到请求后还要退出当前等待、把 TikTok
 * 带回信息流，通常 1 秒内完成，但它确实还在动。这时界面说「已停止」，
 * 用户看到 TikTok 仍在操作，只能怀疑"到底停没停"。
 *
 * **不负责重建界面** —— 调用方要么接着切屏，要么自己补一次重建。
 */
App.stopRun = function () {
    if (!Session.running) { return; }
    if (Session.stopping) { return; }

    if (Engine.requestStop(Session.runId)) {
        Session.stopping = true;
        Session.stopRequestedAt = Date.now();
        console.log("[app] 已发出停止请求 runId=" + Session.runId);
        return;
    }

    /* 写标志都失败了就没什么可等的，直接复位 */
    App.finishRun({ status: "stopped", message: "\u5DF2\u505C\u6B62" });
};

/* ------------------------------------------------------------ 权限弹窗 */

/** 打开权限弹窗。弹窗自己也保证同时只存在一个，这里再挡一道更直观。 */
App.openPermissions = function () {
    if (Dialog.active) { return; }
    Dialog.showPermissions();
};

/* ------------------------------------------------------------ 卡密登录 */

/** 切到登录页。重置三态，避免把上一次的失败提示带过来。 */
App.showLogin = function () {
    App.screen = "login";
    /* 登录页不该有球：卡密都没了就没什么可控制的，留在屏幕上只是挡路 */
    FB.destroy();
    Pages.LICENSE_RESET();
    App.renderScreen();
};

/** 登录成功：回主界面，并顺手把还缺的权限提示一次。 */
App.enterApp = function () {
    App.screen = "app";
    /* 进主界面就把悬浮球挂上（它只在"卡密有效 + 有悬浮窗权限"时才会真的建，见 FB.canShow） */
    FB.ensure();
    /* 把登录页三态复位。不复位的话它会停在 verifying ——
     * 一旦有别的路径重新渲染登录页（而不是走 showLogin），
     * 用户看到的就是一个永远「登录中…」的界面。 */
    Pages.LICENSE_RESET();
    App.renderScreen();
    if (!Device.allPermissionsGranted()) { App.openPermissions(); }
};

/**
 * 提交卡密。
 *
 * 为什么中间要留 450ms：校验走本地时是毫秒级的，界面会从「登录激活」
 * 直接跳到主界面，用户根本看不到反馈——会以为按钮没反应于是连点。
 * 留这一帧让「登录中…」真的被画出来，是**交互正确性**而不是动画点缀。
 */
App.submitLicense = function (code) {
    var view = Pages.LICENSE_VIEW;
    if (typeof code !== "string" || code.replace(/[\s-]/g, "") === "") {
        toast("\u8BF7\u8F93\u5165\u5361\u5BC6");
        return;
    }

    view.state = "verifying";
    App.renderScreen();

    setTimeout(function () {
        var result = Service.login(code);

        if (result.ok) {
            Store.set("license.status", result.status);
            Store.set("license.code", result.code);
            Store.set("license.expireAt", result.expireAt);
            /* ★ 这里**不要**去清 `license.draftCode`。
             *   试过「激活成功后清空草稿」，真机上立刻被打回来：
             *   `App.enterApp()` → `renderContent()` 会先跑 `commitPendingInputs()`，
             *   而登录页那个输入框此刻**还在待提交表里**，于是刚清掉的草稿
             *   又被它自己的文字写回去（顺序反了，清理等于没做）。
             *   保留草稿也更顺手：解绑后回到登录页，上次的卡密已经填好，一键即可重新激活；
             *   它和 `license.code` 本来就在同一个 JSON 里，多留一份不增加暴露面。 */
            toast(result.message);
            App.enterApp();
            return;
        }

        if (result.status === "expired") {
            Store.set("license.status", "expired");
            Store.set("license.expireAt", result.expireAt || "");
        }
        view.state = "failed";
        view.message = result.message;
        App.renderScreen();
    }, 450);
};

/** 购买入口。没有可用的客服渠道就如实说，不编一个不存在的联系方式。 */
App.showPurchaseInfo = function () {
    Dialog.alert("\u8D2D\u4E70\u5361\u5BC6",
        "\u5F53\u524D\u672A\u914D\u7F6E\u5728\u7EBF\u8D2D\u4E70\u6E20\u9053\u3002\n\n" +
        "\u914D\u7F6E\u540E\uFF0C\u8FD9\u91CC\u4F1A\u76F4\u63A5\u6253\u5F00\u5BA2\u670D\u4F1A\u8BDD\u6216\u8D2D\u4E70\u9875\u3002");
};

/** 退出应用。优先用 ui.finish()，它才是 UI 模式下的正确出口。 */
App.exit = function () {
    /* 退出前必须关掉悬浮窗：脚本结束不会自动带走它，留着就是一个"孤儿球" */
    FB.destroy();
    try {
        if (typeof ui.finish === "function") { ui.finish(); return; }
    } catch (e) {
        console.log("[app] ui.finish 不可用: " + e);
    }
    try {
        activity.finish();
    } catch (e2) {
        console.log("[app] 退出失败: " + e2);
    }
};

/* ------------------------------------------------------------ 结果文件 / 日志动作 */

/**
 * 打开结果文件（D3 的「打开」）。
 *
 * 文件可能已经不在了（被清理/被移走），所以先 exists 再动手 ——
 * 直接 startActivity 一个不存在的 file:// 在部分 ROM 上会抛 FileUriExposedException。
 */
App.openResultFile = function (path) {
    if (!path) { return; }
    try {
        if (!files.exists(path)) {
            Dialog.alert("\u6587\u4EF6\u4E0D\u5B58\u5728",
                "\u8FD9\u4E2A\u7ED3\u679C\u6587\u4EF6\u5DF2\u4E0D\u5728\u672C\u673A\uFF1A\n\n" + path);
            return;
        }
        app.viewFile(path);
    } catch (e) {
        console.log("[app] 打开结果文件失败: " + e);
        toast("\u65E0\u6CD5\u6253\u5F00\u8BE5\u6587\u4EF6");
    }
};

/** 分享结果文件（D3 的「分享」）。系统分享面板由 ROM 提供，不自己造一个。 */
App.shareResultFile = function (path) {
    if (!path) { return; }
    try {
        if (!files.exists(path)) {
            toast("\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u65E0\u6CD5\u5206\u4EAB");
            return;
        }
        app.sendIntent({
            action: "android.intent.action.SEND",
            type: "*/*",
            extra: { "android.intent.extra.STREAM": path }
        });
    } catch (e) {
        console.log("[app] 分享失败: " + e);
        toast("\u5206\u4EAB\u5931\u8D25");
    }
};

/**
 * 复制整段日志（D3 的「复制」）。
 *
 * 拼成纯文本而不是 JSON：用户多半是要粘到聊天窗口里给人看，
 * 带花括号的 JSON 反而难读。
 */
App.copyLogs = function (record) {
    if (!record) { return; }
    var logs = record.logs || [];
    if (logs.length === 0) {
        toast("\u672C\u6B21\u8FD0\u884C\u6CA1\u6709\u65E5\u5FD7");
        return;
    }
    var lines = [];
    for (var i = 0; i < logs.length; i++) {
        var e = logs[i];
        lines.push(String(e.text || ""));
    }
    var text = Pages.recordTitle(record) + "\n" + Records.timeLine(record) + "\n\n" + lines.join("\n");
    try {
        /* setClip 是 AutoX 的全局函数；桩测环境没有它，所以带类型判断 */
        if (typeof setClip === "function") {
            setClip(text);
            toast("\u65E5\u5FD7\u5DF2\u590D\u5236");
        } else {
            toast("\u5F53\u524D\u8FD0\u884C\u65F6\u4E0D\u652F\u6301\u526A\u8D34\u677F");
        }
    } catch (e2) {
        console.log("[app] 复制日志失败: " + e2);
        toast("\u590D\u5236\u5931\u8D25");
    }
};

/* ------------------------------------------------------------ 启动 */

/**
 * 挂载根视图。
 * ui.setContentView 是标准 API；若运行时确实没有，宁可明确报错，
 * 也不要退回一个半可用的挂载方式——那样界面起不来还找不到原因。
 */
App.mount = function (root) {
    if (typeof ui.setContentView !== "function") {
        throw new Error("当前 AutoX 运行时缺少 ui.setContentView，无法挂载界面");
    }
    ui.setContentView(root);
};

/**
 * 界面被关掉时，把悬浮球一起带走。
 *
 * ★ 为什么必须有这个：AutoX 的 UI 模式下**「Activity 关闭」不等于「脚本结束」**。
 *   界面脚本跑在 `:script` 进程的线程里，用户从最近任务划掉界面（或按返回退出）后，
 *   脚本仍在跑 —— 而悬浮球窗口是**脚本**持有的，于是球留在别的 App 上面，
 *   看起来就是"应用都关了，球还浮着"。
 *   实测（2026-10-22）：前台已是 AutoX 的 MainActivity、`:script` 进程存活、
 *   dumpsys 里还有 8 个 autojs 窗口残留。
 *
 * 两条兜底，各自覆盖一种情况：
 *   ① `events.on("exit")` —— 脚本正常结束或抛异常时清一次。
 *      进程被系统杀掉时走不到这里，但那种情况窗口会随进程一起被回收，不用我们管。
 *   ② 轮询 `activity` 是否已 finish —— **唯一能覆盖"界面关了但脚本还活着"的路径**，
 *      也就是用户报的这个场景。
 */
function bindLifecycleCleanup() {
    try {
        events.on("exit", function () {
            try { FB.destroy(); } catch (e) { /* 退出路径上不能再抛 */ }
        });
    } catch (e) {
        console.log("[app] events.on(exit) 不可用（不影响其它清理路径）: " + e);
    }

    /* 只有"曾经拿到过 activity、后来它没了/在销毁"才算关闭。
     * 这样在 PC 侧 smoke（没有 activity 这个全局）里不会误触发 exit()。 */
    var sawActivity = false;

    App.lifecycleTick = setInterval(function () {
        var gone = false;
        try {
            if (typeof activity !== "undefined" && activity !== null) {
                sawActivity = true;
                gone = activity.isFinishing() || activity.isDestroyed();
            } else if (sawActivity) {
                gone = true;
            }
        } catch (e) {
            /* 拿 activity 时抛异常 = 它已经没了 */
            gone = sawActivity;
        }
        if (!gone) {
            return;
        }
        try { clearInterval(App.lifecycleTick); } catch (ignored) { }
        App.lifecycleTick = null;
        console.log("[app] 界面已关闭，清理悬浮球并结束脚本");
        try { FB.destroy(); } catch (e2) { /* 同上 */ }
        try { exit(); } catch (e3) { /* 老版本 AutoX 可能没有 exit() */ }
    }, 1500);
}

App.main = function () {
    Store.init();

    /* v8：把旧的四张卡配置翻译成「取材清单」（一次性，已有清单就不动）。
     *
     * 为什么放在这里而不是 Store.load 里：Store 不该知道 Sources 存在
     * （清单是另一个储物柜），而且这里能保证**所有模块都已加载完**再动它。
     * 迁移失败不许拦住界面 —— 最坏情况是用户看到空清单，自己加一条即可。 */
    try {
        var migrated = Sources.migrateLegacy();
        if (migrated && migrated.length > 0) {
            console.log("[app] 旧的四张卡配置已翻译成 " + migrated.length + " 条取材");
        }
    } catch (eMig) {
        console.log("[app] 取材清单迁移失败（不影响使用，清单为空时可手动添加）: " + eMig);
    }

    /* getEnum 保证拿回合法 tab key：旧配置里存了已删除的页签也不会白屏。
     * 老页签（id/dm/nurture/video）由 Store.MIGRATIONS[5] 映射成 tasks（见 store.js）。 */
    var configuredTab = Store.getEnum("activeTab", "tab");
    App.activeTab = App.TAB_PAGES[configuredTab] ? configuredTab : "tasks";

    /* 二级页也要能冷启动恢复 —— 但必须是**认识的那个任务**。
     * 配置被手改过时回退到一级页，而不是渲染一个空白详情页。 */
    var configuredDetail = Store.getEnum("activeDetail", ["", "id", "dm", "nurture", "video"]);
    App.detail = App.DETAIL_PAGES[configuredDetail] ? configuredDetail : "";

    /* 返回键：有弹窗就先关弹窗，其次退二级页，都没有则交给系统（退出界面）。
     * 用 emitter 而不是 View.OnKeyListener —— 后者要构造一个 Java 接口实例，
     * 写法依赖运行时的接口包装能力，换个 AutoX 版本就可能失效。 */
    ui.emitter.on("back_pressed", function (event) {
        if (Dialog.active) {
            event.consumed = true;
            Dialog.active.close();
            return;
        }
        if (App.recordId) {
            event.consumed = true;
            App.closeRecord();
            return;
        }
        if (App.detail) {
            event.consumed = true;
            App.closeDetail();
        }
    });

    /* 界面回到前台时提醒一句（只在引擎正在跑时）。
     * 这是 UI 生命周期事件，不是轮询：用户切走再切回才会触发，代价为零。 */
    ui.emitter.on("resume", function () {
        App.noticeIfRunningInBackground();
        /* 补建：用户多半是先去系统设置里开了悬浮窗权限、再切回来的。
         * ensure() 幂等，已经建好时只做一次状态同步。 */
        FB.ensure();
    });

    ui.statusBarColor(U.argb(Theme.hex.bg));
    App.mount(App.build());
    /* 弹窗需要一个浮层宿主，骨架搭好之后注入 */
    Dialog.mount(App.overlayHost);

    /* 启动时的屏：卡密没激活就直接进登录页，不让用户先进一个什么都点不动的主界面 */
    App.screen = Service.licenseStatus().status === "active" ? "app" : "login";

    /* 冷启动也是"要用球"的场景：已激活时直接把它挂上（未激活时 canShow 自己会拦住） */
    FB.ensure();
    /* 界面关了要把球带走 —— 见 bindLifecycleCleanup 的注释 */
    bindLifecycleCleanup();
    App.renderScreen();

    console.log("[app] 界面已就绪，screen=" + App.screen + " 页签=" + App.activeTab);
    console.log("[app] 无障碍=" + Device.a11yEnabled() +
                " 悬浮窗=" + Device.overlayEnabled() +
                " 通知=" + Device.notifyEnabled());

    if (App.screen === "app" && !Device.allPermissionsGranted()) {
        App.openPermissions();
    }

    /* 落盘一份启动结论，便于 PC 侧离线核验（日志链路可能丢） */
    try {
        files.write("/sdcard/tiktok_app_ui_result.txt",
            "OK_UI_STARTED\nscreen=" + App.screen +
            "\ntab=" + App.activeTab +
            "\na11y=" + Device.a11yEnabled() +
            "\nlicense=" + Service.licenseStatus().status +
            "\ntiktok=" + JSON.stringify(Device.tiktok()));
    } catch (e) {
        console.log("[app] 结果文件写入失败: " + e);
    }
};

/* ---------------------------------------------------------------------------
 * 测试钩子（规范 R16：让纯函数与内部状态可被单独驱动）
 *
 * PC 侧 tools/smoke.js 会先设 __FEIZHOU_TEST__ 再加载产物，
 * 借此拿到 IIFE 内部的对象做断言。设备端不会设这个标志，
 * 因此对实际运行零影响、零开销。
 * ------------------------------------------------------------------------- */
if (typeof globalThis !== "undefined" && globalThis.__FEIZHOU_TEST__) {
    globalThis.__FEIZHOU__ = {
        Theme: Theme,
        Store: Store,
        Records: Records,
        Sources: Sources,
        Device: Device,
        Service: Service,
        Engine: Engine,
        Session: Session,
        Resume: Resume,
        Fingerprint: Fingerprint,
        W: W,
        Dialog: Dialog,
        Pages: Pages,
        FB: FB,
        App: App
    };
}


/* 入口 */
App.main();
}());