@gobing-ai/knowledge-kit 0.0.36 → 0.1.0

package/plugins/publishings/wechatmp-pub/dist/index.js

@@ -19831,6 +19831,83 @@ var init_runtime_node_bun = __esm(() => {
 // ../../plugins/publishings/wechatmp-pub/src/index.ts
 import { parseArgs } from "util";
 
+// ../../packages/kk-core/src/content-limits.ts
+var PLATFORM_CONTENT_LIMITS = Object.freeze({
+  schemaVersion: 5,
+  tagLimits: Object.freeze({
+    default: 7,
+    imageText: Object.freeze({
+      instagram: 5,
+      douyin: 5,
+      kuaishou: 4,
+      weixin: 1,
+      xiaohongshu: 10
+    }),
+    shortVideo: Object.freeze({
+      douyin: 5,
+      kuaishou: 4,
+      xiaohongshu: 10,
+      bilibili: 10,
+      zhihu: 5,
+      tiktok: 20,
+      youtube: 60
+    })
+  }),
+  titleCapabilities: Object.freeze({
+    dynamic: Object.freeze({
+      bilibili: Object.freeze({ max: 20, unit: "utf16_code_units" }),
+      zhihu: Object.freeze({ max: 50, unit: "utf16_code_units" }),
+      douban: Object.freeze({ max: 70, unit: "utf16_code_units" }),
+      x: null,
+      threads: null,
+      weibo: null,
+      jike: null,
+      zsxq: null,
+      toutiao: null,
+      juejin: null
+    }),
+    imageText: Object.freeze({
+      xiaohongshu: Object.freeze({ max: 20, unit: "xiaohongshu_title_weighted" }),
+      weixin: Object.freeze({ max: 20, unit: "utf16_code_units" }),
+      douyin: Object.freeze({ max: 20, unit: "utf16_code_units" }),
+      shipinhao: Object.freeze({ max: 22, unit: "utf16_code_units" }),
+      reddit: Object.freeze({ max: 300, unit: "utf16_code_units" })
+    }),
+    article: Object.freeze({
+      juejin: Object.freeze({ max: 100, unit: "utf16_code_units" }),
+      csdn: Object.freeze({ max: 100, unit: "utf16_code_units" }),
+      cnblogs: Object.freeze({ max: 128, unit: "utf16_code_units" }),
+      weibo: Object.freeze({ max: 30, unit: "utf16_code_units" }),
+      sspai: Object.freeze({ max: 80, unit: "utf16_code_units" })
+    }),
+    shortVideo: Object.freeze({
+      shipinhao: Object.freeze({ max: 16, unit: "utf16_code_units" }),
+      douyin: Object.freeze({ max: 30, unit: "utf16_code_units" }),
+      bilibili: Object.freeze({ max: 80, unit: "utf16_code_units" })
+    })
+  }),
+  bodyCapabilities: Object.freeze({
+    dynamic: Object.freeze({
+      threads: Object.freeze({ max: 500, unit: "unicode_code_points", behavior: "split_thread" }),
+      x: Object.freeze({ max: 280, unit: "weighted", behavior: "split_thread" }),
+      weibo: Object.freeze({ max: 2000, unit: "unicode_code_points" }),
+      jike: Object.freeze({ max: 1000, unit: "unicode_code_points" })
+    }),
+    imageText: Object.freeze({
+      xiaohongshu: Object.freeze({ max: 1000, unit: "unicode_code_points" }),
+      douyin: Object.freeze({ max: 1000, unit: "unicode_code_points" })
+    }),
+    article: Object.freeze({
+      wechatmp: Object.freeze({ max: 50000, unit: "unicode_code_points" }),
+      juejin: Object.freeze({ max: 50000, unit: "unicode_code_points" })
+    }),
+    shortVideo: Object.freeze({
+      douyin: Object.freeze({ max: 1000, unit: "unicode_code_points" }),
+      kuaishou: Object.freeze({ max: 1000, unit: "unicode_code_points" }),
+      shipinhao: Object.freeze({ max: 1000, unit: "unicode_code_points" })
+    })
+  })
+});
 // ../../packages/kk-core/src/kinds.ts
 init_zod();
 
@@ -19921,6 +19998,67 @@ var BrowserSessionDescriptorSchema = object({
     }
   }).optional()
 }).strict();
+var ContentCountUnitSchema = _enum([
+  "utf16_code_units",
+  "unicode_code_points",
+  "weighted",
+  "xiaohongshu_title_weighted"
+]);
+var LimitEntrySchema = object({
+  max: number2().int().positive(),
+  unit: ContentCountUnitSchema
+}).strict();
+var PublishingProfileLimitsSchema = object({
+  title: LimitEntrySchema.optional(),
+  body: LimitEntrySchema.optional()
+}).strict();
+var PublishingProfileRequiresSchema = object({
+  cover: boolean2().optional(),
+  orderedImages: boolean2().optional()
+}).strict();
+var PublishingProfileModeBindingSchema = object({
+  metadata: record(string2(), unknown())
+}).strict();
+var PublishingProfileModesSchema = object({
+  draft: PublishingProfileModeBindingSchema.optional(),
+  live: PublishingProfileModeBindingSchema.optional()
+}).strict().superRefine((modes, ctx) => {
+  if (modes.draft === undefined && modes.live === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'modes must define at least one of "draft" or "live"'
+    });
+  }
+});
+var PublishingProfileSchema = object({
+  format: string2().min(1),
+  locale: string2().regex(/^(source|[a-z]{2,3}(-[A-Za-z0-9]+)*)$/, {
+    message: 'locale must be "source" or a valid language tag'
+  }),
+  limits: PublishingProfileLimitsSchema.optional(),
+  requires: PublishingProfileRequiresSchema.optional(),
+  modes: PublishingProfileModesSchema
+}).strict();
+var PublishingCapabilitiesSchema = object({
+  defaultProfile: string2().min(1),
+  profiles: record(string2().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/), PublishingProfileSchema)
+}).strict().superRefine((data, ctx) => {
+  const keys = Object.keys(data.profiles);
+  if (keys.length === 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["profiles"],
+      message: "profiles record must be nonempty"
+    });
+  }
+  if (!(data.defaultProfile in data.profiles)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultProfile"],
+      message: `defaultProfile "${data.defaultProfile}" must reference a declared profile`
+    });
+  }
+});
 var PluginManifestSchemaBase = looseObject({
   name: string2().min(1),
   kind: PluginKindSchema,
@@ -19929,23 +20067,31 @@ var PluginManifestSchemaBase = looseObject({
   version: string2().optional(),
   description: string2().optional(),
   operations: record(string2(), PluginOperationSchema).optional(),
-  browserSession: BrowserSessionDescriptorSchema.optional()
+  browserSession: BrowserSessionDescriptorSchema.optional(),
+  publishing: PublishingCapabilitiesSchema.optional()
 });
 var PluginManifestSchema = PluginManifestSchemaBase.superRefine((manifest, ctx) => {
-  if (manifest.browserSession === undefined)
-    return;
-  if (manifest.kind !== "publish") {
-    ctx.addIssue({
-      code: "custom",
-      path: ["browserSession"],
-      message: `browserSession requires kind "publish", not "${manifest.kind}"`
-    });
+  if (manifest.browserSession !== undefined) {
+    if (manifest.kind !== "publish") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["browserSession"],
+        message: `browserSession requires kind "publish", not "${manifest.kind}"`
+      });
+    }
+    if (manifest.check === undefined) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["browserSession"],
+        message: "browserSession requires a check probe entry that owns the session routines"
+      });
+    }
   }
-  if (manifest.check === undefined) {
+  if (manifest.publishing !== undefined && manifest.kind !== "publish") {
     ctx.addIssue({
       code: "custom",
-      path: ["browserSession"],
-      message: "browserSession requires a check probe entry that owns the session routines"
+      path: ["publishing"],
+      message: `publishing requires kind "publish", not "${manifest.kind}"`
     });
   }
 });
@@ -20484,6 +20630,8 @@ async function ensureProfileDir2(profileDir, headless) {
     throw new BrowserProfileMissingError(profileDir);
   await mkdir2(profileDir, { recursive: true, mode: 448 });
 }
+// ../../packages/publish-harness/src/browser-anti-detection.ts
+var MAX_QUEUED_BYTES = 8 * 1024 * 1024;
 // ../../packages/publish-harness/src/browser.ts
 var DEFAULT_STEP_TIMEOUT_MS = 30000;
 var DEFAULT_POLL_MS = 500;
@@ -20687,380 +20835,344 @@ function editorTextScript(selector) {
 // ../../plugins/publishings/wechatmp-pub/src/index.ts
 init_dist();
 
-// ../../plugins/publishings/wechatmp-pub/src/page.ts
-var POLL_MS = 500;
-var STEP_TIMEOUT_MS = 30000;
-async function modalState(page) {
-  try {
-    const raw = await page.evaluate(`[...document.querySelectorAll('.weui-desktop-dialog__wrp, .weui-desktop-dialog')].some((d) => d.offsetWidth)`);
-    return raw === true ? "open" : raw === false ? "closed" : "unknown";
-  } catch {
-    return "unknown";
+// ../../plugins/publishings/wechatmp-pub/src/cgi.ts
+var MP_ORIGIN = "https://mp.weixin.qq.com";
+var FILETRANSFER_URL = `${MP_ORIGIN}/cgi-bin/filetransfer`;
+var CROPIMAGE_URL = `${MP_ORIGIN}/cgi-bin/cropimage`;
+var MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+var REQUEST_TIMEOUT_MS = 30000;
+var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var WIDE_COVER_ASPECT = 2.35;
+var SQUARE_COVER_ASPECT = 1;
+var EXTENSION_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp"
+};
+
+class WechatCgiError extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this.name = "WechatCgiError";
   }
 }
