xiaoshu-app/scripts/smoke-admin-functions.mjs

#!/usr/bin/env node

import { randomBytes } from 'node:crypto';
import { readFile } from 'node:fs/promises';

const APP_ID = process.env.XIAOSHU_PARSE_APP_ID || '7pIbDBJmKx_main';
const MASTER_KEY = process.env.XIAOSHU_MASTER_KEY || '';
const PARSE_URL = (process.env.XIAOSHU_PARSE_URL || 'https://server.xiaoshu.pro/parse').replace(/\/$/, '');
const FUNCTION_URL = (process.env.XIAOSHU_FUNCTION_URL || 'https://server.xiaoshu.pro/api/functions').replace(/\/$/, '');

if (!MASTER_KEY) throw new Error('缺少 XIAOSHU_MASTER_KEY');

async function jsonRequest(url, init = {}, master = false) {
  const response = await fetch(url, {
    ...init,
    headers: {
      'X-Parse-Application-Id': APP_ID,
      ...(master ? { 'X-Parse-Master-Key': MASTER_KEY } : {}),
      'Content-Type': 'application/json',
      ...(init.headers || {}),
    },
  });
  const payload = await response.json().catch(() => ({}));
  if (!response.ok) {
    const detail = payload.message || payload.error || payload;
    throw new Error(`${response.status}: ${typeof detail === 'string' ? detail : JSON.stringify(detail)}`);
  }
  return payload;
}

async function callFunction(path, token, params) {
  const payload = await jsonRequest(`${FUNCTION_URL}/${path}`, {
    method: 'POST',
    body: JSON.stringify({ token, params }),
  });
  if (!payload.success) throw new Error(payload.message || `${path} 返回失败`);
  return payload.data;
}

async function callFunctionError(path, token, params, expectedStatus) {
  const response = await fetch(`${FUNCTION_URL}/${path}`, {
    method: 'POST',
    headers: { 'X-Parse-Application-Id': APP_ID, 'Content-Type': 'application/json' },
    body: JSON.stringify({ token, params }),
  });
  const payload = await response.json().catch(() => ({}));
  if (response.status !== expectedStatus || payload.success !== false) throw new Error(`${path} 期望 ${expectedStatus} 失败，实际 ${response.status}: ${payload.message || payload.error || ''}`);
  return payload;
}

async function callLegacyFunction(token, params, expectedStatus = 200) {
  const response = await fetch(`${FUNCTION_URL}/xiaoshu/app/gateway`, {
    method: 'POST',
    headers: { 'X-Parse-Application-Id': APP_ID, 'Content-Type': 'application/json' },
    body: JSON.stringify({ ...(token ? { token } : {}), params }),
  });
  const payload = await response.json().catch(() => ({}));
  if (response.status !== expectedStatus) throw new Error(`app gateway ${params.action} 期望 ${expectedStatus}，实际 ${response.status}: ${payload.retmsg || payload.error || ''}`);
  return payload;
}

async function sourceActions() {
  const source = await readFile(new URL('../src/app/core/source-parity.generated.ts', import.meta.url), 'utf8');
  const match = source.match(/export const SOURCE_API_ACTIONS = (\[[\s\S]*?\]) as const;/);
  if (!match) throw new Error('无法读取 SOURCE_API_ACTIONS');
  return JSON.parse(match[1]);
}

