腾讯云 38 元轻量服务器活动指南：4 核 4G 3M 配置与 Console 辅助脚本

/*
 * 腾讯云 38 元轻量服务器 Console 脚本。
 *
 * 运行位置：已登录的活动页
 * https://curl.qcloud.com/REmjDl1z
 *
 * 粘贴完整脚本后会自动选择下一场并等待下单。
 * 脚本直接复用活动页官方请求模块，不需要再执行初始化命令。
 * TC38.fireNow() 会立即尝试创建待支付订单。
 */
(() => {
  "use strict";

  // 重复粘贴新版时先停止上一版，避免留下两个等待任务。
  try {
    window.TC38?.cancel?.();
  } catch {}
  document.querySelector("#tc38-monitor-panel")?.remove();
  document.querySelector("#tc38-payment-link")?.remove();

  const CFG = {
    expectedPriceFen: 3800,
    expectedSpec: "4核4G3M",
    retryRoundIntervalMs: 220,
    finalClockSyncLeadMs: 60_000,
    panelNormalRefreshMs: 1000,
    panelFastRefreshMs: 200,
    panelFastRefreshLeadMs: 10_000,
    regionPriority: [
      { id: 1, name: "广州" },
      { id: 4, name: "上海" },
      { id: 8, name: "北京" },
    ],
  };

  let dianshiApi = null;
  let runGeneration = 0;
  let scheduledFor = null;
  let monitorTimer = null;
  let monitorState = "idle";
  let monitorTargetMs = null;
  let monitorClockOffsetMs = 0;
  let monitorSession = null;
  let monitorMessage = "";
  let preferredRegionId = CFG.regionPriority[0].id;
  let orderRound = 0;
  let orderRequestCount = 0;
  let noStockRetryCount = 0;
  let noStockDetected = false;
  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

  function readTarget() {
    const node = document.querySelector("#__NEXT_DATA__");
    if (!node?.textContent) {
      throw new Error("找不到 __NEXT_DATA__，请确认在活动页运行");
    }

    const root = JSON.parse(node.textContent);
    const activity = root?.props?.pageProps?.activityData;
    const flash = activity?.twoDaySeckillState?.flashResult || {};
    const sales = Object.values(flash)
      .flatMap((sessions) => (Array.isArray(sessions) ? sessions : []))
      .flatMap((session) => (Array.isArray(session?.sales) ? session.sales : []));

    const sale = sales.find((item) => {
      const sku = item?.seckill_act_extra?.skuList || [];
      return item?.priceData?.real_cost === CFG.expectedPriceFen
        && sku.includes(CFG.expectedSpec)
        && sku.includes("300GB 月流量")
        && String(item?.product_name || "").includes("lighthouse");
    });

    if (!sale) {
      throw new Error("未找到 38 元 4核4G3M / 300GB 商品，拒绝继续");
    }

    const goodsParam = structuredClone(
      sale.defaultOrderParam || sale.defaultGoodsParam || {},
    );
    const activityId = Number(
      sale.activityId || sale?.$goods?.activity_id || activity?.activityId,
    );
    const goodsActId = Number(
      sale.goodsId || sale.act_id || sale?.$goods?.big_goods_id,
    );

    if (!Number.isSafeInteger(activityId) || !Number.isSafeInteger(goodsActId)) {
      throw new Error("活动 ID 解析失败");
    }

    return {
      activityId,
      goodsActId,
      outerType: sale.productType || sale.product_name || sale?.$goods?.product_name,
      goodsType: goodsParam.type,
      goodsParam,
      title: sale.goods_name,
      priceFen: sale.priceData.real_cost,
    };
  }

  const target = readTarget();

  function chinaTimeText(timestamp) {
    return new Date(timestamp + 8 * 3_600_000)
      .toISOString()
      .replace("T", " ")
      .slice(0, 19);
  }

  function remainingText(milliseconds) {
    // 与活动页一样显示“完整剩余秒数”，避免向上取整多出 1 秒。
    const totalSeconds = Math.max(0, Math.floor(milliseconds / 1000));
    const days = Math.floor(totalSeconds / 86_400);
    const hours = Math.floor((totalSeconds % 86_400) / 3_600);
    const minutes = Math.floor((totalSeconds % 3_600) / 60);
    const seconds = totalSeconds % 60;
    const clock = [hours, minutes, seconds]
      .map((value) => String(value).padStart(2, "0"))
      .join(":");
    return days ? `${days}天 ${clock}` : clock;
  }

  function regionsInPriorityOrder() {
    const preferred = CFG.regionPriority.find(
      (region) => region.id === preferredRegionId,
    );
    if (!preferred) return [...CFG.regionPriority];
    return [
      preferred,
      ...CFG.regionPriority.filter((region) => region.id !== preferredRegionId),
    ];
  }

  function setPreferredRegion(regionValue) {
    const normalized = String(regionValue).trim();
    const region = CFG.regionPriority.find(
      (item) => String(item.id) === normalized || item.name === normalized,
    );
    if (!region) {
      throw new Error(`不支持的地域：${regionValue}`);
    }

    preferredRegionId = region.id;
    if (document.querySelector("#tc38-monitor-panel")) renderMonitorPanel();
    const order = regionsInPriorityOrder().map((item) => item.name);
    console.log(`[TC38] 优先地域已设为 ${region.name}`, order.join(" → "));
    return order;
  }

  function clearMonitorTimer() {
    if (monitorTimer !== null) {
      clearTimeout(monitorTimer);
      monitorTimer = null;
    }
  }

  function monitorRefreshDelay() {
    if (monitorTargetMs === null) return CFG.panelNormalRefreshMs;
    const left = monitorTargetMs - (Date.now() + monitorClockOffsetMs);
    return left <= CFG.panelFastRefreshLeadMs
      ? CFG.panelFastRefreshMs
      : CFG.panelNormalRefreshMs;
  }

  function scheduleMonitorRefresh() {
    clearMonitorTimer();
    const tick = () => {
      if (monitorState !== "monitoring") {
        monitorTimer = null;
        return;
      }
      renderMonitorPanel();
      monitorTimer = setTimeout(tick, monitorRefreshDelay());
    };
    monitorTimer = setTimeout(tick, monitorRefreshDelay());
  }

  function ensureMonitorPanel() {
    let panel = document.querySelector("#tc38-monitor-panel");
    if (panel) return panel;

    panel = document.createElement("div");
    panel.id = "tc38-monitor-panel";
    Object.assign(panel.style, {
      position: "fixed",
      zIndex: "2147483647",
      top: "20px",
      right: "20px",
      width: "340px",
      padding: "16px",
      border: "1px solid #2f6feb",
      borderRadius: "10px",
      background: "#101828",
      boxShadow: "0 8px 28px rgba(0, 0, 0, 0.3)",
      color: "#f8fafc",
      font: "14px/1.5 -apple-system, BlinkMacSystemFont, Segoe UI, sans-serif",
    });
    panel.innerHTML = `
      <div style="display:flex;align-items:center;justify-content:space-between;gap:12px">
        <strong data-role="title" style="font-size:16px"></strong>
        <span data-role="state" style="color:#6ee7b7"></span>
      </div>
      <div data-role="countdown" style="margin:12px 0 8px;font:700 30px/1.2 ui-monospace,SFMono-Regular,Menlo,monospace;color:#7dd3fc"></div>
      <div data-role="target" style="color:#cbd5e1"></div>
      <div data-role="offset" style="color:#94a3b8"></div>
      <label style="display:flex;align-items:center;gap:8px;margin-top:8px;color:#cbd5e1">
        <span>优先地域：</span>
        <select data-role="preferred-region" style="flex:1;padding:5px 8px;border:1px solid #64748b;border-radius:5px;background:#1e293b;color:#f8fafc;cursor:pointer">
          ${CFG.regionPriority.map((region) => `<option value="${region.id}">${region.name}</option>`).join("")}
        </select>
      </label>
      <div data-role="regions" style="margin-top:6px;color:#94a3b8"></div>
      <div data-role="attempts" style="margin-top:4px;color:#94a3b8"></div>
      <div data-role="stock-retries" style="margin-top:4px;color:#94a3b8"></div>
      <div data-role="message" style="min-height:21px;margin-top:8px;color:#fbbf24"></div>
      <div style="margin-top:12px;display:flex;gap:8px">
        <button data-role="stop" type="button" style="padding:8px 13px;border:0;border-radius:6px;background:#ef4444;color:white;cursor:pointer">停止监控</button>
      </div>
    `;
    panel.querySelector('[data-role="stop"]').addEventListener("click", cancel);
    panel.querySelector('[data-role="preferred-region"]').addEventListener(
      "change",
      (event) => setPreferredRegion(event.currentTarget.value),
    );
    document.body.append(panel);
    return panel;
  }

  function renderMonitorPanel() {
    const panel = ensureMonitorPanel();
    const stateLabels = {
      monitoring: "持续监控中",
      submitting: "循环抢购中",
      stopped: "已停止",
      failed: "下单失败",
      success: "订单已创建",
    };
    const left = monitorTargetMs === null
      ? null
      : monitorTargetMs - (Date.now() + monitorClockOffsetMs);
    const stopButton = panel.querySelector('[data-role="stop"]');
    const preferredSelect = panel.querySelector('[data-role="preferred-region"]');
    const isStoppable = ["monitoring", "submitting"].includes(monitorState);

    panel.querySelector('[data-role="title"]').textContent = "腾讯云 38 元抢购";
    panel.querySelector('[data-role="state"]').textContent =
      stateLabels[monitorState] || monitorState;
    panel.querySelector('[data-role="countdown"]').textContent = left === null
      ? "--:--:--"
      : remainingText(left);
    panel.querySelector('[data-role="target"]').textContent = monitorTargetMs === null
      ? `场次：${monitorSession || "-"}`
      : `场次：${monitorSession}（${chinaTimeText(monitorTargetMs)}）`;
    panel.querySelector('[data-role="offset"]').textContent =
      `服务器时差：${monitorClockOffsetMs >= 0 ? "+" : ""}${monitorClockOffsetMs} ms`;
    preferredSelect.value = String(preferredRegionId);
    panel.querySelector('[data-role="regions"]').textContent = `地域顺序：${regionsInPriorityOrder()
      .map((region) => region.name)
      .join(" → ")}`;
    panel.querySelector('[data-role="attempts"]').textContent = orderRequestCount
      ? `抢购进度：第 ${orderRound} 轮，累计 ${orderRequestCount} 次请求`
      : "抢购进度：等待开抢";
    panel.querySelector('[data-role="stock-retries"]').textContent = noStockDetected
      ? `无库存复查：${noStockRetryCount}/6 次`
      : "无库存复查：尚未触发";
    panel.querySelector('[data-role="message"]').textContent = monitorMessage;
    stopButton.disabled = !isStoppable;
    stopButton.textContent = monitorState === "monitoring"
      ? "停止监控"
      : monitorState === "submitting"
        ? "停止抢购"
        : "监控已停止";
    Object.assign(stopButton.style, {
      opacity: isStoppable ? "1" : "0.55",
      cursor: isStoppable ? "pointer" : "not-allowed",
    });
  }

  function beginMonitor(session, targetMs, offset) {
    clearMonitorTimer();
    monitorState = "monitoring";
    monitorTargetMs = targetMs;
    monitorClockOffsetMs = offset;
    monitorSession = session;
    orderRound = 0;
    orderRequestCount = 0;
    noStockRetryCount = 0;
    noStockDetected = false;
    monitorMessage = "保持登录且电脑不休眠；临近开抢请让本页保持前台";
    renderMonitorPanel();
    // 平时降低刷新频率，最后 10 秒再提高到 200ms。
    scheduleMonitorRefresh();
    console.log(
      `[TC38] 持续监控中，距离 ${session} 还有 ${remainingText(
        targetMs - (Date.now() + offset),
      )}；点击右上角“停止监控”或执行 TC38.cancel() 可停止。`,
    );
  }

  function finishMonitor(state, message, removePanel = false) {
    clearMonitorTimer();
    monitorState = state;
    monitorMessage = message;
    if (removePanel) {
      document.querySelector("#tc38-monitor-panel")?.remove();
      return;
    }
    renderMonitorPanel();
  }

  function resolveDianshiApi() {
    const chunkQueue = window.webpackChunk_tencent_qcact_ssr;
    if (!Array.isArray(chunkQueue)) {
      throw new Error("腾讯云页面请求模块尚未加载，请刷新活动页后重试");
    }

    let webpackRequire;
    const chunkId = `tc38_${Date.now()}_${Math.random().toString(16).slice(2)}`;
    chunkQueue.push([
      [chunkId],
      {},
      (runtimeRequire) => {
        webpackRequire = runtimeRequire;
      },
    ]);
    if (typeof webpackRequire !== "function") {
      throw new Error("无法连接腾讯云页面请求模块");
    }

    const candidateIds = ["58357"];
    for (const [moduleId, factory] of Object.entries(webpackRequire.m || {})) {
      if (moduleId === "58357") continue;
      const source = Function.prototype.toString.call(factory);
      if (source.includes("check-available") && source.includes("do-goods")) {
        candidateIds.push(moduleId);
      }
    }

    for (const moduleId of candidateIds) {
      try {
        const module = webpackRequire(moduleId);
        const api = module?.api?.dianshi;
        if (
          typeof api?.checkAvailable?.request === "function"
          && typeof api?.doGoods?.request === "function"
          && typeof api?.getNow?.request === "function"
        ) {
          return api;
        }
      } catch {}
    }
    throw new Error("当前活动页版本中未找到腾讯云官方下单模块");
  }

  function normalizeApiError(error) {
    if (error?.response?.data && typeof error.response.data === "object") {
      return error.response.data;
    }
    if (error && typeof error === "object") {
      return {
        code: error.code ?? "API_ERROR",
        message: error.message || error.msg || JSON.stringify(error).slice(0, 300),
      };
    }
    return { code: "API_ERROR", message: String(error) };
  }

  async function callOfficialApi(request) {
    try {
      return { code: 0, data: await request() };
    } catch (error) {
      return normalizeApiError(error);
    }
  }

  function importCopiedFetch() {
    try {
      dianshiApi = resolveDianshiApi();
      console.log("已连接腾讯云页面的官方请求模块，无需粘贴请求或认证头", {
        activityId: target.activityId,
        goodsActId: target.goodsActId,
        regionPriority: regionsInPriorityOrder().map((region) => region.name),
      });
      const info = status();
      start().catch((error) => {
        console.error("自动抢购任务启动失败", error);
      });
      return info;
    } catch (error) {
      console.error("初始化失败", error);
      throw error;
    }
  }

  function assertApiReady() {
    if (!dianshiApi) {
      throw new Error("请先执行 TC38.importCopiedFetch()");
    }
  }

  function stockState(payload, regionId) {
    const text = JSON.stringify(payload).toLowerCase();
    if (/login|captcha|verify|risk|登录态|登陆态/.test(text)) return "manual";
    if (
      /sold.?out|抢光|售罄/.test(text)
      || [20001, 10002, 1100151].includes(Number(payload?.code))
    ) {
      return "sold-out";
    }
    if (![0, "0"].includes(payload?.code)) return "unavailable";

    const records = Array.isArray(payload?.data) ? payload.data : [payload?.data];
    for (const record of records) {
      const quota = record?.quota?.[String(regionId)]?.[target.goodsType];
      if (quota && "available" in quota) {
        return Number(quota.available) > 0 ? "available" : "unavailable";
      }
      for (const key of [
        "user_available",
        "userAvailable",
        "available",
        "canBuy",
        "enable",
      ]) {
        if (record && key in record) {
          return Boolean(record[key]) ? "available" : "unavailable";
        }
      }
    }
    return "unknown";
  }

  async function dryRun() {
    assertApiReady();
    const results = [];
    for (const region of regionsInPriorityOrder()) {
      const payload = await callOfficialApi(
        () => dianshiApi.checkAvailable.request({
          activityId: target.activityId,
          goods: [{ act_id: target.goodsActId, region_id: [region.id] }],
          isPreview: false,
        }),
      );
      results.push({
        region: region.name,
        code: payload?.code,
        state: stockState(payload, region.id),
        message: payload?.message || payload?.msg || "",
      });
    }
    console.table(results);
    return results;
  }

  function buildOrder(region) {
    const goodsParam = structuredClone(target.goodsParam);
    Object.assign(goodsParam, {
      area: 1,
      goodsNum: 1,
      regionId: region.id,
      type: target.goodsType,
    });
    const body = {
      activity_id: target.activityId,
      goods: [{
        act_id: target.goodsActId,
        type: target.outerType,
        goods_param: goodsParam,
        page_from: "act_buy",
      }],
      preview: 0,
      agent_channel: {
        fromChannel: "",
        fromSales: "",
        isAgentClient: false,
        fromUrl: location.href,
      },
    };
    return body;
  }

  function orderState(payload, text) {
    const lower = text.toLowerCase();
    const data = payload?.data;
    if (
      [0, "0"].includes(payload?.code)
      && data
      && (
        "deal_names" in data
        || "big_deal_no" in data
        || "seqId" in data
        || Object.values(data).some(
          (value) => typeof value === "string" && value.includes("order/check"),
        )
      )
    ) {
      return "pending-payment";
    }
    if (
      /sold.?out|抢光|售罄/.test(lower)
      || [20001, 10002, 1100151].includes(Number(payload?.code))
    ) {
      return "sold-out";
    }
    if (/not.?started|未开始/.test(lower)) return "not-started";
    if (/login|captcha|verify|risk|登录态|登陆态/.test(lower)) return "manual";
    if (
      /too many|rate.?limit|频率过快|访问频率/.test(lower)
      || [408, 429, 1100110].includes(Number(payload?.code))
    ) {
      return "rate-limited";
    }
    return "unknown";
  }

  function paymentUrlFromPayload(payload) {
    const fallback = "https://buy.cloud.tencent.com/order/check";
    const data = payload?.data;
    if (!data || typeof data !== "object") return fallback;

    const candidates = [
      data.url,
      data.redirectUrl,
      data.redirect_url,
      data.orderUrl,
      data.order_url,
    ];
    for (const candidate of candidates) {
      if (typeof candidate !== "string" || !candidate) continue;
      try {
        const url = new URL(candidate, fallback);
        if (
          url.hostname === "buy.cloud.tencent.com"
          && url.pathname.startsWith("/order/")
        ) {
          return url.href;
        }
      } catch {}
    }

    const url = new URL(fallback);
    const bigDealId = Array.isArray(data.big_deal_no)
      ? data.big_deal_no.join("|")
      : data.big_deal_no;
    const dealName = Array.isArray(data.deal_names)
      ? data.deal_names.join("|")
      : data.deal_names;
    if (bigDealId) url.searchParams.set("bigDealId", bigDealId);
    if (!bigDealId && dealName) url.searchParams.set("dealName", dealName);
    url.searchParams.set("s_url", location.href);
    url.searchParams.set("serviceFrom", "activity");
    return url.href;
  }

  function showPaymentLink(paymentUrl, regionName) {
    clearMonitorTimer();
    document.querySelector("#tc38-monitor-panel")?.remove();
    document.querySelector("#tc38-payment-link")?.remove();

    const panel = document.createElement("div");
    panel.id = "tc38-payment-link";
    Object.assign(panel.style, {
      position: "fixed",
      zIndex: "2147483647",
      top: "20px",
      right: "20px",
      width: "320px",
      padding: "18px",
      border: "1px solid #57a564",
      borderRadius: "10px",
      background: "#f2fff4",
      boxShadow: "0 8px 28px rgba(0, 0, 0, 0.22)",
      color: "#183b20",
      font: "14px/1.5 -apple-system, BlinkMacSystemFont, Segoe UI, sans-serif",
    });

    const title = document.createElement("strong");
    title.textContent = `订单已创建（${regionName}）`;
    title.style.display = "block";
    title.style.marginBottom = "12px";

    const link = document.createElement("a");
    link.href = paymentUrl;
    link.target = "_blank";
    link.rel = "noopener noreferrer";
    link.textContent = "打开订单支付页";
    Object.assign(link.style, {
      display: "inline-block",
      padding: "9px 16px",
      borderRadius: "6px",
      background: "#006eff",
      color: "#fff",
      fontWeight: "600",
      textDecoration: "none",
    });

    const close = document.createElement("button");
    close.type = "button";
    close.textContent = "关闭";
    close.addEventListener("click", () => panel.remove());
    Object.assign(close.style, {
      marginLeft: "10px",
      padding: "8px 12px",
      border: "1px solid #aab4c3",
      borderRadius: "6px",
      background: "#fff",
      cursor: "pointer",
    });

    panel.append(title, link, close);
    document.body.append(panel);
  }

  async function fire(generation = runGeneration) {
    assertApiReady();

    orderRound = 0;
    orderRequestCount = 0;
    noStockRetryCount = 0;
    noStockDetected = false;
    while (generation === runGeneration) {
      orderRound++;
      let allRegionsSoldOut = true;
      for (const region of regionsInPriorityOrder()) {
        if (generation !== runGeneration) return { state: "cancelled" };

        orderRequestCount++;
        monitorMessage = `第 ${orderRound} 轮：正在尝试 ${region.name}（累计 ${orderRequestCount} 次）`;
        if (document.querySelector("#tc38-monitor-panel")) renderMonitorPanel();

        const order = buildOrder(region);
        const payload = await callOfficialApi(
          () => dianshiApi.doGoods.request({
            activityId: order.activity_id,
            goods: order.goods,
            isPreview: false,
            agentChannel: order.agent_channel,
            business: order.business,
          }),
        );
        const text = JSON.stringify(payload);

        const state = orderState(payload, text);
        console.log("下单返回", {
          region: region.name,
          round: orderRound,
          requestCount: orderRequestCount,
          code: payload?.code,
          state,
          message: payload?.message || payload?.msg || "",
        });

        if (state === "pending-payment") {
          const paymentUrl = paymentUrlFromPayload(payload);
          showPaymentLink(paymentUrl, region.name);
          console.log("订单已创建，点击下面的 URL 打开支付页：");
          console.log(paymentUrl);
          return { state, region: region.name, paymentUrl };
        }
        if (generation !== runGeneration) return { state: "cancelled" };
        if (noStockDetected) {
          if (state === "sold-out") {
            noStockRetryCount++;
            if (noStockRetryCount >= 6) {
              monitorMessage = "所有地域均无库存，额外复查 6 次后结束当前场次";
              if (document.querySelector("#tc38-monitor-panel")) renderMonitorPanel();
              console.warn("[TC38] 所有地域均无库存，额外复查 6 次后结束当前场次");
              return {
                state: "sold-out",
                noStockRetryCount,
                requestCount: orderRequestCount,
              };
            }
          } else {
            noStockDetected = false;
            noStockRetryCount = 0;
          }
        }
        if (state !== "sold-out") {
          allRegionsSoldOut = false;
        }
        if (["manual", "rate-limited", "unknown"].includes(state)) {
          console.warn("本次未确认无库存，将继续下一地域和下一轮", {
            region: region.name,
            state,
            code: payload?.code,
            message: payload?.message || payload?.msg || "",
          });
        }
      }

      if (generation !== runGeneration) return { state: "cancelled" };
      if (allRegionsSoldOut && !noStockDetected) {
        noStockDetected = true;
        noStockRetryCount = 0;
        monitorMessage =
          `检测到所有地域无库存，${CFG.retryRoundIntervalMs}ms 后开始额外复查 6 次`;
      } else if (noStockDetected) {
        monitorMessage = `所有地域仍无库存，已复查 ${noStockRetryCount}/6 次`;
      } else {
        monitorMessage = `第 ${orderRound} 轮未创建订单，${CFG.retryRoundIntervalMs}ms 后继续`;
      }
      if (document.querySelector("#tc38-monitor-panel")) renderMonitorPanel();
      await sleep(CFG.retryRoundIntervalMs);
    }
    return { state: "cancelled" };
  }

  async function fireNow() {
    assertApiReady();
    const generation = ++runGeneration;
    scheduledFor = null;
    clearMonitorTimer();
    monitorState = "submitting";
    monitorTargetMs = null;
    monitorSession = "立即下单";
    monitorMessage = "正在立即循环尝试创建订单";
    renderMonitorPanel();

    const result = await fire(generation);
    if (result.state === "pending-payment") {
      finishMonitor("success", "订单已创建，请尽快支付", true);
    } else if (result.state !== "cancelled") {
      finishMonitor("failed", "抢购已停止，具体原因请查看 Console");
    }
    return result;
  }

  async function serverOffset() {
    assertApiReady();
    const offsets = [];
    for (let index = 0; index < 3; index++) {
      const before = Date.now();
      const nowData = await dianshiApi.getNow.request();
      const after = Date.now();
      let server = Number(nowData?.nowTime ?? nowData);
      if (server > 0 && server < 10_000_000_000) server *= 1000;
      if (Number.isFinite(server)) {
        offsets.push(server - Math.round((before + after) / 2));
      }
      if (index < 2) await sleep(80);
    }
    if (!offsets.length) throw new Error("服务器时间同步失败");
    offsets.sort((left, right) => left - right);
    return offsets[Math.floor(offsets.length / 2)];
  }

  function nextSessionChina(serverNowMs) {
    const china = new Date(serverNowMs + 8 * 3_600_000);
    const ten = Date.UTC(
      china.getUTCFullYear(),
      china.getUTCMonth(),
      china.getUTCDate(),
      10 - 8,
      0,
      0,
      0,
    );
    const fifteen = Date.UTC(
      china.getUTCFullYear(),
      china.getUTCMonth(),
      china.getUTCDate(),
      15 - 8,
      0,
      0,
      0,
    );

    if (serverNowMs <= ten) {
      return { targetMs: ten, label: "今天 10:00" };
    }
    if (serverNowMs <= fifteen) {
      return { targetMs: fifteen, label: "今天 15:00" };
    }
    return {
      targetMs: ten + 24 * 3_600_000,
      label: "明天 10:00",
    };
  }

  async function start() {
    assertApiReady();

    const generation = ++runGeneration;
    let offset = await serverOffset();
    if (generation !== runGeneration) return { state: "cancelled" };

    const nowServer = Date.now() + offset;
    const session = nextSessionChina(nowServer);
    const { targetMs } = session;
    const waitMs = targetMs - nowServer;
    let finalClockSyncPending = waitMs > CFG.finalClockSyncLeadMs;
    scheduledFor = session.label;

    beginMonitor(session.label, targetMs, offset);

    console.log(`已自动选择 ${session.label} 场，等待下单`, {
      targetChinaTime: chinaTimeText(targetMs),
      clockOffsetMs: offset,
      waitMs,
    });

    while (true) {
      if (generation !== runGeneration) return { state: "cancelled" };
      const left = targetMs - (Date.now() + offset);
      if (finalClockSyncPending && left <= CFG.finalClockSyncLeadMs) {
        finalClockSyncPending = false;
        try {
          const refreshedOffset = await serverOffset();
          if (generation !== runGeneration) return { state: "cancelled" };
          offset = refreshedOffset;
          monitorClockOffsetMs = refreshedOffset;
          monitorMessage = "开抢前 60 秒已重新同步腾讯云服务器时间";
          renderMonitorPanel();
          console.log("[TC38] 临场服务器时间同步完成", {
            clockOffsetMs: refreshedOffset,
          });
          continue;
        } catch (error) {
          monitorMessage = "临场校时失败，继续使用上次服务器时差";
          renderMonitorPanel();
          console.warn("[TC38] 临场服务器时间同步失败", error);
        }
      }
      if (left <= 20) break;
      await sleep(Math.min(200, Math.max(1, left - 10)));
    }
    while (Date.now() + offset < targetMs) {}
    if (generation !== runGeneration) return { state: "cancelled" };

    clearMonitorTimer();
    monitorState = "submitting";
    monitorMessage = "已到开抢时间，正在发送创建订单请求";
    renderMonitorPanel();

    const result = await fire(generation);
    scheduledFor = null;
    if (result.state === "pending-payment") {
      finishMonitor("success", "订单已创建，请尽快支付", true);
    } else if (result.state === "sold-out") {
      const finishedHour =
        new Date(targetMs + 8 * 3_600_000).getUTCHours();
      const nextSessionText = finishedHour === 10
        ? "今天 15:00"
        : "明天 10:00";
      monitorState = "monitoring";
      monitorMessage =
        `${finishedHour}:00 场已无库存，正在自动切换到 ${nextSessionText}`;
      renderMonitorPanel();
      console.log(
        `[TC38] ${finishedHour}:00 场已结束，自动继续监控 ${nextSessionText}`,
      );
      return start();
    } else if (result.state !== "cancelled") {
      finishMonitor("failed", "未创建订单，具体原因请查看 Console");
    }
    return result;
  }

  function cancel() {
    if (!["monitoring", "submitting"].includes(monitorState) && !scheduledFor) {
      console.log("[TC38] 当前没有正在等待的监控任务");
      return false;
    }

    const requestWasInFlight = monitorState === "submitting";
    runGeneration++;
    scheduledFor = null;
    clearMonitorTimer();
    monitorState = "stopped";
    monitorTargetMs = null;
    monitorMessage = requestWasInFlight
      ? "已停止后续重试；已发出的当前请求无法撤回"
      : "已停止，不会在开抢时间发送下单请求";
    renderMonitorPanel();
    console.log("[TC38] 已停止监控及后续重试");
    return true;
  }

  function status() {
    const remaining = monitorTargetMs === null || monitorState !== "monitoring"
      ? null
      : remainingText(
        monitorTargetMs - (Date.now() + monitorClockOffsetMs),
      );
    const info = {
      activityId: target.activityId,
      goodsActId: target.goodsActId,
      priceYuan: target.priceFen / 100,
      goodsType: target.goodsType,
      officialApiReady: Boolean(dianshiApi),
      scheduledFor,
      monitorState,
      remaining,
      orderRound,
      orderRequestCount,
      noStockDetected,
      noStockRetryCount,
      retryRoundIntervalMs: CFG.retryRoundIntervalMs,
      stopCommand: "TC38.cancel()",
      regions: regionsInPriorityOrder()
        .map((region) => `${region.name}(${region.id})`)
        .join(" → "),
    };
    return info;
  }

  window.TC38 = {
    importCopiedFetch,
    dryRun,
    start,
    fireNow,
    setPreferredRegion,
    cancel,
    status,
  };
  console.log("TC38 已加载，正在自动初始化并启动");
  queueMicrotask(() => {
    try {
      importCopiedFetch();
    } catch {}
  });
})();