-async function tryFindAttachedSelector(page, selectors, timeoutMs = STEP_TIMEOUT_MS) {
-  let found;
-  await waitUntil(async () => {
-    for (const selector of selectors) {
-      const attached = await page.locator(selector).count().catch(() => 0);
-      if (attached > 0) {
-        found = selector;
-        return true;
-      }
-    }
+function isAllowedCdnUrl(candidate) {
+  try {
+    const url = new URL(candidate);
+    return url.protocol === "https:" && url.host === "mmbiz.qpic.cn";
+  } catch {
     return false;
-  }, timeoutMs);
-  return found;
+  }
 }
-async function tryFindSelector(page, selectors, timeoutMs = STEP_TIMEOUT_MS) {
-  let found;
-  await waitUntil(async () => {
-    const result = await trySelectors(page, selectors).catch(() => ({ found: false, selector: null }));
-    if (result.found && result.selector) {
-      found = result.selector;
-      return true;
-    }
-    return false;
-  }, timeoutMs);
-  return found;
+function centerCropRect(width, height, aspect) {
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width < 1 || height < 1) {
+    throw new WechatCgiError("invalid-dimensions", `image dimensions must be positive numbers, got ${width}x${height}`);
+  }
+  if (!Number.isFinite(aspect) || aspect <= 0) {
+    throw new WechatCgiError("invalid-dimensions", `crop aspect must be positive, got ${aspect}`);
+  }
+  let cropWidth = width;
+  let cropHeight = height;
+  if (width / height > aspect) {
+    cropWidth = height * aspect;
+  } else {
+    cropHeight = width / aspect;
+  }
+  const x1 = Math.floor((width - cropWidth) / 2);
+  const y1 = Math.floor((height - cropHeight) / 2);
+  return {
+    x1,
+    y1,
+    x2: Math.min(width, x1 + Math.round(cropWidth)),
+    y2: Math.min(height, y1 + Math.round(cropHeight))
+  };
 }
-async function findSelector(page, selectors, what, timeoutMs = STEP_TIMEOUT_MS) {
-  const found = await tryFindSelector(page, selectors, timeoutMs);
-  if (found === undefined) {
-    throw new Error(`${what}: none of [${selectors.join(" | ")}] visible within ${timeoutMs}ms`);
+function extensionMime(name) {
+  const lower = name.toLowerCase();
+  const dot = lower.lastIndexOf(".");
+  const mime = dot === -1 ? undefined : EXTENSION_MIME[lower.slice(dot)];
+  if (mime === undefined) {
+    throw new WechatCgiError("unsupported-extension", `accepted image extensions are PNG/JPEG/WebP, got '${name}'`);
   }
-  return found;
+  return mime;
 }
-async function findAttachedSelector(page, selectors, what, timeoutMs = STEP_TIMEOUT_MS) {
-  const found = await tryFindAttachedSelector(page, selectors, timeoutMs);
-  if (found === undefined) {
-    throw new Error(`${what}: none of [${selectors.join(" | ")}] attached within ${timeoutMs}ms`);
+function validateImageBytes(bytes, name) {
+  if (bytes.byteLength === 0) {
+    throw new WechatCgiError("empty-image", `image '${name}' is empty`);
   }
-  return found;
+  if (bytes.byteLength > MAX_IMAGE_BYTES) {
+    throw new WechatCgiError("image-too-large", `image '${name}' exceeds the ${MAX_IMAGE_BYTES}-byte bound`);
+  }
+  return { bytes, name, mime: extensionMime(name) };
 }
-async function followNewPage(pages, before, timeoutMs) {
-  const opened = await waitUntil(async () => pages().length > before, timeoutMs);
-  if (!opened)
-    return;
-  const all = pages();
-  return all[all.length - 1];
+async function readLocalImageBytes(path) {
+  const name = path.replaceAll("\\", "/").split("/").pop() ?? path;
+  extensionMime(name);
+  const file = Bun.file(path);
+  let stat;
+  try {
+    stat = await file.stat();
+  } catch {
+    throw new WechatCgiError("unreadable-file", `image is not a readable file: ${path}`);
+  }
+  if (!stat.isFile() || stat.size === 0) {
+    throw new WechatCgiError("unreadable-file", `image is not a nonempty regular file: ${path}`);
+  }
+  if (stat.size > MAX_IMAGE_BYTES) {
+    throw new WechatCgiError("image-too-large", `image '${path}' exceeds the ${MAX_IMAGE_BYTES}-byte bound`);
+  }
+  return validateImageBytes(new Uint8Array(await file.arrayBuffer()), name);
 }
-async function clickSelector(page, selector, timeoutMs = STEP_TIMEOUT_MS) {
-  await page.locator(selector).first().click({ timeout: timeoutMs });
+function cgiFetchExpression(spec) {
+  return `(async () => {
+        const spec = ${JSON.stringify(spec)};
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), spec.timeoutMs);
+        try {
+            const form = new FormData();
+            for (const key of Object.keys(spec.fields)) form.append(key, spec.fields[key]);
+            if (spec.file) {
+                const binary = atob(spec.file.base64);
+                const bytes = new Uint8Array(binary.length);
+                for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+                form.append(spec.file.field, new Blob([bytes], { type: spec.file.mime }), spec.file.filename);
+            }
+            const response = await fetch(spec.url, {
+                method: 'POST',
+                body: form,
+                credentials: 'include',
+                redirect: 'error',
+                signal: controller.signal,
+            });
+            if (!response.ok) return JSON.stringify({ kind: 'http-status', status: response.status });
+            if (!response.body) return JSON.stringify({ kind: 'error', detail: 'response has no body stream' });
+            const reader = response.body.getReader();
+            let total = 0;
+            const chunks = [];
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                total += value.byteLength;
+                if (total > spec.maxBytes) {
+                    controller.abort();
+                    return JSON.stringify({ kind: 'too-large' });
+                }
+                chunks.push(value);
+            }
+            const text = await new Blob(chunks).text();
+            return JSON.stringify({ kind: 'ok', status: response.status, text });
+        } catch (error) {
+            return JSON.stringify({ kind: 'error', detail: String(error) });
+        } finally {
+            clearTimeout(timer);
+        }
+    })()`;
 }
-async function fillSelector(page, selector, value) {
-  await page.locator(selector).first().fill(value);
+function stripQuery(detail) {
+  return detail.replace(/\?[^'"\\\s]*/g, "?\u2026");
 }
-function wrapPlaywrightPage(raw) {
-  const pw = raw;
-  return {
-    goto: (url, options) => pw.goto(url, { waitUntil: "domcontentloaded", ...options }).then(() => {
-      return;
-    }),
-    locator: (selector) => ({
-      count: () => pw.locator(selector).count(),
-      first: () => {
-        const loc = pw.locator(selector).first();
-        return {
-          count: () => loc.count(),
-          isVisible: (options) => loc.isVisible(options),
-          fill: (text, options) => loc.fill(text, options),
-          click: (options) => loc.click(options),
-          type: (text, options) => loc.pressSequentially(text, options),
-          waitFor: (options) => loc.waitFor(options),
-          textContent: async () => await loc.textContent() ?? "",
-          inputValue: () => loc.inputValue()
-        };
-      }
-    }),
-    setInputFiles: (selector, paths) => pw.setInputFiles(selector, paths),
-    url: () => pw.url(),
-    evaluate: (expression) => pw.evaluate(expression),
-    waitForTimeout: (ms) => pw.waitForTimeout(ms),
-    press: (key) => pw.keyboard.press(key),
-    frames: () => {
-      const source = raw;
-      return (source.frames?.() ?? []).map((frame) => ({
-        url: () => frame.url(),
-        locator: (selector) => ({ count: () => frame.locator(selector).count() })
-      }));
+async function postCgiForm(page, spec) {
+  let verdict;
+  const raw = await page.evaluate(cgiFetchExpression(spec));
+  if (typeof raw === "string") {
+    try {
+      verdict = JSON.parse(raw);
+    } catch {
+      verdict = undefined;
     }
-  };
+  }
+  if (verdict?.kind === "http-status") {
+    throw new WechatCgiError("http-status", `CGI call returned HTTP ${verdict.status}`);
+  }
+  if (verdict?.kind === "too-large") {
+    throw new WechatCgiError("response-too-large", `CGI response exceeded the ${MAX_RESPONSE_BYTES}-byte bound`);
+  }
+  if (verdict?.kind !== "ok") {
+    const detail = verdict?.kind === "error" ? stripQuery(verdict.detail) : "page returned no usable verdict";
+    throw new WechatCgiError("network-error", `CGI call failed before a usable response: ${detail}`);
+  }
+  return { status: verdict.status, text: verdict.text };
 }
-function wrapPlaywrightContext(raw, entryPage) {
-  const context = raw;
-  const cache = new WeakMap;
-  const wrap = (page) => {
-    const key = page;
-    const cached = cache.get(key);
-    if (cached !== undefined)
-      return cached;
-    const wrapped = wrapPlaywrightPage(page);
-    cache.set(key, wrapped);
-    return wrapped;
-  };
-  return {
-    page: wrap(entryPage),
-    pages: () => context.pages().map(wrap),
-    newPage: async () => wrap(await context.newPage()),
-    close: () => context.close()
-  };
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
 }
-async function waitForVisible(page, selector, timeoutMs, opts = {}) {
-  const visible = await waitUntil(async () => {
-    const found = await trySelectors(page, [selector]).catch(() => ({ found: false, selector: null }));
-    return found.found;
-  }, timeoutMs, POLL_MS);
-  if (visible)
-    return selector;
-  if (opts.required === false)
+function parseJsonBody(text, what) {
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    throw new WechatCgiError("bad-receipt", `${what}: response is not JSON`);
+  }
+  if (!isRecord(body)) {
+    throw new WechatCgiError("bad-receipt", `${what}: response is not a JSON object`);
+  }
+  return body;
+}
+function assertBaseResp(body, what) {
+  const base = body.base_resp;
+  if (base === undefined)
     return;
-  throw new Error(`${selector}: not visible within ${timeoutMs}ms`);
+  if (!isRecord(base)) {
+    throw new WechatCgiError("bad-receipt", `${what}: malformed base_resp`);
+  }
+  if (base.ret !== undefined && base.ret !== 0) {
+    throw new WechatCgiError("bad-receipt", `${what}: base_resp.ret=${String(base.ret)}`);
+  }
+  if (base.err_msg !== undefined && base.err_msg !== "ok") {
+    throw new WechatCgiError("bad-receipt", `${what}: err_msg=${String(base.err_msg)}`);
+  }
+}
+function parseFiletransferReceipt(text) {
+  const body = parseJsonBody(text, "filetransfer");
+  assertBaseResp(body, "filetransfer");
+  const content = body.content;
+  if (typeof content !== "string" || !/^\d+$/.test(content)) {
+    throw new WechatCgiError("bad-receipt", "filetransfer: content file ID is missing or not numeric");
+  }
+  const cdnUrl = body.cdn_url;
+  if (typeof cdnUrl !== "string" || !isAllowedCdnUrl(cdnUrl)) {
+    throw new WechatCgiError("bad-receipt", "filetransfer: cdn_url is missing or outside the allowed HTTPS CDN host");
+  }
+  const width = body.width;
+  const height = body.height;
+  if (typeof width !== "number" || typeof height !== "number" || width < 1 || height < 1) {
+    throw new WechatCgiError("bad-receipt", "filetransfer: receipt did not return usable image dimensions");
+  }
+  return { fileId: content, url: cdnUrl, width, height };
+}
+function parseCropMultiReceipt(text, crops) {
+  const body = parseJsonBody(text, "crop_multi");
+  assertBaseResp(body, "crop_multi");
+  const entries = Array.isArray(body.result) ? body.result : [];
+  const entryCount = entries.length;
+  if (entryCount !== 2) {
+    throw new WechatCgiError("bad-receipt", `crop_multi: expected exactly two result entries, got ${entryCount}`);
+  }
+  let wide;
+  let square;
+  entries.forEach((entry, index) => {
+    const dims = index === 0 ? crops[0] : crops[1];
+    if (!isRecord(entry)) {
+      throw new WechatCgiError("bad-receipt", `crop_multi: result entry ${index} is not an object`);
+    }
+    const cdnurl = entry.cdnurl;
+    const fileId = entry.file_id;
+    if (typeof cdnurl !== "string" || !isAllowedCdnUrl(cdnurl)) {
+      throw new WechatCgiError("bad-receipt", `crop_multi: entry ${index} cdnurl is outside the allowed HTTPS CDN host`);
+    }
+    if (typeof fileId !== "string" || fileId === "") {
+      throw new WechatCgiError("bad-receipt", `crop_multi: entry ${index} file_id is missing`);
+    }
+    const image = {
+      fileId,
+      url: cdnurl,
+      width: Math.max(1, dims.x2 - dims.x1),
+      height: Math.max(1, dims.y2 - dims.y1)
+    };
+    if (index === 0) {
+      wide = image;
+    } else {
+      square = image;
+    }
+  });
+  if (wide === undefined || square === undefined) {
+    throw new WechatCgiError("bad-receipt", "crop_multi: receipt did not fill both crop entries");
+  }
+  return [wide, square];
 }
-
-// ../../plugins/publishings/wechatmp-pub/src/enrich.ts
-var DIALOG = ".weui-desktop-dialog:visible";
-var CONFIRM = `${DIALOG} button:has-text("\u786E\u8BA4"), ${DIALOG} button:has-text("\u786E\u5B9A")`;
-var ROW_ORIGINAL = [
-  ".setting-group__switch.js_original_apply.js_edit_ori",
-  ".setting-group__switch.js_edit_ori",
-  ".js_edit_ori",
-  "text=\u539F\u521B"
-];
-var ROW_REWARD = [
-  ".setting-group__switch.js_reward_open",
-  ".js_reward_open",
-  ".js_reward_allow_click",
-  ".setting-group__switch.js_can_reward",
-  "text=\u8D5E\u8D4F"
-];
-var ROW_COLLECTION = [".allow_click_opr.js_article_tags_label", "text=\u5408\u96C6"];
-var ROW_URL = [".allow_click_opr.js_url_checkbox", "text=\u539F\u6587\u94FE\u63A5"];
-var ROW_CLAIM = ["#js_claim_source_area .frm_checkbox_label", "text=\u521B\u4F5C\u6765\u6E90"];
-var DIALOG_CONFIRM = CONFIRM;
-var TAG_INPUT = 'input[placeholder*="\u5408\u96C6"]';
-var REWARD_ACCOUNT = [
-  `${DIALOG} input[placeholder*="\u8D5E\u8D4F"]`,
-  `${DIALOG} input[placeholder*="\u8D26\u6237"]`,
-  `${DIALOG} input.frm_input`
-];
-var URL_INPUT = [`${DIALOG} input[type="url"]`, `${DIALOG} input[placeholder*="\u94FE\u63A5"]`, `${DIALOG} input.frm_input`];
-var ORIGINAL_DECLARATION = `${DIALOG} label:has(.js_original_type_radio):has-text("\u6587\u5B57\u539F\u521B")`;
-var ORIGINAL_AGREEMENT = `${DIALOG} .original_agreement`;
-var COLLECTION_SETTLE_MS = 1200;
-var STEP_RETRY_SETTLE_MS = 1000;
-var SWEEP_SETTLE_MS = 400;
-
-class CapabilityError extends Error {
+function buildUrl(base, params) {
+  return `${base}?${new URLSearchParams(params).toString()}`;
 }
-function norm(value) {
-  return typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+function randomRequestSalt() {
+  return Math.floor(Math.random() * 1e9);
 }
-var COMMITTED = {
-  original: `(() => {
-        const el = document.querySelector('#js_original, .js_ori_setting_checkbox');
-        return el ? el.checked === true : null;
-    })()`,
-  reward: `(() => {
-        const el = document.querySelector('#js_reward_setting_area .js_reward_setting_checkbox') ||
-                  document.querySelector('.js_reward_allow_click_cell .js_reward_setting');
-        return el ? el.checked === true : null;
-    })()`
-};
-var CLAIM_COMMITTED = `(() => {
-    const area = document.querySelector('#js_claim_source_area');
-    if (!area) return null;
-    const label = area.querySelector('.js_claim_source_selected');
-    const text = (label ? (label.textContent ?? '') : '').replace(/\\s+/g, ' ').trim();
-    const checkbox = area.querySelector('.js_claim_source, input[type=checkbox]');
-    const enabled = checkbox ? checkbox.checked === true : null;
-    return { enabled, text };
-})()`;
-async function readChecked(page, expression) {
+function filetransferUrl(session) {
+  return buildUrl(FILETRANSFER_URL, {
+    action: "upload_material",
+    f: "json",
+    scene: "8",
+    writetype: "doublewrite",
+    groupid: "1",
+    ticket_id: session.userName,
+    ticket: session.ticket,
+    svr_time: String(Math.floor(Date.now() / 1000)),
+    token: session.token,
+    lang: "zh_CN",
+    seq: String(randomRequestSalt()),
+    t: String(randomRequestSalt())
+  });
+}
+function assertMpOrigin(page) {
+  let origin;
   try {
-    const raw = await page.evaluate(expression);
-    return typeof raw === "boolean" ? raw : null;
+    origin = new URL(page.url()).origin;
   } catch {
-    return null;
-  }
-}
-async function enrichArticle(page, meta) {
-  const warnings = [];
-  const str = (key) => typeof meta[key] === "string" ? meta[key] : "";
-  const on = (key) => meta[key] === true;
-  const sweep = async () => {
-    const cancel = await trySelectors(page, ['button:has-text("\u53D6\u6D88")']);
-    if (cancel.found) {
-      try {
-        await page.locator(cancel.selector ?? "").first().click({ timeout: 2000 });
-      } catch {}
-    }
-    await page.press?.("Escape");
-    await page.waitForTimeout?.(SWEEP_SETTLE_MS);
-    const state = await modalState(page);
-    if (state === "open") {
-      for (const close of [".weui-desktop-dialog__close-btn", ".weui-desktop-dialog__close"]) {
-        const control = await tryFindSelector(page, [close], 1500);
-        if (control === undefined)
-          continue;
-        try {
-          await clickSelector(page, control, 2000);
-        } catch {}
-        break;
-      }
-      return await modalState(page) === "closed" ? "closed" : "unknown";
-    }
-    return state === "closed" ? "closed" : "unknown";
+    throw new WechatCgiError("wrong-origin", `page URL is not usable for CGI dispatch: ${page.url()}`);
+  }
+  if (origin !== MP_ORIGIN) {
+    throw new WechatCgiError("wrong-origin", `CGI dispatch requires page origin ${MP_ORIGIN}, got ${origin}`);
+  }
+}
+async function uploadCoverImage(page, session, input) {
+  assertMpOrigin(page);
+  const image = "path" in input ? await readLocalImageBytes(input.path) : validateImageBytes(input.bytes, input.name);
+  const now = Date.now();
+  const fields = {
+    type: image.mime,
+    id: `kk_${now}_${randomRequestSalt()}`,
+    name: image.name,
+    lastModifiedDate: new Date(now).toString(),
+    size: String(image.bytes.byteLength)
   };
-  const openRow = async (row, what) => {
-    for (const selector of row) {
-      const found = await trySelectors(page, [selector]);
-      if (found.found) {
-        await clickSelector(page, selector, 8000);
-        return;
-      }
-    }
-    throw new Error(`no ${what} row control among [${row.join(" | ")}]`);
-  };
-  const step = async (name, fn) => {
-    try {
-      await fn();
-      return "ok";
-    } catch (error) {
-      if (error instanceof CapabilityError) {
-        warnings.push(`${name}: ${error.message}`);
-        return "capability";
-      }
-    }
-    await sweep();
-    await page.waitForTimeout?.(STEP_RETRY_SETTLE_MS);
-    try {
-      await fn();
-      return "ok";
-    } catch (error) {
-      warnings.push(`${name}: ${(error instanceof Error ? error.message : String(error)).slice(0, 120)}`);
-      await sweep();
-      return "failed";
-    }
-  };
-  const residual = async (name) => {
-    const state = await modalState(page);
-    if (state === "closed")
-      return false;
-    warnings.push(state === "open" ? `${name}: dialog did not close \u2014 check the draft` : `${name}: dialog state unknown after cleanup \u2014 a residual overlay may block later steps`);
-    return true;
+  const { text } = await postCgiForm(page, {
+    url: filetransferUrl(session),
+    fields,
+    file: {
+      field: "file",
+      filename: image.name,
+      mime: image.mime,
+      base64: Buffer.from(image.bytes).toString("base64")
+    },
+    maxBytes: MAX_RESPONSE_BYTES,
+    timeoutMs: REQUEST_TIMEOUT_MS
+  });
+  return parseFiletransferReceipt(text);
+}
+async function cropCoverMulti(page, session, imageUrl, crops) {
+  assertMpOrigin(page);
+  const fields = {
+    imgurl: imageUrl,
+    size_count: "2",
+    token: session.token,
+    lang: "zh_CN",
+    f: "json",
+    ajax: "1"
   };
-  if (on("original")) {
-    const name = "\u539F\u521B\u58F0\u660E";
-    if (await readChecked(page, COMMITTED.original) !== true) {
-      const outcome = await step(name, async () => {
-        await openRow(ROW_ORIGINAL, "\u539F\u521B\u58F0\u660E");
-        await clickSelector(page, ORIGINAL_DECLARATION, 5000);
-        const agreement = await trySelectors(page, [ORIGINAL_AGREEMENT]);
-        if (agreement.found) {
-          await clickSelector(page, ORIGINAL_AGREEMENT, 3000);
-        }
-        await clickSelector(page, DIALOG_CONFIRM, 8000);
-      });
-      if (outcome !== "capability" && await readChecked(page, COMMITTED.original) !== true && !await residual(name)) {
-        warnings.push(`${name}: \u539F\u521B\u58F0\u660E\u672A\u751F\u6548\uFF0C\u8BF7\u624B\u52A8\u8BBE\u7F6E`);
-      }
-    }
-  }
-  if (on("reward")) {
-    const name = "\u8D5E\u8D4F";
-    if (await readChecked(page, COMMITTED.reward) !== true) {
-      const outcome = await step(name, async () => {
-        await openRow(ROW_REWARD, "\u8D5E\u8D4F");
-        const blocked = await tryFindSelector(page, [`${DIALOG} :has-text("\u524D\u5F80\u5F00\u901A")`, `${DIALOG} :has-text("\u65E0\u6CD5\u5F00\u542F")`], 1500);
-        if (blocked !== undefined)
-          throw new CapabilityError("\u9700\u8981\u8D5E\u8D4F\u8D26\u6237\uFF08\u8FD0\u8425\u8005\u5148\u5728\u5E73\u53F0\u5F00\u901A\uFF09\uFF0C\u5DF2\u8DF3\u8FC7\u81EA\u52A8\u586B\u5199");
-        const author = str("author");
-        if (author !== "") {
-          for (const selector of REWARD_ACCOUNT) {
-            const found = await trySelectors(page, [selector]);
-            if (!found.found)
-              continue;
-            const locator = page.locator(selector).first();
-            if (typeof locator.inputValue !== "function")
-              break;
-            const empty = norm(await locator.inputValue().catch(() => null)) === "";
-            if (empty)
-              await fillSelector(page, selector, author);
-            break;
-          }
-        }
-        await clickSelector(page, DIALOG_CONFIRM, 8000);
-      });
-      if (outcome !== "capability" && await readChecked(page, COMMITTED.reward) !== true && !await residual(name)) {
-        warnings.push(`${name}: \u8D5E\u8D4F\u672A\u751F\u6548\uFF0C\u8BF7\u624B\u52A8\u8BBE\u7F6E`);
-      }
-    }
-  }
-  const collection = str("collection");
-  if (collection !== "") {
-    const name = "\u5408\u96C6";
-    await step(name, async () => {
-      await openRow(ROW_COLLECTION, "\u5408\u96C6");
-      await waitForVisible(page, TAG_INPUT, 8000);
-      await fillSelector(page, TAG_INPUT, collection);
-      await page.waitForTimeout?.(COLLECTION_SETTLE_MS);
-      await clickSelector(page, `${DIALOG} :text("${collection}")`, 8000);
-      await clickSelector(page, DIALOG_CONFIRM, 8000);
-    });
-    await residual(name);
-  }
-  const originalUrl = str("originalUrl");
-  if (originalUrl !== "") {
-    const name = "\u539F\u6587\u94FE\u63A5";
-    const urlRow = await tryFindSelector(page, ROW_URL, 2000);
-    if (urlRow === undefined) {
-      warnings.push(`${name}: \u884C\u4E0D\u5B58\u5728\uFF08\u5F53\u524D\u516C\u4F17\u53F7\u4E0D\u652F\u6301\uFF09\uFF0C\u8BF7\u624B\u52A8\u5904\u7406\u6216\u79FB\u9664 originalUrl`);
-    } else {
-      await step(name, async () => {
-        await openRow(ROW_URL, "\u539F\u6587\u94FE\u63A5");
-        const field = await trySelectors(page, URL_INPUT);
-        if (!field.found)
-          throw new Error("no URL field in the \u539F\u6587\u94FE\u63A5 dialog");
-        await fillSelector(page, field.selector ?? URL_INPUT.join(", "), originalUrl);
-        await clickSelector(page, DIALOG_CONFIRM, 8000);
-      });
-      await residual(name);
-      const locator = page.locator(URL_INPUT[0] ?? "").first();
-      const committed = typeof locator.inputValue === "function" ? await locator.inputValue().catch(() => null) : null;
-      if (norm(committed) !== norm(originalUrl))
-        warnings.push(`${name}: \u5DF2\u63D0\u4EA4\u4F46\u672A\u8BFB\u53D6\u5230\u5DF2\u4FDD\u5B58\u7684\u94FE\u63A5\uFF0C\u8BF7\u6838\u5BF9`);
-    }
-  }
-  const claimSource = str("claimSource");
-  if (claimSource !== "") {
-    const name = "\u521B\u4F5C\u6765\u6E90";
-    const claimMatched = async () => {
-      try {
-        const raw = await page.evaluate(CLAIM_COMMITTED);
-        if (raw === null || typeof raw !== "object")
-          return null;
-        return raw.enabled === true && norm(raw.text) === norm(claimSource);
-      } catch {
-        return null;
-      }
-    };
-    if (await claimMatched() !== true) {
-      await step(name, async () => {
-        await openRow(ROW_CLAIM, "\u521B\u4F5C\u6765\u6E90");
-        const dialog = await waitForVisible(page, DIALOG, 3000, { required: false });
-        if (dialog !== undefined) {
-          await clickSelector(page, `${DIALOG} :text("${claimSource}")`, 8000);
-          await clickSelector(page, DIALOG_CONFIRM, 8000);
-        }
-      });
-    }
-    if (await claimMatched() !== true && !await residual(name)) {
-      warnings.push(`${name}: \u672A\u751F\u6548\uFF0C\u8BF7\u624B\u52A8\u8BBE\u7F6E`);
-    }
-  }
-  await sweep();
-  return warnings;
+  crops.forEach((crop, index) => {
+    fields[`size${index}_x1`] = String(crop.x1);
+    fields[`size${index}_y1`] = String(crop.y1);
+    fields[`size${index}_x2`] = String(crop.x2);
+    fields[`size${index}_y2`] = String(crop.y2);
+  });
+  const { text } = await postCgiForm(page, {
+    url: buildUrl(CROPIMAGE_URL, { action: "crop_multi" }),
+    fields,
+    maxBytes: MAX_RESPONSE_BYTES,
+    timeoutMs: REQUEST_TIMEOUT_MS
+  });
+  return parseCropMultiReceipt(text, crops);
+}
+async function uploadAndCropCover(page, session, input) {
+  const uploaded = await uploadCoverImage(page, session, input);
+  const crops = [
+    centerCropRect(uploaded.width, uploaded.height, WIDE_COVER_ASPECT),
+    centerCropRect(uploaded.width, uploaded.height, SQUARE_COVER_ASPECT)
+  ];
+  const [wide, square] = await cropCoverMulti(page, session, uploaded.url, crops);
+  return { wide, square, crops };
 }
 
 // ../../plugins/publishings/wechatmp-pub/src/modes.ts
@@ -21164,156 +21276,1132 @@ async function resolveBodyImages(content) {
     if (typeof path !== "string" || path.length === 0) {
       return { error: `images validation: images[${index}] carries no path` };
     }
-    candidates.push({ path, what: `metadata.images[${index}]` });
+    candidates.push({ path, what: `metadata.images[${index}]` });
+  }
+  const paths = [];
+  for (const { path, what } of candidates) {
+    if (!isAbsolute2(path)) {
+      return { error: `images validation: ${what} must be absolute, got '${path}'` };
+    }
+    if (!IMAGE_EXTENSIONS.test(path)) {
+      return {
+        error: `images validation: ${what} has unsupported extension (expected ${IMAGE_LIST}): '${path}'`
+      };
+    }
+    if (!await createNodeFileSystem().exists(path)) {
+      return { error: `images validation: ${what} does not exist: '${path}'` };
+    }
+    paths.push(path);
+  }
+  return { paths };
+}
+function deriveDigest(content) {
+  const explicit = content.metadata?.digest;
+  if (typeof explicit === "string")
+    return explicit;
+  const body = content.body ?? "";
+  const first = body.split(`
+`).map((line) => line.trim()).find((line) => line !== "");
+  return first === undefined ? undefined : first.slice(0, DERIVED_DIGEST_MAX);
+}
+function validatePublishStatus(content) {
+  const status = content.metadata?.publishStatus;
+  if (status !== undefined && status !== "draft" && status !== "public") {
+    return {
+      error: `publishStatus validation: unknown publishStatus '${String(status)}' (expected 'draft' or 'public')`
+    };
+  }
+  return {};
+}
+function validateTitle(content, operation) {
+  const limits = MODE_LIMITS[operation];
+  const title = content.title ?? "";
+  if (limits.titleRequired === true && title.trim().length === 0) {
+    return {
+      error: `title validation: Content.title is required for ${operation} (the editor's placeholder is \u8BF7\u5728\u8FD9\u91CC\u8F93\u5165\u6807\u9898)`
+    };
+  }
+  if (limits.titleMax !== undefined && title.length > limits.titleMax) {
+    return {
+      error: `title validation: Content.title is ${title.length} chars but ${operation} accepts \u2264${limits.titleMax}`
+    };
+  }
+  return {};
+}
+function validateDigest(content, operation) {
+  const max = MODE_LIMITS[operation].digestMax;
+  if (max === undefined)
+    return {};
+  const digest = deriveDigest(content);
+  if (digest !== undefined && digest.length > max) {
+    return { error: `digest validation: the \u6458\u8981 is ${digest.length} chars but ${operation} accepts \u2264${max}` };
+  }
+  return digest === undefined ? {} : { digest };
+}
+function validateAuthor(content, operation) {
+  const max = MODE_LIMITS[operation].authorMax;
+  const author = content.metadata?.author;
+  if (typeof author !== "string" || author.length === 0)
+    return {};
+  if (max !== undefined && author.length > max) {
+    return {
+      error: `author validation: Content.metadata.author is ${author.length} chars but ${operation} accepts \u2264${max}`
+    };
+  }
+  return { author };
+}
+async function validateModeInput(operation, content) {
+  const status = validatePublishStatus(content);
+  if (status.error)
+    return { error: status.error };
+  const title = validateTitle(content, operation);
+  if (title.error)
+    return { error: title.error };
+  const author = validateAuthor(content, operation);
+  if (author.error)
+    return { error: author.error };
+  switch (operation) {
+    case "\u6587\u7AE0": {
+      if ((content.body ?? "").trim().length === 0) {
+        return { error: "body validation: Content.body is required for \u6587\u7AE0" };
+      }
+      const digest = validateDigest(content, operation);
+      if (digest.error)
+        return { error: digest.error };
+      const images = await resolveBodyImages(content);
+      if (images.error)
+        return { error: images.error };
+      if ((images.paths ?? []).length === 0) {
+        return {
+          error: "cover validation: \u6587\u7AE0 takes its cover from a body image (\u9ED8\u8BA4\u9996\u56FE\u4E3A\u5C01\u9762) but none was supplied \u2014 set metadata.wechatmp.coverPath or metadata.images[]"
+        };
+      }
+      return {
+        input: {
+          operation,
+          images: images.paths ?? [],
+          ...digest.digest === undefined ? {} : { digest: digest.digest }
+        }
+      };
+    }
+    case "\u8D34\u56FE": {
+      const images = await resolveBodyImages(content);
+      if (images.error)
+        return { error: images.error };
+      if ((images.paths ?? []).length === 0) {
+        return {
+          error: "image validation: \u8D34\u56FE requires at least one image (metadata.images[] or metadata.wechatmp.coverPath)"
+        };
+      }
+      return { input: { operation, images: images.paths ?? [] } };
+    }
+    case "\u89C6\u9891": {
+      const video = await resolveMediaPath(content, {
+        key: "video",
+        label: "video validation",
+        extensions: VIDEO_EXTENSIONS,
+        list: VIDEO_LIST
+      });
+      if (video.error)
+        return { error: video.error };
+      return { input: { operation, video: video.path ?? "" } };
+    }
+    case "\u64AD\u5BA2": {
+      const audio = await resolveMediaPath(content, {
+        key: "audio",
+        label: "audio validation",
+        extensions: AUDIO_EXTENSIONS,
+        list: AUDIO_LIST
+      });
+      if (audio.error)
+        return { error: audio.error };
+      const cover = await resolveMediaPath(content, {
+        key: "coverImage",
+        label: "cover validation",
+        extensions: IMAGE_EXTENSIONS,
+        list: IMAGE_LIST
+      });
+      if (cover.error)
+        return { error: cover.error };
+      return { input: { operation, audio: audio.path ?? "", cover: cover.path ?? "" } };
+    }
+  }
+}
+
+// ../../plugins/publishings/wechatmp-pub/src/cgi-draft.ts
+var MP_ORIGIN2 = "https://mp.weixin.qq.com";
+var CREATE_URL = `${MP_ORIGIN2}/cgi-bin/operate_appmsg`;
+var APPMSG_URL = `${MP_ORIGIN2}/cgi-bin/appmsg`;
+var MAX_RESPONSE_BYTES2 = 2 * 1024 * 1024;
+var REQUEST_TIMEOUT_MS2 = 30000;
+var MAX_SNAPSHOT_CHARS = 2 * 1024 * 1024;
+var DEFAULT_OPERATION = "\u6587\u7AE0";
+
+class WechatCgiDraftError extends Error {
+  code;
+  stage;
+  metadata;
+  constructor(code, stage, message, metadata = {}) {
+    super(message);
+    this.code = code;
+    this.stage = stage;
+    this.metadata = metadata;
+    this.name = "WechatCgiDraftError";
+  }
+}
+var ALLOWED_METADATA_KEYS = new Set([
+  "operation",
+  "publishStatus",
+  "title",
+  "body",
+  "digest",
+  "author",
+  "contentId",
+  "source",
+  "sourceUrl",
+  "tags",
+  "categories",
+  "coverPath",
+  "images"
+]);
+function isNonemptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function certifyCgiDraft(content) {
+  const metadata = content.metadata ?? {};
+  function refuse(detail) {
+    throw new WechatCgiDraftError("ineligible", "eligibility", `content is not eligible for the CGI draft path: ${detail}`);
+  }
+  const operation = metadata.operation ?? DEFAULT_OPERATION;
+  if (operation !== DEFAULT_OPERATION) {
+    refuse(`operation is not ${DEFAULT_OPERATION}`);
+  }
+  if (metadata.publishStatus !== undefined && metadata.publishStatus !== "draft") {
+    refuse("publishStatus is not draft");
+  }
+  if (!isNonemptyString(content.title)) {
+    refuse("title is missing or empty");
+  }
+  if (!isNonemptyString(content.body)) {
+    refuse("body is missing or empty");
+  }
+  for (const key of ["digest", "author"]) {
+    if (metadata[key] !== undefined && typeof metadata[key] !== "string") {
+      refuse(`${key} is present but not a string`);
+    }
+  }
+  for (const key of Object.keys(metadata)) {
+    if (!ALLOWED_METADATA_KEYS.has(key)) {
+      refuse(`metadata key '${key}' is outside the plain-article set`);
+    }
+  }
+  return {
+    operation: DEFAULT_OPERATION,
+    publishStatus: "draft",
+    title: content.title,
+    body: content.body,
+    digest: typeof metadata.digest === "string" ? metadata.digest : "",
+    author: typeof metadata.author === "string" ? metadata.author : ""
+  };
+}
+function assertEligibleCgiDraft(content) {
+  certifyCgiDraft(content);
+}
+function stripQuery2(detail) {
+  return detail.replace(/\?[^'"\\\s]*/g, "?\u2026");
+}
+function assertMpOrigin2(page) {
+  let origin;
+  try {
+    origin = new URL(page.url()).origin;
+  } catch {
+    throw new WechatCgiDraftError("request-failed", "assert-origin", `page URL is not usable for CGI dispatch: ${page.url()}`);
+  }
+  if (origin !== MP_ORIGIN2) {
+    throw new WechatCgiDraftError("request-failed", "assert-origin", `CGI dispatch requires page origin ${MP_ORIGIN2}, got ${origin}`);
+  }
+}
+function extractSessionExpression() {
+  return `(function () {
+    const fields = {};
+    const urlToken = new URLSearchParams(location.search).get('token');
+    if (urlToken !== null && /^\\d{4,32}$/.test(urlToken)) fields.token = urlToken;
+    const snapshot = document.documentElement.outerHTML.slice(0, ${MAX_SNAPSHOT_CHARS});
+    const first = (regex) => {
+        const match = regex.exec(snapshot);
+        return match === null ? undefined : match[1];
+    };
+    // URL token wins, but ticket/user_name/uin are scan-only: a URL-token page still needs them,
+    // so only the token lookup is skipped when the URL already supplied it (task 0290 chunk C bugfix).
+    if (!fields.token) {
+        const token = first(/\\btoken\\s*=\\s*['"](\\d{4,32})['"]/);
+        if (token !== undefined) fields.token = token;
+    }
+    const ticketId = first(/\\bticket_id\\s*=\\s*['"]([A-Za-z0-9]{8,128})['"]/);
+    if (ticketId !== undefined) fields.ticketId = ticketId;
+    const ticket = first(/\\bticket\\s*=\\s*['"]([A-Za-z0-9]{8,128})['"]/);
+    if (ticket !== undefined) fields.ticket = ticket;
+    const userName = first(/\\buser_name\\s*=\\s*['"](@[A-Za-z0-9_-]{1,63}|gh_[A-Za-z0-9_-]{1,61})['"]/);
+    if (userName !== undefined) fields.userName = userName;
+    const uin = first(/\\buin\\s*=\\s*['"](\\d{1,32})['"]/);
+    if (uin !== undefined) fields.uin = uin;
+    return JSON.stringify({ kind: 'ok', ...fields });
+})()`;
+}
+function readSessionFields(raw) {
+  if (typeof raw !== "string")
+    return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (!isRecord2(parsed))
+    return {};
+  const field = (key) => {
+    const value = parsed[key];
+    return typeof value === "string" && value !== "" ? value : undefined;
+  };
+  return {
+    token: field("token"),
+    ticket: field("ticket"),
+    ticketId: field("ticketId"),
+    userName: field("userName"),
+    uin: field("uin")
+  };
+}
+async function extractWechatCgiSession(page) {
+  assertMpOrigin2(page);
+  let raw;
+  try {
+    raw = await page.evaluate(extractSessionExpression());
+  } catch (error) {
+    throw new WechatCgiDraftError("session-missing", "extract-session", `session extraction failed inside the console page: ${stripQuery2(String(error))}`);
+  }
+  const fields = readSessionFields(raw);
+  const userName = fields.userName ?? fields.ticketId;
+  const { token, ticket } = fields;
+  if (token === undefined || ticket === undefined || userName === undefined) {
+    const missing = [
+      ...token === undefined ? ["token"] : [],
+      ...ticket === undefined ? ["ticket"] : [],
+      ...userName === undefined ? ["user_name"] : []
+    ];
+    throw new WechatCgiDraftError("session-missing", "extract-session", `authenticated session field(s) missing on the console page: ${missing.join(", ")}`);
+  }
+  return { token, ticket, userName, uin: fields.uin };
+}
+function buildUrl2(base, params) {
+  return `${base}?${new URLSearchParams(params).toString()}`;
+}
+function randomHex16() {
+  const bytes = crypto.getRandomValues(new Uint8Array(8));
+  let hex = "";
+  for (const byte of bytes)
+    hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function buildCreateArticlePayload(session, content, media, opts) {
+  const metadata = content.metadata ?? {};
+  const plain = (key) => {
+    const value = metadata[key];
+    return typeof value === "string" ? value : "";
+  };
+  const fields = {
+    token: session.token,
+    lang: "zh_CN",
+    f: "json",
+    ajax: "1",
+    random: opts?.random ?? randomHex16(),
+    AppMsgId: "",
+    count: "1",
+    data_seq: "0",
+    operate_from: "Chrome",
+    isnew: "0",
+    type: "77",
+    title0: content.title ?? "",
+    author0: plain("author"),
+    digest0: deriveDigest(content) ?? "",
+    auto_gen_digest0: "0",
+    content0: media.html,
+    sourceurl0: "",
+    cdn_url0: media.cover.wide.url,
+    cdn_235_1_url0: media.cover.wide.url,
+    cdn_1_1_url0: media.cover.square.url,
+    cdn_url_back0: media.cover.wide.url,
+    crop_list0: JSON.stringify(media.cover.crops),
+    share_page_type0: "0",
+    share_imageinfo0: JSON.stringify({ list: [] }),
+    categories_list0: "[]",
+    compose_info0: JSON.stringify({ list: "" })
+  };
+  return {
+    url: buildUrl2(CREATE_URL, {
+      t: "ajax-response",
+      sub: "create",
+      type: "77",
+      token: session.token,
+      lang: "zh_CN"
+    }),
+    fields
+  };
+}
+function cgiFetchExpression2(spec) {
+  return `(async () => {
+    const spec = ${JSON.stringify(spec)};
+    try {
+        const init = {
+            method: spec.method,
+            credentials: 'include',
+            redirect: 'error',
+            signal: AbortSignal.timeout(spec.timeoutMs),
+        };
+        if (spec.method === 'POST') {
+            const form = new FormData();
+            for (const key of Object.keys(spec.fields)) form.append(key, spec.fields[key]);
+            init.body = form;
+        }
+        const response = await fetch(spec.url, init);
+        if (!response.ok) return JSON.stringify({ kind: 'http-status', status: response.status });
+        if (!response.body) return JSON.stringify({ kind: 'error', detail: 'response has no body stream' });
+        const reader = response.body.getReader();
+        let total = 0;
+        const chunks = [];
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            total += value.byteLength;
+            if (total > spec.maxBytes) return JSON.stringify({ kind: 'too-large' });
+            chunks.push(value);
+        }
+        const text = await new Blob(chunks).text();
+        return JSON.stringify({ kind: 'ok', status: response.status, text });
+    } catch (error) {
+        return JSON.stringify({ kind: 'error', detail: String(error) });
+    }
+})()`;
+}
+async function evaluateCgiVerdict(page, expression) {
+  const raw = await page.evaluate(expression);
+  if (typeof raw !== "string")
+    return;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return;
+  }
+}
+function ambiguousSubmission(stage, detail) {
+  return new WechatCgiDraftError("ambiguous-submission", stage, detail, { ambiguousSubmission: true });
+}
+async function createWechatArticleDraft(page, session, content, media) {
+  assertEligibleCgiDraft(content);
+  assertMpOrigin2(page);
+  const payload = buildCreateArticlePayload(session, content, media);
+  let createVerdict;
+  try {
+    createVerdict = await evaluateCgiVerdict(page, cgiFetchExpression2({
+      url: payload.url,
+      method: "POST",
+      fields: payload.fields,
+      maxBytes: MAX_RESPONSE_BYTES2,
+      timeoutMs: REQUEST_TIMEOUT_MS2
+    }));
+  } catch (error) {
+    throw ambiguousSubmission("create-dispatch", `operate_appmsg create ended before a receipt returned: ${stripQuery2(String(error))}`);
+  }
+  if (createVerdict?.kind === "http-status") {
+    throw ambiguousSubmission("create-dispatch", `operate_appmsg create returned HTTP ${createVerdict.status}`);
+  }
+  if (createVerdict?.kind === "too-large") {
+    throw ambiguousSubmission("create-dispatch", `create response exceeded the ${MAX_RESPONSE_BYTES2}-byte bound`);
+  }
+  if (createVerdict?.kind !== "ok") {
+    const detail = createVerdict?.kind === "error" ? stripQuery2(createVerdict.detail) : "page returned no usable verdict";
+    throw ambiguousSubmission("create-dispatch", `create failed before a usable response: ${detail}`);
+  }
+  let body;
+  try {
+    body = JSON.parse(createVerdict.text);
+  } catch {
+    throw ambiguousSubmission("create-receipt", "create receipt is not JSON");
+  }
+  if (!isRecord2(body)) {
+    throw ambiguousSubmission("create-receipt", "create receipt is not a JSON object");
+  }
+  if (body.ret !== undefined && body.ret !== 0) {
+    throw new WechatCgiDraftError("receipt-invalid", "create-receipt", `operate_appmsg create refused: ret=${String(body.ret)}`);
+  }
+  const receipt = isRecord2(body.appMsgInfo) ? body.appMsgInfo : body;
+  const rawId = receipt.appMsgId;
+  const appMsgId = typeof rawId === "string" || typeof rawId === "number" ? String(rawId) : undefined;
+  if (appMsgId === undefined || !/^-?\d{1,12}$/.test(appMsgId)) {
+    throw ambiguousSubmission("create-receipt", "create receipt did not return a safe numeric appMsgId");
+  }
+  const listUrl = buildUrl2(APPMSG_URL, {
+    action: "list_ex",
+    begin: "0",
+    count: "5",
+    token: session.token,
+    lang: "zh_CN",
+    f: "json"
+  });
+  let listVerdict;
+  try {
+    listVerdict = await evaluateCgiVerdict(page, cgiFetchExpression2({
+      url: listUrl,
+      method: "GET",
+      fields: {},
+      maxBytes: MAX_RESPONSE_BYTES2,
+      timeoutMs: REQUEST_TIMEOUT_MS2
+    }));
+  } catch (error) {
+    throw new WechatCgiDraftError("readback-failed", "readback", `draft list readback ended before a receipt returned: ${stripQuery2(String(error))}`);
+  }
+  if (listVerdict?.kind !== "ok") {
+    const detail = listVerdict?.kind === "http-status" ? `HTTP ${listVerdict.status}` : listVerdict?.kind === "too-large" ? `${MAX_RESPONSE_BYTES2}-byte bound exceeded` : listVerdict?.kind === "error" ? stripQuery2(listVerdict.detail) : "page returned no usable verdict";
+    throw new WechatCgiDraftError("readback-failed", "readback", `draft list readback failed: ${detail}`);
+  }
+  let list;
+  try {
+    list = JSON.parse(listVerdict.text);
+  } catch {
+    throw new WechatCgiDraftError("readback-failed", "readback", "draft list receipt is not JSON");
+  }
+  const items = isRecord2(list) && Array.isArray(list.app_msg_list) ? list.app_msg_list : [];
+  const confirmed = items.some((item) => isRecord2(item) && item.title === content.title && (String(item.app_id) === appMsgId || String(item.appmsgid) === appMsgId));
+  if (!confirmed) {
+    throw new WechatCgiDraftError("readback-failed", "readback", "draft list did not confirm an item matching the created appMsgId and title");
+  }
+  return {
+    appMsgId,
+    editPath: `/cgi-bin/appmsg?t=media/appmsg_edit&action=edit&isNew=0&type=77&appmsgid=${appMsgId}`
+  };
+}
+
+// ../../plugins/publishings/wechatmp-pub/src/cgi-media.ts
+var MP_ORIGIN3 = "https://mp.weixin.qq.com";
+var UPLOADIMG2CDN_URL = `${MP_ORIGIN3}/cgi-bin/uploadimg2cdn`;
+var MAX_RESPONSE_BYTES3 = 2 * 1024 * 1024;
+var REQUEST_TIMEOUT_MS3 = 30000;
+var TOTAL_DEADLINE_MS = 180000;
+var MAX_AGGREGATE_BYTES = 20 * 1024 * 1024;
+var MAX_BODY_SOURCES = 30;
+var MAX_SOURCE_DETAIL_LENGTH = 120;
+
+class WechatMediaError extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this.name = "WechatMediaError";
+  }
+}
+function safeSource(source) {
+  const bare = source.replace(/[?#].*$/, "");
+  return bare.length > MAX_SOURCE_DETAIL_LENGTH ? `${bare.slice(0, MAX_SOURCE_DETAIL_LENGTH)}\u2026` : bare;
+}
+function stripQuery3(detail) {
+  return detail.replace(/\?[^'"\\\s]*/g, "?\u2026");
+}
+function assertMpOrigin3(page) {
+  let origin;
+  try {
+    origin = new URL(page.url()).origin;
+  } catch {
+    throw new WechatMediaError("wrong-origin", `page URL is not usable for media preparation: ${page.url()}`);
+  }
+  if (origin !== MP_ORIGIN3) {
+    throw new WechatMediaError("wrong-origin", `media preparation requires page origin ${MP_ORIGIN3}, got ${origin}`);
+  }
+}
+function assertDeadline(deadlineAt) {
+  if (Date.now() > deadlineAt) {
+    throw new WechatMediaError("deadline-exceeded", `article media preparation exceeded the ${TOTAL_DEADLINE_MS}ms deadline`);
+  }
+}
+function assertPublicHttpSource(source) {
+  let url;
+  try {
+    url = new URL(source);
+  } catch {
+    throw new WechatMediaError("unmapped-source", `body image source is not absolute and has no localImages mapping: ${safeSource(source)}`);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new WechatMediaError("unmapped-source", `body image source scheme ${url.protocol} requires a localImages mapping: ${safeSource(source)}`);
+  }
+  if (url.username !== "" || url.password !== "") {
+    throw new WechatMediaError("unmapped-source", `body image source carries credentials and is not transferable: ${safeSource(source)}`);
+  }
+  if (isLocalHostLiteral(url.hostname)) {
+    throw new WechatMediaError("unmapped-source", `body image source is a local-IP literal and is not transferable: ${safeSource(source)}`);
+  }
+}
+function isLocalHostLiteral(hostname) {
+  const host = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  return host === "localhost" || host === "::1" || host === "0.0.0.0" || /^127\./.test(host) || /^10\./.test(host) || /^192\.168\./.test(host) || /^169\.254\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host) || /^(f[cd]|fe80)/.test(host);
+}
+function parseArticleExpression(html) {
+  return `(function () {
+    const doc = new DOMParser().parseFromString(${JSON.stringify(html)}, 'text/html');
+    const dangerous = (value) => {
+        const compact = String(value).toLowerCase().replace(/\\s+/g, '');
+        return ['javascript:', 'data:', 'vbscript:'].some((scheme) => compact.startsWith(scheme));
+    };
+    doc.body.querySelectorAll('*').forEach((el) => {
+        [...el.attributes].forEach((attr) => {
+            const name = attr.name.toLowerCase();
+            if (name.startsWith('on') || dangerous(attr.value)) el.removeAttribute(attr.name);
+        });
+    });
+    doc.body.querySelectorAll('a[href]').forEach((a) => {
+        const span = doc.createElement('span');
+        while (a.firstChild) span.appendChild(a.firstChild);
+        a.replaceWith(span);
+    });
+    const sources = [];
+    const seen = new Set();
+    doc.body.querySelectorAll('img').forEach((img) => {
+        const src = img.getAttribute('src') || '';
+        if (src !== '' && !seen.has(src)) {
+            seen.add(src);
+            sources.push(src);
+        }
+    });
+    return JSON.stringify({ kind: 'ok', sources, html: doc.body.innerHTML });
+})()`;
+}
+function applyReplacementsExpression(html, replacements) {
+  return `(function () {
+    const doc = new DOMParser().parseFromString(${JSON.stringify(html)}, 'text/html');
+    const map = ${JSON.stringify(replacements)};
+    doc.body.querySelectorAll('img').forEach((img) => {
+        const src = img.getAttribute('src') || '';
+        if (map[src]) img.setAttribute('src', map[src]);
+    });
+    return JSON.stringify({ kind: 'ok', html: doc.body.innerHTML });
+})()`;
+}
+function transferExpression(spec) {
+  return `(async () => {
+    const spec = ${JSON.stringify(spec)};
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), ${REQUEST_TIMEOUT_MS3});
+    try {
+        const form = new FormData();
+        for (const key of Object.keys(spec.fields)) form.append(key, spec.fields[key]);
+        const response = await fetch(spec.url, {
+            method: 'POST',
+            body: form,
+            credentials: 'include',
+            redirect: 'error',
+            signal: controller.signal,
+        });
+        if (!response.ok) return JSON.stringify({ kind: 'http-status', status: response.status });
+        if (!response.body) return JSON.stringify({ kind: 'error', detail: 'response has no body stream' });
+        const reader = response.body.getReader();
+        let total = 0;
+        const chunks = [];
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            total += value.byteLength;
+            if (total > spec.maxBytes) {
+                controller.abort();
+                return JSON.stringify({ kind: 'too-large' });
+            }
+            chunks.push(value);
+        }
+        const text = await new Blob(chunks).text();
+        return JSON.stringify({ kind: 'ok', text });
+    } catch (error) {
+        return JSON.stringify({ kind: 'error', detail: String(error) });
+    } finally {
+        clearTimeout(timer);
+    }
+})()`;
+}
+async function evaluateJson(page, expression, what) {
+  const raw = await page.evaluate(expression);
+  if (typeof raw !== "string") {
+    throw new WechatMediaError("transfer-failed", `${what}: page returned no usable verdict`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new WechatMediaError("transfer-failed", `${what}: page verdict is not JSON`);
+  }
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseTransferReceipt(text, source) {
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    throw new WechatMediaError("bad-transfer-receipt", `uploadimg2cdn: response is not JSON for ${safeSource(source)}`);
+  }
+  if (!isRecord3(body) || body.errcode !== 0) {
+    throw new WechatMediaError("bad-transfer-receipt", `uploadimg2cdn: errcode=${String(isRecord3(body) ? body.errcode : body)} for ${safeSource(source)}`);
+  }
+  const fileId = body.file_id;
+  const url = body.url;
+  if (typeof fileId !== "string" || fileId === "" || typeof url !== "string" || !isAllowedCdnUrl(url)) {
+    throw new WechatMediaError("bad-transfer-receipt", `uploadimg2cdn: file_id/url missing or outside the allowed HTTPS CDN host for ${safeSource(source)}`);
+  }
+  return { fileId, url, width: 0, height: 0 };
+}
+async function transferPublicImage(page, session, source) {
+  const query = new URLSearchParams({
+    lang: "zh_CN",
+    token: session.token,
+    t: String(Math.floor(Math.random() * 1e9))
+  });
+  const verdict = await evaluateJson(page, transferExpression({
+    url: `${UPLOADIMG2CDN_URL}?${query.toString()}`,
+    fields: {
+      imgurl: source,
+      t: "ajax-editor-upload-img",
+      token: session.token,
+      lang: "zh_CN",
+      f: "json",
+      ajax: "1"
+    },
+    maxBytes: MAX_RESPONSE_BYTES3
+  }), "uploadimg2cdn");
+  if (verdict.kind === "http-status") {
+    throw new WechatMediaError("transfer-failed", `uploadimg2cdn returned HTTP ${verdict.status}`);
+  }
+  if (verdict.kind === "too-large") {
+    throw new WechatMediaError("transfer-failed", `uploadimg2cdn response exceeded the ${MAX_RESPONSE_BYTES3}-byte bound`);
+  }
+  if (verdict.kind !== "ok" || typeof verdict.text !== "string") {
+    const detail = verdict.kind === "error" ? stripQuery3(verdict.detail) : "page returned no usable verdict";
+    throw new WechatMediaError("transfer-failed", `uploadimg2cdn failed before a usable response: ${detail}`);
+  }
+  return parseTransferReceipt(verdict.text, source);
+}
+async function prepareArticleMedia(page, session, input) {
+  assertMpOrigin3(page);
+  const deadlineAt = Date.now() + TOTAL_DEADLINE_MS;
+  const parsed = await evaluateJson(page, parseArticleExpression(input.html), "article body parse");
+  if (parsed.kind !== "ok" || !Array.isArray(parsed.sources) || typeof parsed.html !== "string") {
+    throw new WechatMediaError("transfer-failed", "article body parse did not return a usable verdict");
+  }
+  if (parsed.sources.length > MAX_BODY_SOURCES) {
+    throw new WechatMediaError("too-many-sources", `article body has ${parsed.sources.length} distinct image sources, bound is ${MAX_BODY_SOURCES}`);
+  }
+  assertDeadline(deadlineAt);
+  const cover = await uploadAndCropCover(page, session, { path: input.coverPath });
+  const replacements = {};
+  const images = [];
+  let aggregateBytes = 0;
+  for (const source of parsed.sources) {
+    assertDeadline(deadlineAt);
+    if (isAllowedCdnUrl(source))
+      continue;
+    const mappedPath = input.localImages[source];
+    let uploaded;
+    if (mappedPath !== undefined) {
+      const image = await readLocalImageBytes(mappedPath);
+      aggregateBytes += image.bytes.byteLength;
+      if (aggregateBytes > MAX_AGGREGATE_BYTES) {
+        throw new WechatMediaError("aggregate-too-large", `local body images exceed the ${MAX_AGGREGATE_BYTES}-byte aggregate bound`);
+      }
+      uploaded = await uploadCoverImage(page, session, { path: mappedPath });
+    } else {
+      assertPublicHttpSource(source);
+      uploaded = await transferPublicImage(page, session, source);
+    }
+    replacements[source] = uploaded.url;
+    images.push(uploaded);
+  }
+  const applied = await evaluateJson(page, applyReplacementsExpression(parsed.html, replacements), "CDN replacement");
+  if (applied.kind !== "ok" || typeof applied.html !== "string") {
+    throw new WechatMediaError("transfer-failed", "CDN replacement did not return a usable verdict");
+  }
+  return { html: applied.html, cover, images };
+}
+
+// ../../plugins/publishings/wechatmp-pub/src/page.ts
+var POLL_MS = 500;
+var STEP_TIMEOUT_MS = 30000;
+async function modalState(page) {
+  try {
+    const raw = await page.evaluate(`[...document.querySelectorAll('.weui-desktop-dialog__wrp, .weui-desktop-dialog')].some((d) => d.offsetWidth)`);
+    return raw === true ? "open" : raw === false ? "closed" : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function tryFindAttachedSelector(page, selectors, timeoutMs = STEP_TIMEOUT_MS) {
+  let found;
+  await waitUntil(async () => {
+    for (const selector of selectors) {
+      const attached = await page.locator(selector).count().catch(() => 0);
+      if (attached > 0) {
+        found = selector;
+        return true;
+      }
+    }
+    return false;
+  }, timeoutMs);
+  return found;
+}
+async function tryFindSelector(page, selectors, timeoutMs = STEP_TIMEOUT_MS) {
+  let found;
+  await waitUntil(async () => {
+    const result = await trySelectors(page, selectors).catch(() => ({ found: false, selector: null }));
+    if (result.found && result.selector) {
+      found = result.selector;
+      return true;
+    }
+    return false;
+  }, timeoutMs);
+  return found;
+}
+async function findSelector(page, selectors, what, timeoutMs = STEP_TIMEOUT_MS) {
+  const found = await tryFindSelector(page, selectors, timeoutMs);
+  if (found === undefined) {
+    throw new Error(`${what}: none of [${selectors.join(" | ")}] visible within ${timeoutMs}ms`);
+  }
+  return found;
+}
+async function findAttachedSelector(page, selectors, what, timeoutMs = STEP_TIMEOUT_MS) {
+  const found = await tryFindAttachedSelector(page, selectors, timeoutMs);
+  if (found === undefined) {
+    throw new Error(`${what}: none of [${selectors.join(" | ")}] attached within ${timeoutMs}ms`);
+  }
+  return found;
+}
+async function followNewPage(pages, before, timeoutMs) {
+  const opened = await waitUntil(async () => pages().length > before, timeoutMs);
+  if (!opened)
+    return;
+  const all = pages();
+  return all[all.length - 1];
+}
+async function clickSelector(page, selector, timeoutMs = STEP_TIMEOUT_MS) {
+  await page.locator(selector).first().click({ timeout: timeoutMs });
+}
+async function fillSelector(page, selector, value) {
+  await page.locator(selector).first().fill(value);
+}
+function wrapPlaywrightPage(raw) {
+  const pw = raw;
+  return {
+    goto: (url, options) => pw.goto(url, { waitUntil: "domcontentloaded", ...options }).then(() => {
+      return;
+    }),
+    locator: (selector) => ({
+      count: () => pw.locator(selector).count(),
+      first: () => {
+        const loc = pw.locator(selector).first();
+        return {
+          count: () => loc.count(),
+          isVisible: (options) => loc.isVisible(options),
+          fill: (text, options) => loc.fill(text, options),
+          click: (options) => loc.click(options),
+          type: (text, options) => loc.pressSequentially(text, options),
+          waitFor: (options) => loc.waitFor(options),
+          textContent: async () => await loc.textContent() ?? "",
+          inputValue: () => loc.inputValue()
+        };
+      }
+    }),
+    setInputFiles: (selector, paths) => pw.setInputFiles(selector, paths),
+    url: () => pw.url(),
+    evaluate: (expression) => pw.evaluate(expression),
+    waitForTimeout: (ms) => pw.waitForTimeout(ms),
+    press: (key) => pw.keyboard.press(key),
+    frames: () => {
+      const source = raw;
+      return (source.frames?.() ?? []).map((frame) => ({
+        url: () => frame.url(),
+        locator: (selector) => ({ count: () => frame.locator(selector).count() })
+      }));
+    }
+  };
+}
+function wrapPlaywrightContext(raw, entryPage) {
+  const context = raw;
+  const cache = new WeakMap;
+  const wrap = (page) => {
+    const key = page;
+    const cached = cache.get(key);
+    if (cached !== undefined)
+      return cached;
+    const wrapped = wrapPlaywrightPage(page);
+    cache.set(key, wrapped);
+    return wrapped;
+  };
+  return {
+    page: wrap(entryPage),
+    pages: () => context.pages().map(wrap),
+    newPage: async () => wrap(await context.newPage()),
+    close: () => context.close()
+  };
+}
+async function waitForVisible(page, selector, timeoutMs, opts = {}) {
+  const visible = await waitUntil(async () => {
+    const found = await trySelectors(page, [selector]).catch(() => ({ found: false, selector: null }));
+    return found.found;
+  }, timeoutMs, POLL_MS);
+  if (visible)
+    return selector;
+  if (opts.required === false)
+    return;
+  throw new Error(`${selector}: not visible within ${timeoutMs}ms`);
+}
+
+// ../../plugins/publishings/wechatmp-pub/src/enrich.ts
+var DIALOG = ".weui-desktop-dialog:visible";
+var CONFIRM = `${DIALOG} button:has-text("\u786E\u8BA4"), ${DIALOG} button:has-text("\u786E\u5B9A")`;
+var ROW_ORIGINAL = [
+  ".setting-group__switch.js_original_apply.js_edit_ori",
+  ".setting-group__switch.js_edit_ori",
+  ".js_edit_ori",
+  "text=\u539F\u521B"
+];
+var ROW_REWARD = [
+  ".setting-group__switch.js_reward_open",
+  ".js_reward_open",
+  ".js_reward_allow_click",
+  ".setting-group__switch.js_can_reward",
+  "text=\u8D5E\u8D4F"
+];
+var ROW_COLLECTION = [".allow_click_opr.js_article_tags_label", "text=\u5408\u96C6"];
+var ROW_URL = [".allow_click_opr.js_url_checkbox", "text=\u539F\u6587\u94FE\u63A5"];
+var ROW_CLAIM = ["#js_claim_source_area .frm_checkbox_label", "text=\u521B\u4F5C\u6765\u6E90"];
+var DIALOG_CONFIRM = CONFIRM;
+var TAG_INPUT = 'input[placeholder*="\u5408\u96C6"]';
+var REWARD_ACCOUNT = [
+  `${DIALOG} input[placeholder*="\u8D5E\u8D4F"]`,
+  `${DIALOG} input[placeholder*="\u8D26\u6237"]`,
+  `${DIALOG} input.frm_input`
+];
+var URL_INPUT = [`${DIALOG} input[type="url"]`, `${DIALOG} input[placeholder*="\u94FE\u63A5"]`, `${DIALOG} input.frm_input`];
+var ORIGINAL_DECLARATION = `${DIALOG} label:has(.js_original_type_radio):has-text("\u6587\u5B57\u539F\u521B")`;
+var ORIGINAL_AGREEMENT = `${DIALOG} .original_agreement`;
+var COLLECTION_SETTLE_MS = 1200;
+var STEP_RETRY_SETTLE_MS = 1000;
+var SWEEP_SETTLE_MS = 400;
+
+class CapabilityError extends Error {
+}
+function norm(value) {
+  return typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+}
+var COMMITTED = {
+  original: `(() => {
+        const el = document.querySelector('#js_original, .js_ori_setting_checkbox');
+        return el ? el.checked === true : null;
+    })()`,
+  reward: `(() => {
+        const el = document.querySelector('#js_reward_setting_area .js_reward_setting_checkbox') ||
+                  document.querySelector('.js_reward_allow_click_cell .js_reward_setting');
+        return el ? el.checked === true : null;
+    })()`
+};
+var CLAIM_COMMITTED = `(() => {
+    const area = document.querySelector('#js_claim_source_area');
+    if (!area) return null;
+    const label = area.querySelector('.js_claim_source_selected');
+    const text = (label ? (label.textContent ?? '') : '').replace(/\\s+/g, ' ').trim();
+    const checkbox = area.querySelector('.js_claim_source, input[type=checkbox]');
+    const enabled = checkbox ? checkbox.checked === true : null;
+    return { enabled, text };
+})()`;
+async function readChecked(page, expression) {
+  try {
+    const raw = await page.evaluate(expression);
+    return typeof raw === "boolean" ? raw : null;
+  } catch {
+    return null;
+  }
+}
+async function enrichArticle(page, meta) {
+  const warnings = [];
+  const str = (key) => typeof meta[key] === "string" ? meta[key] : "";
+  const on = (key) => meta[key] === true;
+  const sweep = async () => {
+    const cancel = await trySelectors(page, ['button:has-text("\u53D6\u6D88")']);
+    if (cancel.found) {
+      try {
+        await page.locator(cancel.selector ?? "").first().click({ timeout: 2000 });
+      } catch {}
+    }
+    await page.press?.("Escape");
+    await page.waitForTimeout?.(SWEEP_SETTLE_MS);
+    const state = await modalState(page);
+    if (state === "open") {
+      for (const close of [".weui-desktop-dialog__close-btn", ".weui-desktop-dialog__close"]) {
+        const control = await tryFindSelector(page, [close], 1500);
+        if (control === undefined)
+          continue;
+        try {
+          await clickSelector(page, control, 2000);
+        } catch {}
+        break;
+      }
+      return await modalState(page) === "closed" ? "closed" : "unknown";
+    }
+    return state === "closed" ? "closed" : "unknown";
+  };
+  const openRow = async (row, what) => {
+    for (const selector of row) {
+      const found = await trySelectors(page, [selector]);
+      if (found.found) {
+        await clickSelector(page, selector, 8000);
+        return;
+      }
+    }
+    throw new Error(`no ${what} row control among [${row.join(" | ")}]`);
+  };
+  const step = async (name, fn) => {
+    try {
+      await fn();
+      return "ok";
+    } catch (error) {
+      if (error instanceof CapabilityError) {
+        warnings.push(`${name}: ${error.message}`);
+        return "capability";
+      }
+    }
+    await sweep();
+    await page.waitForTimeout?.(STEP_RETRY_SETTLE_MS);
+    try {
+      await fn();
+      return "ok";
+    } catch (error) {
+      warnings.push(`${name}: ${(error instanceof Error ? error.message : String(error)).slice(0, 120)}`);
+      await sweep();
+      return "failed";
+    }
+  };
+  const residual = async (name) => {
+    const state = await modalState(page);
+    if (state === "closed")
+      return false;
+    warnings.push(state === "open" ? `${name}: dialog did not close \u2014 check the draft` : `${name}: dialog state unknown after cleanup \u2014 a residual overlay may block later steps`);
+    return true;
+  };
+  if (on("original")) {
+    const name = "\u539F\u521B\u58F0\u660E";
+    if (await readChecked(page, COMMITTED.original) !== true) {
+      const outcome = await step(name, async () => {
+        await openRow(ROW_ORIGINAL, "\u539F\u521B\u58F0\u660E");
+        await clickSelector(page, ORIGINAL_DECLARATION, 5000);
+        const agreement = await trySelectors(page, [ORIGINAL_AGREEMENT]);
+        if (agreement.found) {
+          await clickSelector(page, ORIGINAL_AGREEMENT, 3000);
+        }
+        await clickSelector(page, DIALOG_CONFIRM, 8000);
+      });
+      if (outcome !== "capability" && await readChecked(page, COMMITTED.original) !== true && !await residual(name)) {
+        warnings.push(`${name}: \u539F\u521B\u58F0\u660E\u672A\u751F\u6548\uFF0C\u8BF7\u624B\u52A8\u8BBE\u7F6E`);
+      }
+    }
   }
-  const paths = [];
-  for (const { path, what } of candidates) {
-    if (!isAbsolute2(path)) {
-      return { error: `images validation: ${what} must be absolute, got '${path}'` };
-    }
-    if (!IMAGE_EXTENSIONS.test(path)) {
-      return {
-        error: `images validation: ${what} has unsupported extension (expected ${IMAGE_LIST}): '${path}'`
-      };
-    }
-    if (!await createNodeFileSystem().exists(path)) {
-      return { error: `images validation: ${what} does not exist: '${path}'` };
+  if (on("reward")) {
+    const name = "\u8D5E\u8D4F";
+    if (await readChecked(page, COMMITTED.reward) !== true) {
+      const outcome = await step(name, async () => {
+        await openRow(ROW_REWARD, "\u8D5E\u8D4F");
+        const blocked = await tryFindSelector(page, [`${DIALOG} :has-text("\u524D\u5F80\u5F00\u901A")`, `${DIALOG} :has-text("\u65E0\u6CD5\u5F00\u542F")`], 1500);
+        if (blocked !== undefined)
+          throw new CapabilityError("\u9700\u8981\u8D5E\u8D4F\u8D26\u6237\uFF08\u8FD0\u8425\u8005\u5148\u5728\u5E73\u53F0\u5F00\u901A\uFF09\uFF0C\u5DF2\u8DF3\u8FC7\u81EA\u52A8\u586B\u5199");
+        const author = str("author");
+        if (author !== "") {
+          for (const selector of REWARD_ACCOUNT) {
+            const found = await trySelectors(page, [selector]);
+            if (!found.found)
+              continue;
+            const locator = page.locator(selector).first();
+            if (typeof locator.inputValue !== "function")
+              break;
+            const empty = norm(await locator.inputValue().catch(() => null)) === "";
+            if (empty)
+              await fillSelector(page, selector, author);
+            break;
+          }
+        }
+        await clickSelector(page, DIALOG_CONFIRM, 8000);
+      });
+      if (outcome !== "capability" && await readChecked(page, COMMITTED.reward) !== true && !await residual(name)) {
+        warnings.push(`${name}: \u8D5E\u8D4F\u672A\u751F\u6548\uFF0C\u8BF7\u624B\u52A8\u8BBE\u7F6E`);
+      }
     }
-    paths.push(path);
-  }
-  return { paths };
-}
-function deriveDigest(content) {
-  const explicit = content.metadata?.digest;
-  if (typeof explicit === "string")
-    return explicit;
-  const body = content.body ?? "";
-  const first = body.split(`
-`).map((line) => line.trim()).find((line) => line !== "");
-  return first === undefined ? undefined : first.slice(0, DERIVED_DIGEST_MAX);
-}
-function validatePublishStatus(content) {
-  const status = content.metadata?.publishStatus;
-  if (status !== undefined && status !== "draft" && status !== "public") {
-    return {
-      error: `publishStatus validation: unknown publishStatus '${String(status)}' (expected 'draft' or 'public')`
-    };
-  }
-  return {};
-}
-function validateTitle(content, operation) {
-  const limits = MODE_LIMITS[operation];
-  const title = content.title ?? "";
-  if (limits.titleRequired === true && title.trim().length === 0) {
-    return {
-      error: `title validation: Content.title is required for ${operation} (the editor's placeholder is \u8BF7\u5728\u8FD9\u91CC\u8F93\u5165\u6807\u9898)`
-    };
-  }
-  if (limits.titleMax !== undefined && title.length > limits.titleMax) {
-    return {
-      error: `title validation: Content.title is ${title.length} chars but ${operation} accepts \u2264${limits.titleMax}`
-    };
   }
-  return {};
-}
-function validateDigest(content, operation) {
-  const max = MODE_LIMITS[operation].digestMax;
-  if (max === undefined)
-    return {};
-  const digest = deriveDigest(content);
-  if (digest !== undefined && digest.length > max) {
-    return { error: `digest validation: the \u6458\u8981 is ${digest.length} chars but ${operation} accepts \u2264${max}` };
+  const collection = str("collection");
+  if (collection !== "") {
+    const name = "\u5408\u96C6";
+    await step(name, async () => {
+      await openRow(ROW_COLLECTION, "\u5408\u96C6");
+      await waitForVisible(page, TAG_INPUT, 8000);
+      await fillSelector(page, TAG_INPUT, collection);
+      await page.waitForTimeout?.(COLLECTION_SETTLE_MS);
+      await clickSelector(page, `${DIALOG} :text("${collection}")`, 8000);
+      await clickSelector(page, DIALOG_CONFIRM, 8000);
+    });
+    await residual(name);
   }
-  return digest === undefined ? {} : { digest };
-}
-function validateAuthor(content, operation) {
-  const max = MODE_LIMITS[operation].authorMax;
-  const author = content.metadata?.author;
-  if (typeof author !== "string" || author.length === 0)
-    return {};
-  if (max !== undefined && author.length > max) {
-    return {
-      error: `author validation: Content.metadata.author is ${author.length} chars but ${operation} accepts \u2264${max}`
-    };
+  const originalUrl = str("originalUrl");
+  if (originalUrl !== "") {
+    const name = "\u539F\u6587\u94FE\u63A5";
+    const urlRow = await tryFindSelector(page, ROW_URL, 2000);
+    if (urlRow === undefined) {
+      warnings.push(`${name}: \u884C\u4E0D\u5B58\u5728\uFF08\u5F53\u524D\u516C\u4F17\u53F7\u4E0D\u652F\u6301\uFF09\uFF0C\u8BF7\u624B\u52A8\u5904\u7406\u6216\u79FB\u9664 originalUrl`);
+    } else {
+      await step(name, async () => {
+        await openRow(ROW_URL, "\u539F\u6587\u94FE\u63A5");
+        const field = await trySelectors(page, URL_INPUT);
+        if (!field.found)
+          throw new Error("no URL field in the \u539F\u6587\u94FE\u63A5 dialog");
+        await fillSelector(page, field.selector ?? URL_INPUT.join(", "), originalUrl);
+        await clickSelector(page, DIALOG_CONFIRM, 8000);
+      });
+      await residual(name);
+      const locator = page.locator(URL_INPUT[0] ?? "").first();
+      const committed = typeof locator.inputValue === "function" ? await locator.inputValue().catch(() => null) : null;
+      if (norm(committed) !== norm(originalUrl))
+        warnings.push(`${name}: \u5DF2\u63D0\u4EA4\u4F46\u672A\u8BFB\u53D6\u5230\u5DF2\u4FDD\u5B58\u7684\u94FE\u63A5\uFF0C\u8BF7\u6838\u5BF9`);
+    }
   }
-  return { author };
-}
-async function validateModeInput(operation, content) {
-  const status = validatePublishStatus(content);
-  if (status.error)
-    return { error: status.error };
-  const title = validateTitle(content, operation);
-  if (title.error)
-    return { error: title.error };
-  const author = validateAuthor(content, operation);
-  if (author.error)
-    return { error: author.error };
-  switch (operation) {
-    case "\u6587\u7AE0": {
-      if ((content.body ?? "").trim().length === 0) {
-        return { error: "body validation: Content.body is required for \u6587\u7AE0" };
-      }
-      const digest = validateDigest(content, operation);
-      if (digest.error)
-        return { error: digest.error };
-      const images = await resolveBodyImages(content);
-      if (images.error)
-        return { error: images.error };
-      if ((images.paths ?? []).length === 0) {
-        return {
-          error: "cover validation: \u6587\u7AE0 takes its cover from a body image (\u9ED8\u8BA4\u9996\u56FE\u4E3A\u5C01\u9762) but none was supplied \u2014 set metadata.wechatmp.coverPath or metadata.images[]"
-        };
+  const claimSource = str("claimSource");
+  if (claimSource !== "") {
+    const name = "\u521B\u4F5C\u6765\u6E90";
+    const claimMatched = async () => {
+      try {
+        const raw = await page.evaluate(CLAIM_COMMITTED);
+        if (raw === null || typeof raw !== "object")
+          return null;
+        return raw.enabled === true && norm(raw.text) === norm(claimSource);
+      } catch {
+        return null;
       }
-      return {
-        input: {
-          operation,
-          images: images.paths ?? [],
-          ...digest.digest === undefined ? {} : { digest: digest.digest }
+    };
+    if (await claimMatched() !== true) {
+      await step(name, async () => {
+        await openRow(ROW_CLAIM, "\u521B\u4F5C\u6765\u6E90");
+        const dialog = await waitForVisible(page, DIALOG, 3000, { required: false });
+        if (dialog !== undefined) {
+          await clickSelector(page, `${DIALOG} :text("${claimSource}")`, 8000);
+          await clickSelector(page, DIALOG_CONFIRM, 8000);
         }
-      };
-    }
-    case "\u8D34\u56FE": {
-      const images = await resolveBodyImages(content);
-      if (images.error)
-        return { error: images.error };
-      if ((images.paths ?? []).length === 0) {
-        return {
-          error: "image validation: \u8D34\u56FE requires at least one image (metadata.images[] or metadata.wechatmp.coverPath)"
-        };
-      }
-      return { input: { operation, images: images.paths ?? [] } };
-    }
-    case "\u89C6\u9891": {
-      const video = await resolveMediaPath(content, {
-        key: "video",
-        label: "video validation",
-        extensions: VIDEO_EXTENSIONS,
-        list: VIDEO_LIST
       });
-      if (video.error)
-        return { error: video.error };
-      return { input: { operation, video: video.path ?? "" } };
     }
-    case "\u64AD\u5BA2": {
-      const audio = await resolveMediaPath(content, {
-        key: "audio",
-        label: "audio validation",
-        extensions: AUDIO_EXTENSIONS,
-        list: AUDIO_LIST
-      });
-      if (audio.error)
-        return { error: audio.error };
-      const cover = await resolveMediaPath(content, {
-        key: "coverImage",
-        label: "cover validation",
-        extensions: IMAGE_EXTENSIONS,
-        list: IMAGE_LIST
-      });
-      if (cover.error)
-        return { error: cover.error };
-      return { input: { operation, audio: audio.path ?? "", cover: cover.path ?? "" } };
+    if (await claimMatched() !== true && !await residual(name)) {
+      warnings.push(`${name}: \u672A\u751F\u6548\uFF0C\u8BF7\u624B\u52A8\u8BBE\u7F6E`);
     }
   }
+  await sweep();
+  return warnings;
 }
 
 // ../../plugins/publishings/wechatmp-pub/src/flow.ts
@@ -21981,7 +23069,86 @@ async function openDialogInventory(page) {
   const raw = await page.evaluate(`[...document.querySelectorAll('.weui-desktop-dialog, .weui-desktop-dialog__wrp')]` + `.filter((d) => d.offsetWidth).map((d) => (d.className || '') + ' :: ' + ` + `(d.innerText || '').replace(/\\s+/g, ' ').slice(0, 160)).join(' || ')`).catch(() => "");
   return typeof raw === "string" ? raw.slice(0, 600) : "";
 }
+async function runCgiDraft(input, deps) {
+  if (input.operation !== "\u6587\u7AE0")
+    return;
+  try {
+    assertEligibleCgiDraft(deps.content);
+  } catch (error) {
+    if (error instanceof WechatCgiDraftError && error.code === "ineligible")
+      return;
+    throw error;
+  }
+  const metadata = deps.content.metadata ?? {};
+  const bodyImages = input.images;
+  if (bodyImages.length === 0)
+    return;
+  const cover = typeof metadata.coverPath === "string" && metadata.coverPath.length > 0 ? metadata.coverPath : bodyImages[0] ?? "";
+  try {
+    await readLocalImageBytes(cover);
+  } catch {
+    return;
+  }
+  const localImages = {};
+  for (const path of bodyImages)
+    localImages[path] = path;
+  const imageBlock = bodyImages.map((path) => `<img src="${path}">`).join("");
+  try {
+    const session = await extractWechatCgiSession(deps.entry);
+    let media;
+    try {
+      media = await prepareArticleMedia(deps.entry, session, {
+        html: imageBlock + markdownToWechatHtml(bodyOf(deps.content)),
+        coverPath: cover,
+        localImages
+      });
+    } catch (error) {
+      if (error instanceof WechatCgiDraftError)
+        throw error;
+      return ResultSchema.parse({
+        ok: false,
+        target: TARGET,
+        error: error instanceof Error ? error.message : String(error),
+        metadata: { operation: input.operation, publishStatus: deps.publishStatus, stage: "media-preparation" }
+      });
+    }
+    const draft = await createWechatArticleDraft(deps.entry, session, deps.content, media);
+    return ResultSchema.parse({
+      ok: true,
+      target: TARGET,
+      id: draft.appMsgId,
+      url: `https://mp.weixin.qq.com${draft.editPath}`,
+      metadata: {
+        operation: input.operation,
+        publishStatus: deps.publishStatus,
+        stage: "draft-created",
+        appMsgId: draft.appMsgId,
+        coverFileIds: [media.cover.wide.fileId, media.cover.square.fileId],
+        cdnMigratedImages: media.images.length
+      }
+    });
+  } catch (error) {
+    if (!(error instanceof WechatCgiDraftError))
+      throw error;
+    return ResultSchema.parse({
+      ok: false,
+      target: TARGET,
+      error: error.message,
+      metadata: {
+        operation: input.operation,
+        publishStatus: deps.publishStatus,
+        stage: error.stage,
+        ...error.metadata.ambiguousSubmission === true ? { ambiguousSubmission: true } : {}
+      }
+    });
+  }
+}
 async function runMode(input, deps) {
+  if (input.operation === "\u6587\u7AE0" && deps.publishStatus === "draft") {
+    const cgi = await runCgiDraft(input, deps);
+    if (cgi !== undefined)
+      return cgi;
+  }
   const entry = await enterMode(deps, input.operation);
   const composed = await compose(input, deps, entry);
   const diagnostics = [...composed.warnings, ...composed.enrichWarnings];