let userId = '';
let adminCreatedUserId = '';
let temporaryGroupObjectId = '';
const temporaryNodeObjectIds = [];
const temporarySpecialObjectIds = [];
const temporaryGuestCategoryObjectIds = [];
const temporaryExamClassObjectIds = [];
const temporaryExamPointObjectIds = [];
let temporaryModelObjectId = '';
const temporaryModelFieldObjectIds = [];
let registeredUserId = '';
let memberId = '';
let memberLegacyId = 0;
let teamChildId = '';
let coachId = '';
let coachLegacyId = 0;
let temporaryAppointmentId = '';
let temporaryAppointmentObjectId = '';
let temporaryGuestbookId = '';
let temporaryGuestbookReplyId = '';
let temporaryGuestBarId = '';
let contentHitObjectId = '';
let contentHitOriginal = 0;
const temporaryLessonIds = [];
try {
  const sample = await jsonRequest(`${PARSE_URL}/classes/Company?limit=1&keys=objectId`, {}, true);
  const companyId = sample.results?.[0]?.objectId;
  if (!companyId) throw new Error('没有可用于帐套隔离测试的 Company');
  const company = { __type: 'Pointer', className: 'Company', objectId: companyId };

  const username = `codex_admin_smoke_${Date.now()}`;
  const password = randomBytes(24).toString('base64url');
  const created = await jsonRequest(`${PARSE_URL}/users`, {
    method: 'POST',
    body: JSON.stringify({ username, password, isAdmin: true, roles: ['admin'], company }),
  }, true);
  userId = created.objectId;

  const login = await jsonRequest(`${PARSE_URL}/login`, {
    method: 'POST',
    body: JSON.stringify({ username, password }),
  });
  if (!login.sessionToken) throw new Error('临时管理员登录未返回 sessionToken');

  const registeredUsername = `codex_register_smoke_${Date.now()}`;
  const registered = await callLegacyFunction('', { action: 'user_register', name: registeredUsername, passwd: 'Ab1234' });
  registeredUserId = String(registered.result?.objectId || '');
  const registeredLegacyId = Number(registered.result?.userId);
  if (!registeredUserId || !registeredLegacyId || !registered.result?.sessionToken || Number(registered.result?.groupId) !== 1 || Number(registered.addon?.parentUserId) !== 0) throw new Error(`新用户注册基础字段异常：${JSON.stringify(registered)}`);
  const registeredInfo = await callLegacyFunction(registered.result.sessionToken, { action: 'user_get', uid: registeredLegacyId });
  if (Number(registeredInfo.result?.userId) !== registeredLegacyId || Number(registeredInfo.result?.groupId) !== 1 || Number(registeredInfo.addon?.Purse) !== 0 || Number(registeredInfo.addon?.UserPoint) !== 0) throw new Error('新用户注册后自查异常');
  const registeredByName = await callLegacyFunction('', { action: 'user_info_name', uname: registeredUsername });
  if (registeredByName.result?.objectId !== registeredUserId) throw new Error('新用户用户名查重异常');
  await jsonRequest(`${PARSE_URL}/users/${registeredUserId}`, { method: 'DELETE' }, true);
  registeredUserId = '';

  const memberUsername = `codex_member_smoke_${Date.now()}`;
  const memberPassword = randomBytes(24).toString('base64url');
  memberLegacyId = 900000000 + Math.floor(Date.now() / 1000) % 90000000;
  const member = await jsonRequest(`${PARSE_URL}/users`, {
    method: 'POST',
    body: JSON.stringify({ username: memberUsername, password: memberPassword, legacyUserId: memberLegacyId, legacyGroupId: 1, legacyUserData: { UserID: memberLegacyId, UserName: memberUsername, HoneyName: '冒烟学员', GroupID: 1, ParentUserID: 0, VIP: 2, Purse: 2, SilverCoin: 2, UserExp: 2, UserPoint: 2 }, company }),
  }, true);
  memberId = member.objectId;
  const childLegacyId = memberLegacyId + 2;
  const child = await jsonRequest(`${PARSE_URL}/users`, {
    method: 'POST',
    body: JSON.stringify({ username: `codex_team_child_${Date.now()}`, password: randomBytes(24).toString('base64url'), legacyUserId: childLegacyId, legacyGroupId: 3, legacyUserData: { UserID: childLegacyId, UserName: `team_child_${childLegacyId}`, HoneyName: '冒烟团队成员', GroupID: 3, ParentUserID: memberLegacyId, VIP: 3, UserExp: 5, UserPwd: 'must-not-leak' }, company }),
  }, true);
  teamChildId = child.objectId;
  const coachUsername = `codex_coach_smoke_${Date.now()}`;
  const coachPassword = randomBytes(24).toString('base64url');
  coachLegacyId = memberLegacyId + 1;
  const coach = await jsonRequest(`${PARSE_URL}/users`, {
    method: 'POST',
    body: JSON.stringify({ username: coachUsername, password: coachPassword, legacyUserId: coachLegacyId, legacyGroupId: 3, company }),
  }, true);
  coachId = coach.objectId;
  for (const lessonType of [1, 2, 3]) {
    const lesson = await jsonRequest(`${PARSE_URL}/classes/LessonRecord`, {
      method: 'POST',
      body: JSON.stringify({ company, sourceKey: `cloud:smoke-lesson:${coachLegacyId}:${lessonType}`, jsmz: String(coachLegacyId), kclx: String(lessonType) }),
    }, true);
    temporaryLessonIds.push(lesson.objectId);
  }
  const memberLogin = await jsonRequest(`${PARSE_URL}/login`, {
    method: 'POST',
    body: JSON.stringify({ username: memberUsername, password: memberPassword }),
  });
  const coachLogin = await jsonRequest(`${PARSE_URL}/login`, {
    method: 'POST',
    body: JSON.stringify({ username: coachUsername, password: coachPassword }),
  });
  const feedbackModel = { UserID: memberLegacyId, Title: '冒烟学员 反馈的意见', TContent: '2026-08-19 请假一天', Cateid: 22 };
  const feedback = await callLegacyFunction(memberLogin.sessionToken, { action: 'guestbook_add', model: JSON.stringify(feedbackModel) });
  temporaryGuestbookId = String(feedback.result?.objectId || '');
  if (!temporaryGuestbookId || Number(feedback.result?.UserID) !== memberLegacyId || feedback.result?.Title !== feedbackModel.Title || feedback.result?.TContent !== feedbackModel.TContent || Number(feedback.result?.Cateid) !== 22) throw new Error(`旧版 model 留言写入异常：${JSON.stringify(feedback)}`);
  await callLegacyFunction(memberLogin.sessionToken, { action: 'guestbook_add', model: JSON.stringify({ ...feedbackModel, UserID: coachLegacyId }) }, 403);
  const profileModel = { honeyName: '冒烟资料更新', trueName: '测试学员', userFace: '/UploadFiles/smoke-avatar.png', sex: '女', birthday: '2000-01-02', mobile: '13800138000', Email: `${memberUsername}@example.test`, seturl: '/member/smoke', Position: '词汇小英雄' };
  const updatedProfile = await callLegacyFunction(memberLogin.sessionToken, { action: 'user_update', uid: memberLegacyId, mu: JSON.stringify(profileModel), inviCode: '' });
  if (updatedProfile.result?.honeyName !== profileModel.honeyName || updatedProfile.result?.userFace !== profileModel.userFace || updatedProfile.result?.email !== profileModel.Email || updatedProfile.result?.seturl !== profileModel.seturl) throw new Error(`旧版 mu 用户资料更新异常：${JSON.stringify(updatedProfile)}`);
  await callLegacyFunction(memberLogin.sessionToken, { action: 'user_update', uid: coachLegacyId, mu: JSON.stringify({ honeyName: '越权' }) }, 403);
  await callLegacyFunction(memberLogin.sessionToken, { action: 'user_update_pwd', uid: memberLegacyId, vcode: '123456', newPass: 'Ab1234', reNewPass: 'Ab1234' }, 501);
  await callLegacyFunction(memberLogin.sessionToken, { action: 'user_update_pwdall', uid: memberLegacyId, login: 'Ab1234', pay: '123456' }, 501);
  const createdAppointment = await callLegacyFunction(login.sessionToken, { action: 'content_add', content: JSON.stringify({ ModelID: 54, nodeId: 29, inputer: coachUsername, status: 99, title: memberUsername }), addon: JSON.stringify({ szyh: memberLegacyId, kcid: 16, dslx: 1, dszt: 0, pl: coachLegacyId, fxpl: coachLegacyId, sdsd: '19:00' }) });
  temporaryAppointmentId = String(createdAppointment.result);
  const appointmentSourceKey = `cloud:content_add:${memberLegacyId}:${temporaryAppointmentId}`;
  const appointmentWhere = encodeURIComponent(JSON.stringify({ sourceKey: appointmentSourceKey }));
  const appointmentRows = await jsonRequest(`${PARSE_URL}/classes/CourseAppointment?where=${appointmentWhere}&limit=1`, {}, true);
  temporaryAppointmentObjectId = appointmentRows.results?.[0]?.objectId || '';
  if (!temporaryAppointmentObjectId) throw new Error('临时预约副表创建失败');
  const appointmentCommonRows = await jsonRequest(`${PARSE_URL}/classes/CommonModel?where=${appointmentWhere}&limit=1`, {}, true);
  const temporaryAppointmentCommonObjectId = String(appointmentCommonRows.results?.[0]?.objectId || '');
  if (!temporaryAppointmentCommonObjectId) throw new Error('临时预约主内容创建失败');

  const meta = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'meta' });
  if (meta.identity?.objectId !== userId || !meta.cloudFunctions) throw new Error('管理员 meta 校验失败');

  const dashboard = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'dashboard' });
  if (!Array.isArray(dashboard.metrics) || dashboard.metrics.length !== 8) throw new Error('dashboard 指标校验失败');

  const catalog = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'catalog' });
  if (!Array.isArray(catalog.resources) || catalog.resources.length < 90 || catalog.resources.some((item) => ['_Session', 'Function'].includes(item.className))) throw new Error('后台规范化类目录校验失败');

  const managedUsername = `codex_admin_created_${Date.now()}`;
  const managedPassword = randomBytes(24).toString('base64url');
  const managed = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'createUser', username: managedUsername, password: managedPassword, displayName: '后台开户冒烟', mobile: '13800138001', isAdmin: true, roles: ['admin'] });
  adminCreatedUserId = String(managed.objectId || '');
  if (!adminCreatedUserId || !Number(managed.userId) || Number(managed.groupId) !== 1 || managed.isAdmin === true || managed.roles?.includes?.('admin') || managed.sessionToken) throw new Error(`管理员开户响应异常：${JSON.stringify(managed)}`);
  const managedStored = await jsonRequest(`${PARSE_URL}/users/${adminCreatedUserId}`, {}, true);
  if (managedStored.username !== managedUsername || managedStored.isAdmin === true || managedStored.roles?.includes?.('admin') || Number(managedStored.legacyUserId) !== Number(managed.userId) || Number(managedStored.legacyGroupId) !== 1 || Number(managedStored.legacyUserData?.UserID) !== Number(managed.userId) || Number(managedStored.legacyUserData?.Purse) !== 0) throw new Error('管理员开户持久化约束校验失败');
  const managedLogin = await jsonRequest(`${PARSE_URL}/login`, { method: 'POST', body: JSON.stringify({ username: managedUsername, password: managedPassword }) });
  if (!managedLogin.sessionToken) throw new Error('后台开户用户登录失败');
  const locked = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'userBatch', className: '_User', action: 'lock', objectIds: [adminCreatedUserId], reason: '云函数冒烟' });
  if (locked.updated !== 1 || locked.results?.[0]?.isDisabled !== true || Number(locked.results?.[0]?.legacyUserData?.State) !== 0 || Number(locked.revokedSessions) < 1) throw new Error(`用户停用与会话撤销异常：${JSON.stringify(locked)}`);
  await callLegacyFunction('', { action: 'user_login_passwd', name: managedUsername, passwd: managedPassword }, 403);
  const unlocked = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'userBatch', className: '_User', action: 'unlock', objectIds: [adminCreatedUserId], reason: '恢复冒烟用户' });
  if (unlocked.updated !== 1 || unlocked.results?.[0]?.isDisabled !== false || Number(unlocked.results?.[0]?.legacyUserData?.State) !== 1) throw new Error(`用户解锁异常：${JSON.stringify(unlocked)}`);
  const temporaryGroup = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveGroup', className: 'Group', fields: { groupName: '云函数冒烟临时组', description: '验证帐套内原子组编号', parentGroupId: 0, regSelect: false } });
  temporaryGroupObjectId = String(temporaryGroup.objectId || '');
  const temporaryGroupNumber = Number(temporaryGroup.groupId);
  if (!temporaryGroupObjectId || !temporaryGroupNumber) throw new Error('临时用户组创建失败');
  const moved = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'userBatch', className: '_User', action: 'move', objectIds: [adminCreatedUserId], groupId: temporaryGroupNumber });
  if (moved.updated !== 1 || Number(moved.results?.[0]?.legacyGroupId) !== temporaryGroupNumber || Number(moved.results?.[0]?.legacyUserData?.GroupID) !== temporaryGroupNumber) throw new Error(`用户组同步异常：${JSON.stringify(moved)}`);
  const groupDeleteBlocked = await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'Group', objectId: temporaryGroupObjectId }, 409);
  if (!String(groupDeleteBlocked.message).includes('仍有用户')) throw new Error('用户组引用删除保护未返回明确原因');
  const managedAppLogin = await callLegacyFunction('', { action: 'user_login_passwd', name: managedUsername, passwd: managedPassword });
  if (!managedAppLogin.result?.sessionToken || Number(managedAppLogin.addon?.State) !== 1) throw new Error('解锁后旧版登录异常');
  await jsonRequest(`${PARSE_URL}/users/${adminCreatedUserId}`, { method: 'DELETE' }, true);
  adminCreatedUserId = '';
  const deletedGroup = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'Group', objectId: temporaryGroupObjectId });
  if (deletedGroup.objectId !== temporaryGroupObjectId) throw new Error('无引用用户组删除失败');
  temporaryGroupObjectId = '';

  const schema = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'schema', className: 'CourseAppointment' });
  if (schema.className !== 'CourseAppointment' || !Array.isArray(schema.fields)) throw new Error('schema 校验失败');
  const contentSchema = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'schema', className: 'CommonModel' });
  const contentFieldMap = Object.fromEntries((contentSchema.fields || []).map((field) => [field.name, field]));
  if (contentSchema.creatable !== false || contentFieldMap.status?.writable !== false || contentFieldMap.modelId?.writable !== false || contentFieldMap.itemId?.writable !== false || contentFieldMap.nodeId?.writable !== false) throw new Error('内容结构字段未从通用创建/编辑中隔离');
  const nodeSchema = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'schema', className: 'Node' });
  const nodeFieldMap = Object.fromEntries((nodeSchema.fields || []).map((field) => [field.name, field]));
  if (nodeFieldMap.nodeId?.writable !== false || nodeFieldMap.parentId?.writable !== false || nodeFieldMap.depth?.writable !== false || nodeFieldMap.zstatus?.writable !== false || nodeFieldMap.sourceKey?.writable !== false) throw new Error('栏目结构字段未从通用编辑中隔离');
  await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'save', className: 'Node', fields: { nodeName: '禁止通用新增' } }, 400);
  const nodeSuffix = Date.now().toString(36);
  const rootNode = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveNode', className: 'Node', parentId: 0, fields: { nodeName: `云函数冒烟栏目-${nodeSuffix}`, nodeDir: `smoke-${nodeSuffix}`, nodeType: 1, contentModel: '54' } });
  temporaryNodeObjectIds.push(String(rootNode.objectId || ''));
  const rootNodeId = Number(rootNode.nodeId);
  if (!temporaryNodeObjectIds[0] || !rootNodeId || Number(rootNode.parentId) !== 0 || Number(rootNode.depth) !== 1 || rootNode.sourceKey !== `[["NodeID",${rootNodeId}]]`) throw new Error(`栏目原子创建异常：${JSON.stringify(rootNode)}`);
  const childNode = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveNode', className: 'Node', parentId: rootNodeId, fields: { nodeName: `云函数冒烟子栏目-${nodeSuffix}`, nodeDir: `smoke-child-${nodeSuffix}`, nodeType: 1, contentModel: '54' } });
  temporaryNodeObjectIds.push(String(childNode.objectId || ''));
  const childNodeId = Number(childNode.nodeId);
  if (!temporaryNodeObjectIds[1] || !childNodeId || Number(childNode.parentId) !== rootNodeId || Number(childNode.depth) !== 2) throw new Error(`子栏目层级创建异常：${JSON.stringify(childNode)}`);
  const duplicateNode = await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveNode', className: 'Node', parentId: 0, fields: { nodeName: `云函数冒烟栏目-${nodeSuffix}`, nodeDir: `another-${nodeSuffix}` } }, 409);
  if (!String(duplicateNode.message).includes('不能重复')) throw new Error('栏目同级重名保护未返回明确原因');
  const cycleNode = await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveNode', className: 'Node', objectId: rootNode.objectId, parentId: childNodeId, fields: { ...rootNode, nodeName: rootNode.nodeName, nodeDir: rootNode.nodeDir } }, 409);
  if (!String(cycleNode.message).includes('自身或其下级')) throw new Error('栏目层级循环保护未返回明确原因');
  const movedNode = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'nodeBatch', className: 'Node', action: 'move', objectIds: [childNode.objectId], parentId: 0 });
  if (movedNode.updated !== 1 || Number(movedNode.results?.[0]?.parentId) !== 0) throw new Error('栏目批量迁移失败');
  const recycledNode = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'nodeBatch', className: 'Node', action: 'recycle', objectIds: [rootNode.objectId] });
  if (Number(recycledNode.results?.[0]?.zstatus) !== -2) throw new Error('栏目回收站状态更新失败');
  const recoveredNode = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'nodeBatch', className: 'Node', action: 'recover', objectIds: [rootNode.objectId] });
  if (Number(recoveredNode.results?.[0]?.zstatus) !== 99) throw new Error('栏目回收站恢复失败');
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'nodeBatch', className: 'Node', action: 'purge', objectIds: [childNode.objectId] });
  temporaryNodeObjectIds.pop();
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'nodeBatch', className: 'Node', action: 'purge', objectIds: [rootNode.objectId] });
  temporaryNodeObjectIds.pop();
  const specialSuffix = Date.now().toString(36);
  const rootSpecial = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveSpecial', className: 'Special', pid: 0, fields: { specName: `云函数冒烟专题-${specialSuffix}`, specDir: `special-${specialSuffix}`, specCate: 0, specDesc: '专题生命周期验证' } });
  temporarySpecialObjectIds.push(String(rootSpecial.objectId || ''));
  const rootSpecId = Number(rootSpecial.specId);
  if (!temporarySpecialObjectIds[0] || !rootSpecId || Number(rootSpecial.pid) !== 0 || rootSpecial.sourceKey !== `[["SpecID",${rootSpecId}]]`) throw new Error(`专题原子创建异常：${JSON.stringify(rootSpecial)}`);
  const childSpecial = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveSpecial', className: 'Special', pid: rootSpecId, fields: { specName: `云函数冒烟子专题-${specialSuffix}`, specDir: `special-child-${specialSuffix}` } });
  temporarySpecialObjectIds.push(String(childSpecial.objectId || ''));
  const childSpecId = Number(childSpecial.specId);
  if (!temporarySpecialObjectIds[1] || !childSpecId || Number(childSpecial.pid) !== rootSpecId) throw new Error(`子专题创建异常：${JSON.stringify(childSpecial)}`);
  await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveSpecial', className: 'Special', pid: 0, fields: { specName: rootSpecial.specName, specDir: `special-other-${specialSuffix}` } }, 409);
  await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveSpecial', className: 'Special', objectId: rootSpecial.objectId, pid: childSpecId, fields: { ...rootSpecial, specName: rootSpecial.specName, specDir: rootSpecial.specDir } }, 409);
  const specialDeleteBlocked = await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'Special', objectId: rootSpecial.objectId }, 409);
  if (!String(specialDeleteBlocked.message).includes('下级专题')) throw new Error('专题子级引用删除保护未返回明确原因');
  const movedSpecial = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'specialBatch', className: 'Special', action: 'move', objectIds: [childSpecial.objectId], pid: 0 });
  if (movedSpecial.updated !== 1 || Number(movedSpecial.results?.[0]?.pid) !== 0) throw new Error('专题批量迁移失败');
  const mergeBlocked = await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'specialBatch', className: 'Special', action: 'merge', objectIds: [childSpecial.objectId], targetId: rootSpecId }, 501);
  if (!String(mergeBlocked.message).includes('specialId')) throw new Error('专题合并数据阻塞未返回明确原因');
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'Special', objectId: childSpecial.objectId });
  temporarySpecialObjectIds.pop();
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'Special', objectId: rootSpecial.objectId });
  temporarySpecialObjectIds.pop();
  const categorySuffix = Date.now().toString(36);
  const rootCategory = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveGuestCategory', className: 'Guestcate', gtype: 1, parentId: 0, fields: { catename: `冒烟贴吧版块-${categorySuffix}`, desc: '分类生命周期验证', needLog: 1 } });
  temporaryGuestCategoryObjectIds.push(String(rootCategory.objectId || ''));
  const rootCateid = Number(rootCategory.cateid);
  if (!temporaryGuestCategoryObjectIds[0] || !rootCateid || Number(rootCategory.gtype) !== 1 || rootCategory.sourceKey !== `[["Cateid",${rootCateid}]]`) throw new Error(`贴吧分类原子创建异常：${JSON.stringify(rootCategory)}`);
  const childCategory = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveGuestCategory', className: 'Guestcate', gtype: 1, parentId: rootCateid, fields: { catename: `冒烟子版块-${categorySuffix}` } });
  temporaryGuestCategoryObjectIds.push(String(childCategory.objectId || ''));
  const childCateid = Number(childCategory.cateid);
  if (!temporaryGuestCategoryObjectIds[1] || !childCateid || Number(childCategory.parentId) !== rootCateid) throw new Error('贴吧子分类创建失败');
  const guestCategory = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveGuestCategory', className: 'Guestcate', gtype: 0, parentId: 0, fields: { catename: `冒烟留言分类-${categorySuffix}`, status: 1 } });
  temporaryGuestCategoryObjectIds.push(String(guestCategory.objectId || ''));
  const barAuthorizationBlocked = await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'barAuthorization', cateId: rootCateid }, 501);
  if (!String(barAuthorizationBlocked.message).includes('ZL_Guest_BarAuth')) throw new Error('贴吧逐用户权限数据阻塞未返回明确原因');
  const barMedalBlocked = await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'barMedal', objectId: 'missing-post' }, 501);
  if (!String(barMedalBlocked.message).includes('ZL_Guest_Medals')) throw new Error('贴吧勋章数据阻塞未返回明确原因');
  const temporaryBar = await jsonRequest(`${PARSE_URL}/classes/GuestBar`, { method: 'POST', body: JSON.stringify({ sourceKey: `cloud:smoke-bar:${categorySuffix}`, company, cateId: rootCateid, pid: 0, title: '后台贴吧工作流冒烟', msgContent: '冒烟正文', status: 0, orderFlag: 0, postFlag: '', cdate: { __type: 'Date', iso: new Date().toISOString() } }) }, true);
  temporaryGuestBarId = String(temporaryBar.objectId || '');
  const barAudited = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'barBatch', className: 'GuestBar', action: 'audit', objectIds: [temporaryGuestBarId] });
  if (Number(barAudited.results?.[0]?.status) !== 99) throw new Error('贴吧帖子审核失败');
  const barElite = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'barBatch', className: 'GuestBar', action: 'elite', objectIds: [temporaryGuestBarId] });
  if (!String(barElite.results?.[0]?.postFlag).includes('Recommend')) throw new Error('贴吧帖子加精失败');
  const barTop = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'barBatch', className: 'GuestBar', action: 'top-global', objectIds: [temporaryGuestBarId] });
  if (Number(barTop.results?.[0]?.orderFlag) !== 2) throw new Error('贴吧帖子全局置顶失败');
  const barMoved = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'barBatch', className: 'GuestBar', action: 'move', objectIds: [temporaryGuestBarId], cateId: childCateid });
  if (Number(barMoved.results?.[0]?.cateId) !== childCateid) throw new Error('贴吧帖子移动版块失败');
  const barRecycled = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'barBatch', className: 'GuestBar', action: 'recycle', objectIds: [temporaryGuestBarId] });
  if (Number(barRecycled.results?.[0]?.status) !== -2) throw new Error('贴吧帖子回收失败');
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'barBatch', className: 'GuestBar', action: 'recover', objectIds: [temporaryGuestBarId] });
  await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveGuestCategory', className: 'Guestcate', gtype: 1, parentId: 0, fields: { catename: rootCategory.catename } }, 409);
  await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveGuestCategory', className: 'Guestcate', objectId: rootCategory.objectId, gtype: 0, parentId: childCateid, fields: { ...rootCategory, catename: rootCategory.catename } }, 409);
  const recommendedCategory = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'guestCategoryBatch', className: 'Guestcate', action: 'recommend', objectIds: [rootCategory.objectId] });
  if (recommendedCategory.results?.[0]?.barInfo !== 'Recommend') throw new Error('贴吧分类推荐失败');
  const categoryDeleteBlocked = await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'Guestcate', objectId: rootCategory.objectId }, 409);
  if (!String(categoryDeleteBlocked.message).includes('引用')) throw new Error('分类子级引用删除保护未返回明确原因');
  await jsonRequest(`${PARSE_URL}/classes/GuestBar/${temporaryGuestBarId}`, { method: 'DELETE' }, true);
  temporaryGuestBarId = '';
  for (const category of [childCategory, rootCategory, guestCategory]) {
    await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'Guestcate', objectId: category.objectId });
    temporaryGuestCategoryObjectIds.splice(temporaryGuestCategoryObjectIds.indexOf(String(category.objectId)), 1);
  }
  const examClassSuffix = Date.now().toString(36);
  const rootExamClass = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveExamClass', className: 'ExamClass', parentId: 0, classType: 1, orderId: 0, fields: { cClassName: `冒烟试题分类-${examClassSuffix}` } });
  temporaryExamClassObjectIds.push(String(rootExamClass.objectId || ''));
  const rootExamClassId = Number(rootExamClass.cId);
  if (!temporaryExamClassObjectIds[0] || !rootExamClassId || rootExamClass.sourceKey !== `[["C_id",${rootExamClassId}]]`) throw new Error(`试题分类原子创建异常：${JSON.stringify(rootExamClass)}`);
  const childExamClass = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveExamClass', className: 'ExamClass', parentId: rootExamClassId, classType: 2, orderId: 0, fields: { cClassName: `冒烟子试题分类-${examClassSuffix}` } });
  temporaryExamClassObjectIds.push(String(childExamClass.objectId || ''));
  const childExamClassId = Number(childExamClass.cId);
  if (!childExamClassId || Number(childExamClass.cClassid) !== rootExamClassId || Number(childExamClass.cClassType) !== 2) throw new Error('子试题分类创建失败');
  const examChildren = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'examClassChildren', className: 'ExamClass', parentId: rootExamClassId });
  if (!examChildren.results?.some((entry) => entry.objectId === childExamClass.objectId)) throw new Error('试题子分类接口未返回目标记录');
  await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveExamClass', className: 'ExamClass', parentId: 0, classType: 1, orderId: 0, fields: { cClassName: rootExamClass.cClassName } }, 409);
  await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveExamClass', className: 'ExamClass', objectId: rootExamClass.objectId, parentId: childExamClassId, classType: 1, orderId: Number(rootExamClass.cOrderBy) || 0, fields: { cClassName: rootExamClass.cClassName } }, 409);
  const examClassDeleteBlocked = await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'ExamClass', objectId: rootExamClass.objectId }, 409);
  if (!String(examClassDeleteBlocked.message).includes('下级分类')) throw new Error('试题分类子级引用删除保护未返回明确原因');
  const movedExamClass = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveExamClass', className: 'ExamClass', objectId: childExamClass.objectId, parentId: 0, classType: 2, orderId: Number(childExamClass.cOrderBy) || 0, fields: { cClassName: childExamClass.cClassName } });
  if (Number(movedExamClass.cClassid) !== 0) throw new Error('试题分类结构移动失败');
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'ExamClass', objectId: childExamClass.objectId });
  temporaryExamClassObjectIds.pop();
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'ExamClass', objectId: rootExamClass.objectId });
  temporaryExamClassObjectIds.pop();
  const examPointSuffix = Date.now().toString(36);
  const rootExamPoint = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveExamPoint', className: 'ExamPoint', parentId: 0, orderId: 0, fields: { testPoint: `冒烟考点-${examPointSuffix}` } });
  temporaryExamPointObjectIds.push(String(rootExamPoint.objectId || ''));
  const rootExamPointId = Number(rootExamPoint.id);
  if (!temporaryExamPointObjectIds[0] || !rootExamPointId || rootExamPoint.sourceKey !== `[["ID",${rootExamPointId}]]`) throw new Error(`考点原子创建异常：${JSON.stringify(rootExamPoint)}`);
  const childExamPoint = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveExamPoint', className: 'ExamPoint', parentId: rootExamPointId, orderId: 0, fields: { testPoint: `冒烟子考点-${examPointSuffix}` } });
  temporaryExamPointObjectIds.push(String(childExamPoint.objectId || ''));
  const childExamPointId = Number(childExamPoint.id);
  if (!childExamPointId || Number(childExamPoint.tid) !== rootExamPointId) throw new Error('子考点创建失败');
  await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveExamPoint', className: 'ExamPoint', parentId: 0, orderId: 0, fields: { testPoint: rootExamPoint.testPoint } }, 409);
  await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveExamPoint', className: 'ExamPoint', objectId: rootExamPoint.objectId, parentId: childExamPointId, orderId: Number(rootExamPoint.orderBy) || 0, fields: { testPoint: rootExamPoint.testPoint } }, 409);
  const examPointDeleteBlocked = await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'ExamPoint', objectId: rootExamPoint.objectId }, 409);
  if (!String(examPointDeleteBlocked.message).includes('下级考点')) throw new Error('考点子级引用删除保护未返回明确原因');
  const movedExamPoint = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveExamPoint', className: 'ExamPoint', objectId: childExamPoint.objectId, parentId: 0, orderId: Number(childExamPoint.orderBy) || 0, fields: { testPoint: childExamPoint.testPoint } });
  if (Number(movedExamPoint.tid) !== 0) throw new Error('考点结构移动失败');
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'ExamPoint', objectId: childExamPoint.objectId });
  temporaryExamPointObjectIds.pop();
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'ExamPoint', objectId: rootExamPoint.objectId });
  temporaryExamPointObjectIds.pop();
  const metadataSuffix = Date.now().toString(36);
  const temporaryModelId = 800000000 + Math.floor(Date.now() / 1000) % 100000000;
  const tempModel = await jsonRequest(`${PARSE_URL}/classes/Model`, { method: 'POST', body: JSON.stringify({ sourceKey: `cloud:smoke-model:${metadataSuffix}`, company, modelId: temporaryModelId, modelName: `冒烟模型-${metadataSuffix}`, tableName: `ZL_C_Smoke_${metadataSuffix}`, modelType: 1, itemName: '记录', itemUnit: '条', multiFlag: true }) }, true);
  temporaryModelObjectId = String(tempModel.objectId || '');
  const updatedModel = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveModelMetadata', className: 'Model', objectId: temporaryModelObjectId, fields: { modelName: `冒烟模型更新-${metadataSuffix}`, description: '仅元数据更新', tableName: 'malicious_table', modelId: 1 } });
  if (Number(updatedModel.modelId) !== temporaryModelId || updatedModel.tableName !== `ZL_C_Smoke_${metadataSuffix}` || updatedModel.description !== '仅元数据更新') throw new Error(`模型结构字段隔离异常：${JSON.stringify(updatedModel)}`);
  await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveModelMetadata', className: 'Model', fields: { modelName: '禁止新增模型' } }, 501);
  for (let index = 0; index < 2; index++) {
    const field = await jsonRequest(`${PARSE_URL}/classes/ModelField`, { method: 'POST', body: JSON.stringify({ sourceKey: `cloud:smoke-model-field:${metadataSuffix}:${index}`, company, fieldId: temporaryModelId + index + 1, modelId: temporaryModelId, fieldName: `smokeField${index}`, fieldAlias: `冒烟字段${index}`, fieldType: 'TextType', orderId: index, isShow: true }) }, true);
    temporaryModelFieldObjectIds.push(String(field.objectId || ''));
  }
  const updatedField = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveModelFieldMetadata', className: 'ModelField', objectId: temporaryModelFieldObjectIds[0], fields: { fieldAlias: '更新后的字段别名', fieldTips: '仅展示元数据', fieldName: 'maliciousField', fieldType: 'SqlType', modelId: 1 } });
  if (updatedField.fieldAlias !== '更新后的字段别名' || updatedField.fieldName !== 'smokeField0' || updatedField.fieldType !== 'TextType' || Number(updatedField.modelId) !== temporaryModelId) throw new Error(`模型字段结构隔离异常：${JSON.stringify(updatedField)}`);
  const reorderedFields = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'modelFieldOrder', className: 'ModelField', items: [{ objectId: temporaryModelFieldObjectIds[0], orderId: 2 }, { objectId: temporaryModelFieldObjectIds[1], orderId: 1 }] });
  if (reorderedFields.updated !== 2 || Number(reorderedFields.modelId) !== temporaryModelId) throw new Error('模型字段排序失败');
  await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'delete', className: 'ModelField', objectId: temporaryModelFieldObjectIds[0] }, 501);
  const updatedGuestbook = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'saveGuestbook', className: 'Guestbook', objectId: temporaryGuestbookId, fields: { title: feedbackModel.Title, tcontent: '管理员规范化编辑', gid: 999, status: -2, cateid: 999 } });
  if (updatedGuestbook.tcontent !== '管理员规范化编辑' || Number(updatedGuestbook.gid) === 999 || Number(updatedGuestbook.cateid) === 999 || Number(updatedGuestbook.status) === -2) throw new Error(`留言结构字段隔离异常：${JSON.stringify(updatedGuestbook)}`);
  const guestUnaudited = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'guestbookBatch', className: 'Guestbook', action: 'unaudit', objectIds: [temporaryGuestbookId] });
  if (Number(guestUnaudited.results?.[0]?.status) !== 0) throw new Error('留言取消审核失败');
  const guestRecycled = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'guestbookBatch', className: 'Guestbook', action: 'recycle', objectIds: [temporaryGuestbookId] });
  if (Number(guestRecycled.results?.[0]?.status) !== -2) throw new Error('留言回收失败');
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'guestbookBatch', className: 'Guestbook', action: 'recover', objectIds: [temporaryGuestbookId] });
  const guestReply = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'guestbookReply', className: 'Guestbook', parentObjectId: temporaryGuestbookId, title: '管理员冒烟回复', content: '云函数回复正文' });
  temporaryGuestbookReplyId = String(guestReply.objectId || '');
  if (!temporaryGuestbookReplyId || Number(guestReply.parentid) !== Number(updatedGuestbook.gid) || Number(guestReply.status) !== 99 || !Number(guestReply.gid)) throw new Error(`管理员留言回复异常：${JSON.stringify(guestReply)}`);
  const guestDeleteBlocked = await callFunctionError('xiaoshu/admin/gateway', login.sessionToken, { operation: 'guestbookBatch', className: 'Guestbook', action: 'purge', objectIds: [temporaryGuestbookId] }, 409);
  if (!String(guestDeleteBlocked.message).includes('仍有回复')) throw new Error('留言回复引用删除保护未返回明确原因');
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'guestbookBatch', className: 'Guestbook', action: 'purge', objectIds: [temporaryGuestbookReplyId] });
  temporaryGuestbookReplyId = '';

  const contentPending = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'contentBatch', className: 'CommonModel', action: 'status', objectIds: [temporaryAppointmentCommonObjectId], status: 0 });
  if (contentPending.updated !== 1 || Number(contentPending.results?.[0]?.status) !== 0) throw new Error('内容待审核状态更新失败');
  const contentRecycled = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'contentBatch', className: 'CommonModel', action: 'recycle', objectIds: [temporaryAppointmentCommonObjectId] });
  if (Number(contentRecycled.results?.[0]?.status) !== -2) throw new Error('内容回收站状态更新失败');
  const contentRecovered = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'contentBatch', className: 'CommonModel', action: 'recover', objectIds: [temporaryAppointmentCommonObjectId] });
  if (Number(contentRecovered.results?.[0]?.status) !== 0) throw new Error('内容回收站恢复失败');
  const contentMoved = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'contentBatch', className: 'CommonModel', action: 'move', objectIds: [temporaryAppointmentCommonObjectId], nodeId: 29 });
  if (Number(contentMoved.results?.[0]?.nodeId) !== 29) throw new Error('内容节点移动失败');
  await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'contentBatch', className: 'CommonModel', action: 'status', objectIds: [temporaryAppointmentCommonObjectId], status: 99 });

  const page = await callFunction('xiaoshu/admin/gateway', login.sessionToken, { operation: 'list', className: 'CourseAppointment', page: 1, pageSize: 2 });
  if (!Array.isArray(page.results) || page.pageSize !== 2) throw new Error('资源分页校验失败');

  const normalized = await callFunction('xiaoshu/cms/content-normalizer', login.sessionToken, { content: '<p>中文&nbsp;<strong>内容</strong></p><script>alert(1)</script>' });
  if (normalized.content !== '中文 内容') throw new Error(`内容清理结果异常：${normalized.content}`);

  const exams = await callFunction('xiaoshu/cms/exams/classes', login.sessionToken, { page: 1, pageSize: 2 });
  if (!Array.isArray(exams.results)) throw new Error('考试班级投影校验失败');

  const guest = await callFunction('xiaoshu/cms/guest/bar', login.sessionToken, { page: 1, pageSize: 2 });
  if (!Array.isArray(guest.results)) throw new Error('互动社区投影校验失败');

  const migration = await callLegacyFunction('', { action: 'migration_status' });
  const sourceActionList = await sourceActions();
  const implementedActions = migration.result?.implemented || [];
  const blockedActions = Object.keys(migration.result?.blocked || {});
  const covered = new Set([...implementedActions, ...blockedActions]);
  const missing = sourceActionList.filter((action) => !covered.has(action));
  if (missing.length) throw new Error(`app gateway 迁移矩阵缺少：${missing.join(', ')}`);
  const sourceBlocked = blockedActions.filter((action) => sourceActionList.includes(action));
  const compatibilityActions = blockedActions.filter((action) => !sourceActionList.includes(action)).sort();
  const sourceImplemented = implementedActions.filter((action) => sourceActionList.includes(action));
  const compatibilityImplemented = implementedActions.filter((action) => !sourceActionList.includes(action)).sort();
  if (sourceImplemented.length !== 28 || sourceBlocked.length !== 63) throw new Error(`app gateway 源 action 计数异常：${sourceImplemented.length} 已映射 / ${sourceBlocked.length} 阻塞`);
  if (compatibilityImplemented.join(',') !== 'content_add_zt') throw new Error(`app gateway 已实现兼容 action 计数异常：${compatibilityImplemented.join(',')}`);
  if (compatibilityActions.join(',') !== 'product_add,product_upd') throw new Error(`app gateway 阻塞兼容 action 计数异常：${compatibilityActions.join(',')}`);

  const content = await callLegacyFunction('', { action: 'content_list', page: 1, pageSize: 2 });
  if (!Array.isArray(content.result) || content.result.length !== 2 || Number(content.page?.itemCount) < 89000) throw new Error('公开内容分页校验失败');
  const contentExact = await callLegacyFunction('', { action: 'content_list', page: 1, pageSize: 1, objectId: content.result[0].objectId });
  if (contentExact.result?.[0]?.objectId !== content.result[0].objectId || contentExact.page?.itemCount !== 1) throw new Error('内容 objectId 精确查询校验失败');
  const contentDetail = await callLegacyFunction('', { action: 'content_get', id: content.result[0].objectId });
  if (!Array.isArray(contentDetail.result) || contentDetail.result[0]?.objectId !== content.result[0].objectId) throw new Error('内容详情旧数组契约校验失败');
  contentHitObjectId = String(content.result[0].objectId);
  contentHitOriginal = Number(content.result[0].hits ?? content.result[0].Hits ?? 0);
  const contentHit = await callLegacyFunction('', { action: 'content_uphis', id: contentHitObjectId, num: 999 });
  if (Number(contentHit.result?.hits) !== contentHitOriginal + 1) throw new Error(`公开内容浏览量未固定原子加一：${JSON.stringify(contentHit)}`);
  await jsonRequest(`${PARSE_URL}/classes/CommonModel/${contentHitObjectId}`, { method: 'PUT', body: JSON.stringify({ hits: contentHitOriginal }) }, true);
  contentHitObjectId = '';
  await callLegacyFunction('', { action: 'content_uphis', id: temporaryAppointmentId }, 401);
  const appUpdate = await callLegacyFunction('', { action: 'app_update' });
  if (Number(appUpdate.result?.ver) !== 113 || appUpdate.result?.nver !== '1.1.8' || !String(appUpdate.result?.path).startsWith('https://') || appUpdate.result?.size !== null || appUpdate.result?.sizeUnavailable !== true) throw new Error(`应用版本旧契约别名异常：${JSON.stringify(appUpdate)}`);
  const gameNode = await callLegacyFunction('', { action: 'node_get', id: 77 });
  if (gameNode.result?.NodeID === undefined || gameNode.result?.ConsumePoint === undefined || gameNode.result?.ConsumeDeposit === undefined) throw new Error(`栏目详情游戏消费字段别名异常：${JSON.stringify(gameNode.result)}`);

  const words = await callLegacyFunction('', { action: 'content_list', modelId: 52, page: 1, pageSize: 1 });
  if (Number(words.page?.itemCount) < 89000 || !words.result?.[0]?.GeneralID || words.result?.[0]?.sy === undefined) throw new Error('词库 addon 联表校验失败');

  const privateContent = await callLegacyFunction('', { action: 'content_list', modelId: 56, page: 1, pageSize: 1 }, 401);
  if (!String(privateContent.retmsg).includes('登录')) throw new Error('学习记录未阻止匿名访问');
  const learning = await callLegacyFunction(login.sessionToken, { action: 'content_list', modelId: 56, page: 1, pageSize: 1 });
  if (!learning.result?.[0]?.GeneralID || learning.result?.[0]?.xxqs === undefined) throw new Error('学习记录 addon 联表校验失败');

  const recordDetail = await callLegacyFunction(login.sessionToken, { action: 'e_record_detail', id: learning.result[0].GeneralID });
  if (!Array.isArray(recordDetail.result) || !recordDetail.result.length || !recordDetail.result[0]?.detail?.[0]?.Title) throw new Error('学习记录单词详情联查校验失败');

  const appointments = await callLegacyFunction(login.sessionToken, { action: 'content_list', modelId: 54, page: 1, pageSize: 1 });
  const appointment = await callLegacyFunction(login.sessionToken, { action: 'e_order_detail', id: appointments.result?.[0]?.GeneralID });
  if (!appointment.result?.[0]?.GeneralID || appointment.result[0].kcid === undefined) throw new Error('预约详情联查校验失败');

  const memberProfile = await callLegacyFunction(memberLogin.sessionToken, { action: 'user_get', uid: memberLegacyId });
  if (memberProfile.result?.honeyName !== profileModel.honeyName || memberProfile.addon?.vip !== 2 || memberProfile.addon?.silverCoin !== 2 || JSON.stringify(memberProfile).includes('must-not-leak')) throw new Error('用户旧契约字段或敏感字段过滤异常');
  const teamMembers = await callLegacyFunction(memberLogin.sessionToken, { action: 'user_list', puid: memberLegacyId, cpage: 1, psize: 10 });
  if (teamMembers.page?.itemCount !== 1 || Number(teamMembers.result?.[0]?.ParentUserID) !== memberLegacyId || Number(teamMembers.result?.[0]?.VIP) !== 3) throw new Error(`团队成员列表异常：${JSON.stringify(teamMembers)}`);
  const teamSummary = await callLegacyFunction(memberLogin.sessionToken, { action: 'user_dept', uid: memberLegacyId });
  if (teamSummary.result?.childs !== 1 || teamSummary.result?.v3 !== 1) throw new Error(`团队会员统计异常：${JSON.stringify(teamSummary.result)}`);
  const childProfile = await callLegacyFunction(memberLogin.sessionToken, { action: 'user_get', uid: childLegacyId });
  if (childProfile.result?.userId !== childLegacyId || childProfile.result?.puid !== memberLegacyId || JSON.stringify(childProfile).includes('must-not-leak')) throw new Error('团队成员详情或密码字段过滤异常');
  await callLegacyFunction(coachLogin.sessionToken, { action: 'user_get', uid: childLegacyId }, 403);
  const coachStudents = await callLegacyFunction(coachLogin.sessionToken, { action: 'e_user_list', cpage: 1, psize: 10 });
  if (coachStudents.page?.itemCount !== 1 || Number(coachStudents.result?.[0]?.szyh) !== memberLegacyId || coachStudents.result?.[0]?.honeyname !== profileModel.honeyName) throw new Error(`陪练学员分组列表异常：${JSON.stringify(coachStudents)}`);

  const newWords = await callLegacyFunction(login.sessionToken, { action: 'e_words_list', uid: 58, page: 1, pageSize: 2 });
  if (Number(newWords.page?.itemCount) < 1 || !newWords.result?.[0]?.detail?.[0]?.Title) throw new Error('用户生词联查校验失败');

  const courseWords = await callLegacyFunction(login.sessionToken, { action: 'e_ck_list', uid: 58, nids: 40, page: 1, pageSize: 1000 });
  const learnedWord = courseWords.result?.find((word) => Number(word.GeneralID) === 2505);
  if (Number(courseWords.page?.itemCount) < 1 || !courseWords.result?.[0]?.detail?.Title || Number(learnedWord?.w_learned) !== 7) throw new Error('课程词库学习进度联查校验失败');

  const memory = await callLegacyFunction(login.sessionToken, { action: 'e_get_21list', uid: 58, page: 1, pageSize: 2 });
  if (Number(memory.page?.itemCount) < 1 || !memory.result?.[0]?.GeneralID || memory.result[0].learned === undefined) throw new Error('21 天抗遗忘联查校验失败');

  const incomeBlocked = await callLegacyFunction(login.sessionToken, { action: 'e_get_21list_tj', uid: 58 }, 501);
  if (!String(incomeBlocked.retmsg).includes('计价规则')) throw new Error('复习收入缺失规则未显式阻塞');

  const ownEmpty = await callLegacyFunction(memberLogin.sessionToken, { action: 'content_list', modelId: 56, myfield2: `UserId=${memberLegacyId}`, page: 1, pageSize: 1 });
  if (!Array.isArray(ownEmpty.result) || ownEmpty.page?.itemCount !== 0) throw new Error('普通用户本人记录权限校验失败');
  const ownCourseWords = await callLegacyFunction(memberLogin.sessionToken, { action: 'e_ck_list', uid: memberLegacyId, nids: 40, page: 1, pageSize: 1 });
  if (!Array.isArray(ownCourseWords.result) || ownCourseWords.result[0]?.w_learned !== 0) throw new Error('普通用户本人课程词库权限校验失败');
  const learnedWrite = await callLegacyFunction(memberLogin.sessionToken, { action: 'e_add_words', uid: memberLegacyId, wordsId: '2505', kcid: 16, save: 1 });
  if (learnedWrite.result?.created !== 1 || learnedWrite.result?.learnedIncremented !== 1) throw new Error('首次学习词进度写入校验失败');
  await callLegacyFunction('', { action: 'node_list', pid: 16, ifunit: 1, userId: memberLegacyId }, 401);
  const unitNodes = await callLegacyFunction(memberLogin.sessionToken, { action: 'node_list', pid: 16, ifunit: 1, userId: memberLegacyId, pageSize: 100 });
  const learnedUnit = unitNodes.result?.find((node) => Number(node.NodeID) === 40);
  if (!learnedUnit || Number(learnedUnit.total) < 1 || Number(learnedUnit.yx_word) !== 1 || Number(learnedUnit.process) !== Math.round(100 / Number(learnedUnit.total))) throw new Error(`单元已学进度异常：${JSON.stringify(learnedUnit)}`);
  const learnedRead = await callLegacyFunction(memberLogin.sessionToken, { action: 'e_ck_list', uid: memberLegacyId, nids: 40, page: 1, pageSize: 1000 });
  if (Number(learnedRead.result?.find((word) => Number(word.GeneralID) === 2505)?.w_learned) !== 1) throw new Error('学习次数写后读校验失败');
  await callLegacyFunction(memberLogin.sessionToken, { action: 'e_add_words', uid: memberLegacyId, wordsId: '2505', kcid: 16, ifnew: 1 });
  const addedNewWord = await callLegacyFunction(memberLogin.sessionToken, { action: 'e_words_list', uid: memberLegacyId, page: 1, pageSize: 10 });
  if (addedNewWord.page?.itemCount !== 1 || Number(addedNewWord.result?.[0]?.detail?.[0]?.GeneralID) !== 2505) throw new Error('加入生词写后读校验失败');
  await callLegacyFunction(memberLogin.sessionToken, { action: 'e_add_words', uid: memberLegacyId, wordsId: '2505', kcid: 16, ifnew: 0 });
  const removedNewWord = await callLegacyFunction(memberLogin.sessionToken, { action: 'e_words_list', uid: memberLegacyId, page: 1, pageSize: 10 });
  if (removedNewWord.page?.itemCount !== 0) throw new Error('移出生词写后读校验失败');
  const scheduledStudy = await callLegacyFunction(memberLogin.sessionToken, { action: 'content_add_zt', content: JSON.stringify({ ModelID: 56, nodeId: 291, inputer: memberUsername, status: 99, Hits: 1, title: memberUsername }), addon: JSON.stringify({ UserID: memberLegacyId, dqrq: '20991231', learned: 1, xxqs: JSON.stringify([{ GeneralID: 2505, Title: 'woman', check: 0 }]) }) });
  if (!/^\d{15}$/.test(String(scheduledStudy.result))) throw new Error('带复习计划的学习记录创建结果异常');
  const scheduledDetail = await callLegacyFunction(memberLogin.sessionToken, { action: 'content_get', id: scheduledStudy.result });
  const reviewDates = String(scheduledDetail.result?.[0]?.fxrl || '').split(',').filter(Boolean);
  if (reviewDates.length !== 15 || !reviewDates.every((date) => /^\d{8}$/.test(date))) throw new Error('15 段抗遗忘复习日期生成失败');
  await callLegacyFunction(coachLogin.sessionToken, { action: 'content_update', content: JSON.stringify({ GeneralID: scheduledStudy.result }), addon: JSON.stringify({ con: '越权更新' }) }, 403);
  const scheduledUpdate = await callLegacyFunction(memberLogin.sessionToken, { action: 'content_update', content: JSON.stringify({ GeneralID: scheduledStudy.result, Title: '已更新学习记录' }), addon: JSON.stringify({ con: '规范化内容更新', learned: 1 }) });
  if (String(scheduledUpdate.result) !== String(scheduledStudy.result)) throw new Error('规范化内容更新返回值异常');
  const updatedScheduledDetail = await callLegacyFunction(memberLogin.sessionToken, { action: 'content_get', id: scheduledStudy.result });
  if (updatedScheduledDetail.result?.[0]?.con !== '规范化内容更新' || updatedScheduledDetail.result?.[0]?.Title !== '已更新学习记录') throw new Error('规范化内容双表更新写后读失败');
  const assessment = await callLegacyFunction(memberLogin.sessionToken, { action: 'content_add', content: JSON.stringify({ ModelID: 61, nodeId: 389, inputer: memberUsername, status: 99, Hits: 1, title: memberUsername }), addon: JSON.stringify({ UserID: memberLegacyId, askid: 1, prev_score: 0, totalScore: 10, wrong: 2, dontKnow: 1, answerid: 7, df: 7 }) });
  if (!/^\d{15}$/.test(String(assessment.result))) throw new Error('规范化测评内容新增结果异常');
  const assessmentDetail = await callLegacyFunction(memberLogin.sessionToken, { action: 'content_get', id: assessment.result });
  if (String(assessmentDetail.result?.[0]?.df) !== '7' || String(assessmentDetail.result?.[0]?.prevScore) !== '0' || Number(assessmentDetail.result?.[0]?.UserID ?? assessmentDetail.result?.[0]?.userId) !== memberLegacyId) throw new Error('规范化测评内容新增写后读失败');
  const missingSchemaCreate = await callLegacyFunction(memberLogin.sessionToken, { action: 'content_add', content: JSON.stringify({ ModelID: 55, nodeId: 255 }), addon: JSON.stringify({ UserID: memberLegacyId, scnr: '[]' }) }, 501);
  if (!String(missingSchemaCreate.retmsg).includes('未迁移内容模型 55')) throw new Error('缺 Schema 内容新增未明确拒绝');
  const studyAddon = { con: '云函数学习记录冒烟测试', dqrq: '20260818', fxrl: '20260819,20260820', UserID: memberLegacyId, learned: 1, ygg: 0, djq: 0, xxqs: JSON.stringify([{ GeneralID: 2505, Title: 'woman', check: 0 }]) };
  const createdStudy = await callLegacyFunction(memberLogin.sessionToken, { action: 'stu_record_update_v2', orderId: temporaryAppointmentId, uid: memberLegacyId, inputer: memberUsername, addon: JSON.stringify(studyAddon) });
  if (!createdStudy.result?.created || !createdStudy.result?.GeneralID || !createdStudy.result?.recordObjectId) throw new Error('预约学习记录首次双表写入校验失败');
  const studyDetail = await callLegacyFunction(memberLogin.sessionToken, { action: 'e_record_detail', id: createdStudy.result.GeneralID });
  if (studyDetail.result?.[0]?.detail?.[0]?.Title !== 'woman') throw new Error('预约学习记录写后详情校验失败');
  studyAddon.xxqs = JSON.stringify([{ GeneralID: 2505, Title: 'woman', check: 1 }]);
  const updatedStudy = await callLegacyFunction(memberLogin.sessionToken, { action: 'stu_record_update_v2', orderId: temporaryAppointmentId, uid: memberLegacyId, inputer: memberUsername, addon: JSON.stringify(studyAddon) });
  if (updatedStudy.result?.created || updatedStudy.result?.GeneralID !== createdStudy.result.GeneralID) throw new Error('预约学习记录幂等更新校验失败');
  const studyList = await callLegacyFunction(memberLogin.sessionToken, { action: 'content_list', modelId: 56, myfield2: `UserId=${memberLegacyId}|dsid=${temporaryAppointmentId}`, page: 1, pageSize: 2 });
  if (studyList.page?.itemCount !== 1 || Number(studyList.result?.[0]?.ygg) !== 1 || Number(studyList.result?.[0]?.learned) !== 1) throw new Error('预约学习记录聚合字段写后读校验失败');
  const orderContent = JSON.stringify({ GeneralID: temporaryAppointmentId, UpDateTime: '2026-08-18 13:30' });
  await callLegacyFunction(memberLogin.sessionToken, { action: 'e_order_update_v2', uid: memberLegacyId, status: 10, content: orderContent }, 403);
  const startedOrder = await callLegacyFunction(coachLogin.sessionToken, { action: 'e_order_update_v2', uid: coachLegacyId, status: 10, content: orderContent });
  if (startedOrder.result?.previousStatus !== 0 || startedOrder.result?.status !== 10) throw new Error('预约开始状态迁移失败');
  const endedOrder = await callLegacyFunction(coachLogin.sessionToken, { action: 'e_order_update_v2', uid: coachLegacyId, status: 11, content: orderContent });
  if (endedOrder.result?.reviewCount !== 2 || !endedOrder.result?.periodDeducted) throw new Error('预约结束课时与抗遗忘副作用失败');
  const repeatedEnd = await callLegacyFunction(coachLogin.sessionToken, { action: 'e_order_update_v2', uid: coachLegacyId, status: 11, content: orderContent });
  if (!repeatedEnd.result?.unchanged) throw new Error('预约结束状态未保持幂等');
  const updatedMember = await jsonRequest(`${PARSE_URL}/users/${memberId}`, {}, true);
  if (Number(updatedMember.legacyUserData?.Purse) !== 1 || Number(updatedMember.legacyUserData?.UserPoint) !== 1.5) throw new Error(`预约结束课时扣减异常：${JSON.stringify(updatedMember.legacyUserData)}`);
  const sideEffectWhere = encodeURIComponent(JSON.stringify({ sourceKey: { $regex: `^cloud:e_order_update:${temporaryAppointmentId}:` } }));
  const [periodLogs, pointLogs, memoryRows, memoryCommonRows] = await Promise.all([
    jsonRequest(`${PARSE_URL}/classes/UserExpDomP?where=${sideEffectWhere}&count=1&limit=0`, {}, true),
    jsonRequest(`${PARSE_URL}/classes/UserUserPoint?where=${sideEffectWhere}&count=1&limit=0`, {}, true),
    jsonRequest(`${PARSE_URL}/classes/MemoryPracticeRecord?where=${sideEffectWhere}&count=1&limit=0`, {}, true),
    jsonRequest(`${PARSE_URL}/classes/CommonModel?where=${sideEffectWhere}&count=1&limit=0`, {}, true),
  ]);
  if (periodLogs.count !== 1 || pointLogs.count !== 1 || memoryRows.count !== 2 || memoryCommonRows.count !== 2) throw new Error(`预约结束账本/抗遗忘数量异常：${periodLogs.count}/${pointLogs.count}/${memoryRows.count}/${memoryCommonRows.count}`);
  const purseHistory = await callLegacyFunction(memberLogin.sessionToken, { action: 'user_point_list', uid: memberLegacyId, stype: 1, cpage: 1, psize: 10 });
  if (purseHistory.page?.itemCount !== 1 || Number(purseHistory.result?.[0]?.score) !== -1 || !purseHistory.result?.[0]?.ExpHisID || purseHistory.result?.[0]?.Detail === undefined || purseHistory.addon?.purseFeeRuleUnavailable !== true) throw new Error(`余额账本读取异常：${JSON.stringify(purseHistory)}`);
  const couponHistory = await callLegacyFunction(memberLogin.sessionToken, { action: 'user_point_list', uid: memberLegacyId, stype: 4, cpage: 1, psize: 10 });
  if (couponHistory.page?.itemCount !== 1 || Number(couponHistory.result?.[0]?.score) !== -0.5 || !couponHistory.result?.[0]?.HisTime) throw new Error(`点券账本读取异常：${JSON.stringify(couponHistory)}`);
  await callLegacyFunction(memberLogin.sessionToken, { action: 'user_point_list', uid: memberLegacyId, stype: 7 }, 400);
  await callLegacyFunction(coachLogin.sessionToken, { action: 'e_order_update_v2', uid: coachLegacyId, status: 20, content: orderContent }, 403);
  await callLegacyFunction(memberLogin.sessionToken, { action: 'e_order_update_v2', uid: memberLegacyId, status: 20, content: orderContent });
  await callLegacyFunction(coachLogin.sessionToken, { action: 'e_order_update_v2', uid: coachLegacyId, status: 30, content: orderContent });
  const completedOrder = await callLegacyFunction(memberLogin.sessionToken, { action: 'e_order_detail', id: temporaryAppointmentId });
  if (Number(completedOrder.result?.[0]?.dszt) !== 30) throw new Error('预约状态机写后读失败');
  const coachStats = await callLegacyFunction(coachLogin.sessionToken, { action: 'e_order_tongji', uid: coachLegacyId });
  if (coachStats.result?.t30 !== '1' || coachStats.result?.t60 !== '1' || coachStats.result?.t_tiyan !== '1' || coachStats.result?.t_total !== '3' || coachStats.result?.t_shichang !== '2.5' || coachStats.result?.t_yongji !== '100') throw new Error('陪练预约统计公式校验失败');
  const memberStats = await callLegacyFunction(memberLogin.sessionToken, { action: 'e_order_tongji', uid: memberLegacyId });
  if (memberStats.result?.t30 !== '1' || memberStats.result?.t60 !== '0' || memberStats.result?.t_tiyan !== '0' || memberStats.result?.t_total !== '1' || memberStats.result?.t_shichang !== '0.5' || memberStats.result?.t_yongji !== '0') throw new Error(`学员预约与生词统计公式校验失败：${JSON.stringify(memberStats.result)}`);
  const deniedCourseWords = await callLegacyFunction(memberLogin.sessionToken, { action: 'e_ck_list', uid: 58, nids: 40, page: 1, pageSize: 1 }, 403);
  if (!String(deniedCourseWords.retmsg).includes('无权')) throw new Error('普通用户跨用户课程词库未被拒绝');
  const denied = await callLegacyFunction(memberLogin.sessionToken, { action: 'content_list', modelId: 56, myfield2: 'UserId=3', page: 1, pageSize: 1 }, 403);
  if (!String(denied.retmsg).includes('无权')) throw new Error('普通用户跨用户记录未被拒绝');

  const profile = await callLegacyFunction(login.sessionToken, { action: 'user_get' });
  if (profile.retcode !== 0 || profile.result?.objectId !== userId) throw new Error('app gateway 用户会话校验失败');

  const blocked = await callLegacyFunction('', { action: 'cart_list' }, 501);
  if (!String(blocked.retmsg).startsWith('migration_blocked:')) throw new Error('阻塞接口未返回 migration_blocked');
  const productBlocked = await callLegacyFunction('', { action: 'product_list' }, 501);
  if (!String(productBlocked.retmsg).includes('ZL_Commodities')) throw new Error('缺商品主表的读取接口未明确阻塞');

  console.log('Cloud smoke passed: admin auth/tenant/account lifecycle/group sync/node/special/guest-category/bar/exam-class/exam-point/model/guestbook lifecycle/content workflow/CRUD reads, CMS projections, normalized learning joins, app action coverage, public content, session scope, explicit blocked APIs.');
} finally {
  if (contentHitObjectId) await jsonRequest(`${PARSE_URL}/classes/CommonModel/${contentHitObjectId}`, { method: 'PUT', body: JSON.stringify({ hits: contentHitOriginal }) }, true).catch((error) => {
    console.error(`公开内容浏览量恢复失败：${error.message}`);
    process.exitCode = 1;
  });
  if (registeredUserId) await jsonRequest(`${PARSE_URL}/users/${registeredUserId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时注册用户清理失败：${error.message}`);
    process.exitCode = 1;
  });
  if (adminCreatedUserId) await jsonRequest(`${PARSE_URL}/users/${adminCreatedUserId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`管理员开户临时用户清理失败：${error.message}`);
    process.exitCode = 1;
  });
  if (temporaryGroupObjectId) await jsonRequest(`${PARSE_URL}/classes/Group/${temporaryGroupObjectId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时用户组清理失败：${error.message}`);
    process.exitCode = 1;
  });
  for (const nodeId of temporaryNodeObjectIds) if (nodeId) await jsonRequest(`${PARSE_URL}/classes/Node/${nodeId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时栏目清理失败：${error.message}`);
    process.exitCode = 1;
  });
  for (const specialId of temporarySpecialObjectIds) if (specialId) await jsonRequest(`${PARSE_URL}/classes/Special/${specialId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时专题清理失败：${error.message}`);
    process.exitCode = 1;
  });
  for (const categoryId of temporaryGuestCategoryObjectIds) if (categoryId) await jsonRequest(`${PARSE_URL}/classes/Guestcate/${categoryId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时留言/贴吧分类清理失败：${error.message}`);
    process.exitCode = 1;
  });
  for (const examClassId of [...temporaryExamClassObjectIds].reverse()) if (examClassId) await jsonRequest(`${PARSE_URL}/classes/ExamClass/${examClassId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时试题分类清理失败：${error.message}`);
    process.exitCode = 1;
  });
  for (const examPointId of [...temporaryExamPointObjectIds].reverse()) if (examPointId) await jsonRequest(`${PARSE_URL}/classes/ExamPoint/${examPointId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时考点清理失败：${error.message}`);
    process.exitCode = 1;
  });
  for (const fieldId of temporaryModelFieldObjectIds) if (fieldId) await jsonRequest(`${PARSE_URL}/classes/ModelField/${fieldId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时模型字段清理失败：${error.message}`);
    process.exitCode = 1;
  });
  if (temporaryModelObjectId) await jsonRequest(`${PARSE_URL}/classes/Model/${temporaryModelObjectId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时模型清理失败：${error.message}`);
    process.exitCode = 1;
  });
  if (temporaryGuestbookId) await jsonRequest(`${PARSE_URL}/classes/Guestbook/${temporaryGuestbookId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时留言清理失败：${error.message}`);
    process.exitCode = 1;
  });
  if (temporaryGuestbookReplyId) await jsonRequest(`${PARSE_URL}/classes/Guestbook/${temporaryGuestbookReplyId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时管理员留言回复清理失败：${error.message}`);
    process.exitCode = 1;
  });
  if (temporaryGuestBarId) await jsonRequest(`${PARSE_URL}/classes/GuestBar/${temporaryGuestBarId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时贴吧帖子清理失败：${error.message}`);
    process.exitCode = 1;
  });
  for (const lessonId of temporaryLessonIds) await jsonRequest(`${PARSE_URL}/classes/LessonRecord/${lessonId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时陪练课次清理失败：${error.message}`);
    process.exitCode = 1;
  });
  if (memberLegacyId) {
    const commonWhere = encodeURIComponent(JSON.stringify({ sourceKey: { $regex: `^cloud:(stu_record|content_add_zt|content_add):${memberLegacyId}:` } }));
    const commonRows = await jsonRequest(`${PARSE_URL}/classes/CommonModel?where=${commonWhere}&limit=1000`, {}, true).catch(() => ({ results: [] }));
    for (const row of commonRows.results || []) await jsonRequest(`${PARSE_URL}/classes/CommonModel/${row.objectId}`, { method: 'DELETE' }, true).catch((error) => {
      console.error(`临时学习主记录清理失败：${error.message}`);
      process.exitCode = 1;
    });
    const studyWhere = encodeURIComponent(JSON.stringify({ userId: memberLegacyId }));
    const studyRows = await jsonRequest(`${PARSE_URL}/classes/DailyStudyRecord?where=${studyWhere}&limit=1000`, {}, true).catch(() => ({ results: [] }));
    for (const row of studyRows.results || []) await jsonRequest(`${PARSE_URL}/classes/DailyStudyRecord/${row.objectId}`, { method: 'DELETE' }, true).catch((error) => {
      console.error(`临时学习 addon 清理失败：${error.message}`);
      process.exitCode = 1;
    });
  }
  if (temporaryAppointmentObjectId) await jsonRequest(`${PARSE_URL}/classes/CourseAppointment/${temporaryAppointmentObjectId}`, { method: 'DELETE' }, true).catch((error) => {
    console.error(`临时预约清理失败：${error.message}`);
    process.exitCode = 1;
  });
  if (temporaryAppointmentId) {
    const sideEffectWhere = encodeURIComponent(JSON.stringify({ sourceKey: { $regex: `^cloud:e_order_update:${temporaryAppointmentId}:` } }));
    for (const className of ['CommonModel', 'MemoryPracticeRecord', 'UserExpDomP', 'UserUserPoint']) {
      const rows = await jsonRequest(`${PARSE_URL}/classes/${className}?where=${sideEffectWhere}&limit=1000`, {}, true).catch(() => ({ results: [] }));
      for (const row of rows.results || []) await jsonRequest(`${PARSE_URL}/classes/${className}/${row.objectId}`, { method: 'DELETE' }, true).catch((error) => {
        console.error(`临时预约副作用清理失败（${className}）：${error.message}`);
        process.exitCode = 1;
      });
    }
  }
  if (memberLegacyId) {
    const assessmentWhere = encodeURIComponent(JSON.stringify({ sourceKey: { $regex: `^cloud:content_add:${memberLegacyId}:` } }));
    const assessments = await jsonRequest(`${PARSE_URL}/classes/AssessmentProfile?where=${assessmentWhere}&limit=1000`, {}, true).catch(() => ({ results: [] }));
    for (const assessment of assessments.results || []) await jsonRequest(`${PARSE_URL}/classes/AssessmentProfile/${assessment.objectId}`, { method: 'DELETE' }, true).catch((error) => {
      console.error(`临时测评记录清理失败：${error.message}`);
      process.exitCode = 1;
    });
  }
  if (memberLegacyId) {
    const where = encodeURIComponent(JSON.stringify({ yhid: String(memberLegacyId) }));
    const practices = await jsonRequest(`${PARSE_URL}/classes/PracticeRecord?where=${where}&limit=1000`, {}, true).catch(() => ({ results: [] }));
    for (const practice of practices.results || []) await jsonRequest(`${PARSE_URL}/classes/PracticeRecord/${practice.objectId}`, { method: 'DELETE' }, true).catch((error) => {
      console.error(`临时学习进度清理失败：${error.message}`);
      process.exitCode = 1;
    });
  }
  if (teamChildId) {
    await jsonRequest(`${PARSE_URL}/users/${teamChildId}`, { method: 'DELETE' }, true).catch((error) => {
      console.error(`临时团队成员清理失败：${error.message}`);
      process.exitCode = 1;
    });
  }
  if (memberId) {
    await jsonRequest(`${PARSE_URL}/users/${memberId}`, { method: 'DELETE' }, true).catch((error) => {
      console.error(`临时普通用户清理失败：${error.message}`);
      process.exitCode = 1;
    });
  }
  if (coachId) {
    await jsonRequest(`${PARSE_URL}/users/${coachId}`, { method: 'DELETE' }, true).catch((error) => {
      console.error(`临时陪练用户清理失败：${error.message}`);
      process.exitCode = 1;
    });
  }
  if (userId) {
    await jsonRequest(`${PARSE_URL}/users/${userId}`, { method: 'DELETE' }, true).catch((error) => {
      console.error(`临时管理员清理失败：${error.message}`);
      process.exitCode = 1;
    });
  }
}