@skrillex1224/playwright-toolkit 2.1.210 → 2.1.212

package/dist/index.cjs

@@ -350,18 +350,18 @@ var fallbackLog = {
   error: (...args) => console.error(...args),
   debug: (...args) => console.debug ? console.debug(...args) : console.log(...args)
 };
-var resolveLogMethod = (logger12, name) => {
-  if (logger12 && typeof logger12[name] === "function") {
-    return logger12[name].bind(logger12);
+var resolveLogMethod = (logger13, name) => {
+  if (logger13 && typeof logger13[name] === "function") {
+    return logger13[name].bind(logger13);
   }
-  if (name === "warning" && logger12 && typeof logger12.warn === "function") {
-    return logger12.warn.bind(logger12);
+  if (name === "warning" && logger13 && typeof logger13.warn === "function") {
+    return logger13.warn.bind(logger13);
   }
   return fallbackLog[name];
 };
 var defaultLogger = null;
-var setDefaultLogger = (logger12) => {
-  defaultLogger = logger12;
+var setDefaultLogger = (logger13) => {
+  defaultLogger = logger13;
 };
 var resolveLogger = (explicitLogger) => {
   if (explicitLogger && typeof explicitLogger.info === "function") {
@@ -388,8 +388,8 @@ var colorize = (text, color) => {
 var createBaseLogger = (prefix = "", explicitLogger) => {
   const name = prefix ? String(prefix) : "";
   const dispatch = (methodName, icon, message, color) => {
-    const logger12 = resolveLogger(explicitLogger);
-    const logFn = resolveLogMethod(logger12, methodName);
+    const logger13 = resolveLogger(explicitLogger);
+    const logFn = resolveLogMethod(logger13, methodName);
     const timestamp = colorize(`[${formatTimestamp()}]`, ANSI.gray);
     const line = formatLine(name, icon, message);
     const coloredLine = colorize(line, color);
@@ -435,6 +435,33 @@ function createInternalLogger(moduleName, explicitLogger) {
   };
 }
 
+// src/internals/viewport.js
+var toPositiveInt = (value) => {
+  const number = Math.round(Number(value) || 0);
+  return number > 0 ? number : 0;
+};
+var resolveCurrentViewportSize = async (page, fallback = {}) => {
+  const directViewport = page?.viewportSize?.();
+  const directWidth = toPositiveInt(directViewport?.width);
+  const directHeight = toPositiveInt(directViewport?.height);
+  if (directWidth && directHeight) {
+    return {
+      width: directWidth,
+      height: directHeight
+    };
+  }
+  const measuredViewport = await page?.evaluate?.(() => ({
+    width: window.innerWidth || document.documentElement?.clientWidth || document.body?.clientWidth || 0,
+    height: window.innerHeight || document.documentElement?.clientHeight || document.body?.clientHeight || 0
+  })).catch(() => null);
+  const fallbackWidth = toPositiveInt(fallback?.width);
+  const fallbackHeight = toPositiveInt(fallback?.height);
+  return {
+    width: toPositiveInt(measuredViewport?.width) || fallbackWidth || 1,
+    height: toPositiveInt(measuredViewport?.height) || fallbackHeight || 1
+  };
+};
+
 // src/internals/screenshot.js
 var logger = createInternalLogger("Screenshot");
 var DEFAULT_TIMEOUT_MS = 5e3;
@@ -461,7 +488,7 @@ var normalizeQuality = (value, type) => {
 };
 var buildFullPageClip = (metrics, viewport, maxClipHeight) => {
   const contentSize = metrics && typeof metrics === "object" ? metrics.contentSize || null : null;
-  const width = Math.max(1, Math.ceil(contentSize?.width || viewport.width || 1));
+  const width = Math.max(1, Math.ceil(viewport.width || contentSize?.width || 1));
   let height = Math.max(1, Math.ceil(contentSize?.height || viewport.height || 1));
   if (maxClipHeight > 0) {
     height = Math.min(height, maxClipHeight);
@@ -498,7 +525,7 @@ var capturePageScreenshot = async (page, options = {}) => {
     const session = await context.newCDPSession(page);
     try {
       const metrics = await session.send("Page.getLayoutMetrics");
-      const viewport = page.viewportSize() || { width: 1280, height: 720 };
+      const viewport = await resolveCurrentViewportSize(page);
       const captureParams = {
         format: type,
         fromSurface: true,
@@ -952,6 +979,9 @@ var ProxyMeterRuntime = {
   getProxyMeterSnapshot
 };
 
+// src/internals/constants.js
+var PageRuntimeStateKey = "__playwright_toolkit_runtime_state__";
+
 // src/runtime-env.js
 var BROWSER_PROFILE_SCHEMA_VERSION = 1;
 var rememberedRuntimeState = null;
@@ -1458,6 +1488,7 @@ var RuntimeEnv = {
   parseInput(input = {}, actor = "") {
     const runtime2 = tryParseJSON(input?.runtime) || {};
     const resolvedActor = String(actor || input?.actor || "").trim();
+    const query = String(input?.query || "").trim();
     const cookies = normalizeCookies(runtime2?.cookies);
     const cookieMap = buildCookieMap(cookies);
     const localStorage = normalizeLocalStorage(runtime2?.local_storage);
@@ -1481,6 +1512,7 @@ var RuntimeEnv = {
       actor: resolvedActor,
       runtime: normalizedRuntime,
       envId,
+      query,
       auth,
       cookies,
       cookieMap,
@@ -1548,6 +1580,12 @@ var RuntimeEnv = {
   async applyToPage(page, source = {}, options = {}) {
     if (!page) return;
     const state = normalizeRuntimeState(source, options?.actor || "");
+    Object.defineProperty(page, PageRuntimeStateKey, {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value: state
+    });
     const localStorage = state.localStorage || {};
     const sessionStorage = state.sessionStorage || {};
     const cookies = (state.cookies || []).map((cookie) => {
@@ -4531,7 +4569,7 @@ var createTemplateLogger = (baseLogger = createBaseLogger()) => {
 };
 var getDefaultBaseLogger = () => createBaseLogger("");
 var Logger = {
-  setLogger: (logger12) => setDefaultLogger(logger12),
+  setLogger: (logger13) => setDefaultLogger(logger13),
   info: (message) => getDefaultBaseLogger().info(message),
   success: (message) => getDefaultBaseLogger().success(message),
   warning: (message) => getDefaultBaseLogger().warning(message),
@@ -4539,8 +4577,8 @@ var Logger = {
   error: (message) => getDefaultBaseLogger().error(message),
   debug: (message) => getDefaultBaseLogger().debug(message),
   start: (message) => getDefaultBaseLogger().start(message),
-  useTemplate: (logger12) => {
-    if (logger12) return createTemplateLogger(createBaseLogger("", logger12));
+  useTemplate: (logger13) => {
+    if (logger13) return createTemplateLogger(createBaseLogger("", logger13));
     return createTemplateLogger();
   }
 };
@@ -4558,13 +4596,28 @@ var DEFAULT_WATERMARK_ROTATE_DEG = -16;
 var DEFAULT_WATERMARK_CELL_WIDTH = 860;
 var DEFAULT_WATERMARK_CELL_HEIGHT = 330;
 var DEFAULT_STRIP_LOGO_URL = "https://static.heartbitai.com/geo/icon/favicon.png";
-var DEFAULT_IP_LOOKUP_URL = "http://myip.ipip.net";
+var DEFAULT_IP_LOOKUP_URL = "https://myip.ipip.net/json";
 var DEFAULT_LOGO_FETCH_TIMEOUT_MS = 2500;
-var DEFAULT_STRIP_HEIGHT = 78;
-var DEFAULT_STRIP_PADDING_LEFT = 20;
-var DEFAULT_STRIP_PADDING_RIGHT = 22;
-var DEFAULT_STRIP_GAP = 16;
+var DEFAULT_STRIP_ONE_LINE_HEIGHT = 78;
+var DEFAULT_STRIP_WRAPPED_MIN_HEIGHT = 108;
+var DEFAULT_STRIP_PADDING_LEFT = 22;
+var DEFAULT_STRIP_PADDING_RIGHT = 28;
+var DEFAULT_STRIP_GAP = 18;
 var DEFAULT_STRIP_LABEL_WIDTH = 56;
+var DEFAULT_STRIP_PROMPT_MAX_SAFE_CHARS = 180;
+var DEFAULT_STRIP_PROMPT_MIN_TOTAL_WIDTH = 320;
+var DEFAULT_STRIP_PROMPT_PREFERRED_WIDTH_RATIO = 0.58;
+var DEFAULT_STRIP_ZONE_GAP = 18;
+var DEFAULT_STRIP_PROMPT_TRAILING_PADDING = 16;
+var DEFAULT_STRIP_LABEL_FONT_SIZE = 14.5;
+var DEFAULT_STRIP_VALUE_FONT_SIZE = 15.5;
+var DEFAULT_STRIP_VALUE_PADDING = 10;
+var DEFAULT_STRIP_LABEL_PADDING = 14;
+var DEFAULT_STRIP_SECTION_GAP = DEFAULT_STRIP_GAP + 16;
+var DEFAULT_STRIP_LINE_HEIGHT_RATIO = 1.28;
+var DEFAULT_STRIP_PROMPT_MAX_LINES = 3;
+var DEFAULT_STRIP_CONTENT_SAFE_PADDING_X = 12;
+var DEFAULT_STRIP_TEXT_WIDTH_SAFETY = 10;
 var WEAK_LOCATION_VALUES = /* @__PURE__ */ new Set(["cn", "\u4E2D\u56FD"]);
 var LOCATION_NETWORK_SUFFIX_PATTERNS = [
   /(?:中国)?移动$/i,
@@ -4589,6 +4642,8 @@ var LOCATION_NETWORK_SUFFIX_PATTERNS = [
   /digitalocean$/i
 ];
 var cachedStripLogoSrcPromise = null;
+var cachedEnrichmentByContext = /* @__PURE__ */ new WeakMap();
+var logger11 = createInternalLogger("Watermarkify");
 var normalizeText = (value) => String(value || "").trim();
 var toInline = (value, maxLen = 200) => {
   const text = normalizeText(value);
@@ -4600,6 +4655,15 @@ var shortenTail = (value, maxLen = 80) => {
   if (!text || text.length <= maxLen) return text;
   return `${text.slice(0, Math.max(0, maxLen - 1)).trimEnd()}\u2026`;
 };
+var shortenByCharacters = (value, maxChars = 80) => {
+  const text = normalizeWhitespace(value);
+  if (!text) return "";
+  const chars = Array.from(text);
+  if (chars.length <= maxChars) {
+    return text;
+  }
+  return `${chars.slice(0, Math.max(0, maxChars - 1)).join("").trimEnd()}\u2026`;
+};
 var padDatePart = (value) => String(value).padStart(2, "0");
 var formatUtcOffsetLabel = (offsetHours = DEFAULT_TIMEZONE_OFFSET) => {
   const sign = offsetHours >= 0 ? "+" : "-";
@@ -4647,18 +4711,26 @@ var pickHeaderValue = async (response, names = []) => {
   }
   return "";
 };
-var parseIpIpResponse = (rawText) => {
+var parseIpIpJsonResponse = (rawText) => {
   const text = normalizeWhitespace(rawText);
-  if (!text) return null;
-  const ipMatch = text.match(/当前\s*IP[:：]\s*([^\s]+)/i) || text.match(/\b((?:\d{1,3}\.){3}\d{1,3}|(?:[0-9a-f]{0,4}:){2,}[0-9a-f]{0,4})\b/i);
-  const locationMatch = text.match(/来自于[:：]?\s*(.+)$/i);
-  const ip = toInline(ipMatch?.[1], 80);
-  const rawLocation = toInline(locationMatch?.[1], 120);
-  const location = toInline(stripLocationNetworkSuffix(rawLocation), 80) || rawLocation;
-  if (!ip && !location) {
+  if (!text || !text.startsWith("{") && !text.startsWith("[")) {
+    return null;
+  }
+  try {
+    const payload = JSON.parse(text);
+    const ip = toInline(payload?.data?.ip || payload?.ip, 80);
+    const locationParts = Array.isArray(payload?.data?.location) ? payload.data.location.map((item) => normalizeWhitespace(item)).filter(Boolean) : [];
+    const location = toInline(
+      stripLocationNetworkSuffix(locationParts.join(" ")),
+      80
+    );
+    if (!ip && !location) {
+      return null;
+    }
+    return { ip, location };
+  } catch {
     return null;
   }
-  return { ip, location };
 };
 var fillEnrichment = (target, source) => {
   if (!target || !source || typeof source !== "object") {
@@ -4672,6 +4744,29 @@ var fillEnrichment = (target, source) => {
   }
   return target;
 };
+var readCachedEnrichment = (page) => {
+  const context = page && typeof page.context === "function" ? page.context() : null;
+  if (!context) {
+    return null;
+  }
+  const cached = cachedEnrichmentByContext.get(context);
+  return cached && typeof cached === "object" ? cached : null;
+};
+var writeCachedEnrichment = (page, source) => {
+  const context = page && typeof page.context === "function" ? page.context() : null;
+  if (!context || !source || typeof source !== "object") {
+    return;
+  }
+  const current = cachedEnrichmentByContext.get(context) || {};
+  const next = {
+    ip: toInline(source.ip || current.ip, 80),
+    location: toInline(source.location || current.location, 80)
+  };
+  if (!next.ip && !next.location) {
+    return;
+  }
+  cachedEnrichmentByContext.set(context, next);
+};
 var getHostname = (url) => {
   try {
     const parsed = new URL(url);
@@ -4785,10 +4880,16 @@ var resolveWithCustomResolver = async (page, baseMeta, options = {}) => {
     if (!resolved || typeof resolved !== "object") {
       return null;
     }
-    return {
+    const enrichment = {
       ip: toInline(resolved.ip, 80),
       location: toInline(resolved.location, 80)
     };
+    if (enrichment.ip || enrichment.location) {
+      logger11.info(`\u81EA\u5B9A\u4E49 resolver \u547D\u4E2D: ip=${enrichment.ip || "-"}, loc=${enrichment.location || "-"}`);
+    } else {
+      logger11.warning("\u81EA\u5B9A\u4E49 resolver \u5DF2\u6267\u884C\uFF0C\u4F46\u672A\u8FD4\u56DE IP/Loc");
+    }
+    return enrichment;
   } finally {
     controller?.abort();
   }
@@ -4801,44 +4902,43 @@ var openProbePage = async (page) => {
   if (!context) {
     return null;
   }
+  const browser = typeof context.browser === "function" ? context.browser() : null;
+  if (browser && typeof browser.newContext === "function") {
+    const probeContext = await browser.newContext().catch(() => null);
+    if (probeContext && typeof probeContext.newPage === "function") {
+      const probePage = await probeContext.newPage().catch(async () => {
+        await probeContext.close().catch(() => {
+        });
+        return null;
+      });
+      if (probePage) {
+        return {
+          page: probePage,
+          close: async () => {
+            await probeContext.close().catch(() => {
+            });
+          }
+        };
+      }
+    } else {
+      await probeContext?.close?.().catch(() => {
+      });
+    }
+  }
   if (typeof context.newPage === "function") {
     try {
-      const probePage2 = await context.newPage();
+      const probePage = await context.newPage();
       return {
-        page: probePage2,
+        page: probePage,
         close: async () => {
-          await probePage2.close().catch(() => {
+          await probePage.close().catch(() => {
           });
         }
       };
     } catch {
     }
   }
-  const browser = typeof context.browser === "function" ? context.browser() : null;
-  if (!browser || typeof browser.newContext !== "function") {
-    return null;
-  }
-  const probeContext = await browser.newContext().catch(() => null);
-  if (!probeContext || typeof probeContext.newPage !== "function") {
-    await probeContext?.close?.().catch(() => {
-    });
-    return null;
-  }
-  const probePage = await probeContext.newPage().catch(async () => {
-    await probeContext.close().catch(() => {
-    });
-    return null;
-  });
-  if (!probePage) {
-    return null;
-  }
-  return {
-    page: probePage,
-    close: async () => {
-      await probeContext.close().catch(() => {
-      });
-    }
-  };
+  return null;
 };
 var resolveWithIpLookup = async (page, options = {}) => {
   if (!page || typeof page.context !== "function" || options.ipLookup === false) {
@@ -4846,6 +4946,7 @@ var resolveWithIpLookup = async (page, options = {}) => {
   }
   const probeScope = await openProbePage(page);
   if (!probeScope?.page) {
+    logger11.warning("ipLookup \u8DF3\u8FC7: \u65E0\u6CD5\u521B\u5EFA probe page");
     return null;
   }
   const timeoutMs = Math.max(
@@ -4854,10 +4955,16 @@ var resolveWithIpLookup = async (page, options = {}) => {
   );
   try {
     const probePage = probeScope.page;
+    logger11.info(`ipLookup \u5C1D\u8BD5: url=${DEFAULT_IP_LOOKUP_URL}, timeoutMs=${timeoutMs}`);
     const response = await probePage.goto(DEFAULT_IP_LOOKUP_URL, {
       waitUntil: "commit",
       timeout: timeoutMs
-    }).catch(() => null);
+    }).catch((error) => {
+      logger11.warning(`ipLookup \u8BF7\u6C42\u5931\u8D25: url=${DEFAULT_IP_LOOKUP_URL}, error=${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    });
+    const status = response && typeof response.status === "function" ? response.status() : 0;
+    const contentType = normalizeText(await pickHeaderValue(response, ["content-type"]));
     let rawText = "";
     if (response && typeof response.text === "function") {
       rawText = String(await withTimeout(
@@ -4873,8 +4980,15 @@ var resolveWithIpLookup = async (page, options = {}) => {
         Math.min(timeoutMs, 500)
       ) || "");
     }
-    return parseIpIpResponse(rawText);
-  } catch {
+    const parsed = parseIpIpJsonResponse(rawText);
+    if (parsed?.ip || parsed?.location) {
+      logger11.info(`ipLookup \u6210\u529F: url=${DEFAULT_IP_LOOKUP_URL}, status=${status || "-"}, contentType=${contentType || "-"}, ip=${parsed.ip || "-"}, loc=${parsed.location || "-"}`);
+      return parsed;
+    }
+    logger11.warning(`ipLookup \u672A\u89E3\u6790\u51FA IP/Loc: url=${DEFAULT_IP_LOOKUP_URL}, status=${status || "-"}, contentType=${contentType || "-"}, preview=${shortenTail(rawText, 120) || "[empty]"}`);
+    return null;
+  } catch (error) {
+    logger11.warning(`ipLookup \u6267\u884C\u5F02\u5E38\uFF0C\u672A\u83B7\u5F97 IP/Loc: ${error instanceof Error ? error.message : String(error)}`);
     return null;
   } finally {
     await probeScope.close().catch(() => {
@@ -4883,10 +4997,18 @@ var resolveWithIpLookup = async (page, options = {}) => {
 };
 var resolveEnrichment = async (page, baseMeta, options) => {
   const response = options.response && typeof options.response === "object" ? options.response : null;
+  const cached = readCachedEnrichment(page);
   const merged = {
     ip: toInline(options.ip, 80),
     location: toInline(options.location, 80)
   };
+  logger11.info(`enrichment \u5F00\u59CB: host=${baseMeta.hostname || "-"}, hasPresetIp=${Boolean(merged.ip)}, hasPresetLoc=${Boolean(merged.location)}, ipLookup=${options.ipLookup !== false}`);
+  if (!merged.ip || !merged.location) {
+    if (cached?.ip || cached?.location) {
+      logger11.info(`enrichment \u547D\u4E2D\u4E0A\u4E0B\u6587\u7F13\u5B58: ip=${cached.ip || "-"}, loc=${cached.location || "-"}`);
+    }
+    fillEnrichment(merged, cached);
+  }
   if (!merged.ip || !merged.location) {
     fillEnrichment(
       merged,
@@ -4907,9 +5029,16 @@ var resolveEnrichment = async (page, baseMeta, options) => {
       "x-geo-country"
     ]), 80);
     if (!merged.location || isWeakLocationValue(merged.location) && headerLocation) {
+      logger11.info(`enrichment \u4F7F\u7528\u54CD\u5E94\u5934\u8865\u5145 Loc: ${headerLocation || "-"}`);
       merged.location = headerLocation || merged.location;
     }
   }
+  writeCachedEnrichment(page, merged);
+  if (merged.ip || merged.location) {
+    logger11.info(`enrichment \u5B8C\u6210: ip=${merged.ip || "-"}, loc=${merged.location || "-"}`);
+  } else {
+    logger11.warning("enrichment \u5B8C\u6210: \u672A\u83B7\u5F97 IP/Loc");
+  }
   return merged;
 };
 var buildWatermarkStamp = ({ prompt, captureTime, ip, location }) => {
@@ -4922,7 +5051,12 @@ var buildWatermarkStamp = ({ prompt, captureTime, ip, location }) => {
   return parts.join(" | ");
 };
 var buildStripSegments = ({ prompt, captureTime, ip, location }) => {
-  const promptValue = toInline(prompt, 240) || "-";
+  const promptValue = shortenByCharacters(
+    normalizeWhitespace(prompt) || "-",
+    DEFAULT_STRIP_PROMPT_MAX_SAFE_CHARS
+  ) || "-";
+  const ipValue = normalizeWhitespace(ip) || "-";
+  const locationValue = normalizeWhitespace(location) || "-";
   return [
     {
       kind: "prompt",
@@ -4939,14 +5073,14 @@ var buildStripSegments = ({ prompt, captureTime, ip, location }) => {
     {
       kind: "location",
       label: "Loc",
-      value: shortenTail(location, 24) || "-",
-      rawValue: toInline(location, 80) || "-"
+      value: locationValue,
+      rawValue: locationValue
     },
     {
       kind: "ip",
       label: "IP",
-      value: toInline(ip, 28) || "-",
-      rawValue: toInline(ip, 80) || "-"
+      value: ipValue,
+      rawValue: ipValue
     }
   ];
 };
@@ -4967,28 +5101,9 @@ var estimateTextWidth = (value, fontSize = 16) => {
   }
   return Math.ceil(width);
 };
-var fitTextToWidth = (value, maxWidth, fontSize = 16) => {
-  const text = normalizeWhitespace(value);
-  if (!text) return "-";
-  const safeMaxWidth = Math.max(fontSize * 3, Number(maxWidth) || 0);
-  if (estimateTextWidth(text, fontSize) <= safeMaxWidth) {
-    return text;
-  }
-  const ellipsis = "\u2026";
-  const ellipsisWidth = estimateTextWidth(ellipsis, fontSize);
-  let current = "";
-  for (const char of text) {
-    const next = current + char;
-    if (estimateTextWidth(next, fontSize) + ellipsisWidth > safeMaxWidth) {
-      break;
-    }
-    current = next;
-  }
-  return `${current.trimEnd()}${ellipsis}`;
-};
 var resolvePromptFields = (options = {}, fallbackTitle = "") => {
   const query = normalizeText(options.query);
-  const prompt = normalizeText(options.prompt) || query || normalizeText(fallbackTitle) || "\u672A\u63D0\u4F9B Prompt";
+  const prompt = query || normalizeText(options.prompt) || normalizeText(fallbackTitle) || "\u672A\u63D0\u4F9B Prompt";
   return {
     prompt,
     query: query || prompt
@@ -5044,8 +5159,8 @@ var normalizeScreenshotWatermarkify = (value) => {
     response: source.response ?? null,
     ip: normalizeText(source.ip),
     location: normalizeText(source.location),
-    prompt: toInline(source.prompt, 220),
-    query: toInline(source.query, 220),
+    prompt: normalizeWhitespace(source.prompt),
+    query: normalizeWhitespace(source.query),
     ipLookup: source.ipLookup !== false,
     ipLookupTimeoutMs: Number.isFinite(ipLookupTimeoutMsRaw) ? ipLookupTimeoutMsRaw : DEFAULT_IP_LOOKUP_TIMEOUT_MS,
     resolver: typeof source.resolver === "function" ? source.resolver : null,
@@ -5098,53 +5213,332 @@ var resolveScreenshotWatermarkifyMeta = async (page, options = {}) => {
   };
 };
 var buildFontFamily = () => 'MiSans, "SF Pro Display", "PingFang SC", "Helvetica Neue", Arial, sans-serif';
-var buildStripSegmentLayouts = (segments, contentWidth) => {
+var buildStripSegmentLayout = (segment, options = {}) => {
+  const label = normalizeWhitespace(segment?.label || "");
+  const rawValue = normalizeWhitespace(segment?.rawValue || segment?.value || "-") || "-";
+  const labelFontSize = DEFAULT_STRIP_LABEL_FONT_SIZE;
+  const valueFontSize = DEFAULT_STRIP_VALUE_FONT_SIZE;
+  const labelWidth = Math.max(
+    DEFAULT_STRIP_LABEL_WIDTH,
+    estimateTextWidth(label, labelFontSize) + DEFAULT_STRIP_LABEL_PADDING
+  );
+  const rawValueWidth = Math.max(
+    24,
+    estimateTextWidth(rawValue, valueFontSize) + DEFAULT_STRIP_VALUE_PADDING
+  );
+  const maxValueWidth = Math.max(0, Number(options.valueMaxWidth) || 0);
+  const renderValue = maxValueWidth > 0 ? fitTextWithEllipsis(rawValue, Math.max(18, maxValueWidth - DEFAULT_STRIP_VALUE_PADDING), valueFontSize) : rawValue;
+  const valueWidth = maxValueWidth > 0 ? Math.max(24, Math.min(maxValueWidth, estimateTextWidth(renderValue, valueFontSize) + DEFAULT_STRIP_VALUE_PADDING)) : rawValueWidth;
+  return {
+    ...segment,
+    label,
+    rawValue,
+    renderValue,
+    labelFontSize,
+    valueFontSize,
+    labelWidth,
+    valueWidth,
+    segmentWidth: labelWidth + valueWidth,
+    rowHeight: Math.round(Math.max(labelFontSize, valueFontSize) * 1.42)
+  };
+};
+var buildStripRowLayout = (segments, overrides = {}) => {
   const safeSegments = Array.isArray(segments) ? segments : [];
-  const sectionGap = DEFAULT_STRIP_GAP + 16;
-  const labelWidth = DEFAULT_STRIP_LABEL_WIDTH;
-  const promptFontSize = 15;
-  const otherFontSizes = {
-    time: 17,
-    location: 17,
-    ip: 17
+  const sectionGap = DEFAULT_STRIP_SECTION_GAP;
+  const layouts = safeSegments.map((segment, index) => buildStripSegmentLayout(segment, {
+    valueMaxWidth: overrides?.valueMaxWidths?.[index]
+  }));
+  const totalWidth = layouts.reduce((sum, segment) => sum + segment.segmentWidth, 0) + Math.max(0, layouts.length - 1) * sectionGap;
+  const rowHeight = layouts.reduce((max, segment) => Math.max(max, segment.rowHeight || 0), 0);
+  return {
+    sectionGap,
+    layouts,
+    totalWidth,
+    rowHeight
   };
-  const maxValueWidths = {
-    time: 290,
-    location: 220,
-    ip: 160
+};
+var fitTextWithEllipsis = (chars, maxWidth, fontSize) => {
+  const safeChars = Array.isArray(chars) ? chars.slice() : Array.from(String(chars || ""));
+  if (!safeChars.length) {
+    return "-";
+  }
+  if (estimateTextWidth(safeChars.join(""), fontSize) <= maxWidth) {
+    return safeChars.join("").trim() || "-";
+  }
+  while (safeChars.length > 1 && estimateTextWidth(`${safeChars.join("").trimEnd()}\u2026`, fontSize) > maxWidth) {
+    safeChars.pop();
+  }
+  return `${safeChars.join("").trimEnd()}\u2026` || "\u2026";
+};
+var splitTextToLines = (value, maxWidth, fontSize, maxLines = 2) => {
+  const chars = Array.from(normalizeWhitespace(value) || "-");
+  const safeMaxWidth = Math.max(18, maxWidth - DEFAULT_STRIP_TEXT_WIDTH_SAFETY);
+  if (!chars.length) {
+    return { lines: ["-"], truncated: false };
+  }
+  const lines = [];
+  let cursor = 0;
+  let truncated = false;
+  while (cursor < chars.length && lines.length < maxLines) {
+    while (cursor < chars.length && chars[cursor] === " ") {
+      cursor += 1;
+    }
+    if (cursor >= chars.length) {
+      break;
+    }
+    const isLastLine = lines.length === maxLines - 1;
+    const lineChars = [];
+    while (cursor < chars.length) {
+      const nextChars = [...lineChars, chars[cursor]];
+      const remaining = cursor < chars.length - 1;
+      const previewText = nextChars.join("") + (isLastLine && remaining ? "\u2026" : "");
+      if (estimateTextWidth(previewText, fontSize) <= safeMaxWidth || lineChars.length === 0) {
+        lineChars.push(chars[cursor]);
+        cursor += 1;
+        continue;
+      }
+      break;
+    }
+    while (cursor < chars.length && chars[cursor] === " ") {
+      cursor += 1;
+    }
+    if (isLastLine && cursor < chars.length) {
+      lines.push(fitTextWithEllipsis([...lineChars, ...chars.slice(cursor)], safeMaxWidth, fontSize));
+      truncated = true;
+      cursor = chars.length;
+      continue;
+    }
+    lines.push(lineChars.join("").trim() || "-");
+  }
+  return {
+    lines: lines.length > 0 ? lines : ["-"],
+    truncated
   };
-  const promptSegment = safeSegments.find((segment) => segment?.kind === "prompt") || null;
-  const fixedSegments = safeSegments.filter((segment) => segment?.kind !== "prompt");
-  const fixedLayouts = fixedSegments.map((segment) => {
-    const fontSize = otherFontSizes[segment.kind] || 17;
-    const maxValueWidth = maxValueWidths[segment.kind] || 220;
-    const renderValue = fitTextToWidth(segment.rawValue || segment.value || "-", maxValueWidth, fontSize);
-    const valueWidth = Math.min(maxValueWidth, estimateTextWidth(renderValue, fontSize) + 8);
-    return {
-      ...segment,
-      fontSize,
-      labelWidth,
-      renderValue,
-      segmentWidth: labelWidth + valueWidth
-    };
+};
+var resolveMetadataMinValueWidth = (segment) => {
+  switch (segment?.kind) {
+    case "time":
+      return Math.max(148, estimateTextWidth("2026-04-23 21:27:16 UTC+8", DEFAULT_STRIP_VALUE_FONT_SIZE) + 8);
+    case "ip":
+      return Math.max(108, estimateTextWidth("255.255.255.255", DEFAULT_STRIP_VALUE_FONT_SIZE) + 8);
+    case "location":
+      return 76;
+    default:
+      return 56;
+  }
+};
+var buildMetadataRowLayout = (segments, contentWidth) => {
+  const safeSegments = Array.isArray(segments) ? segments.filter(Boolean) : [];
+  const naturalRow = buildStripRowLayout(safeSegments);
+  if (!safeSegments.length || naturalRow.totalWidth <= contentWidth) {
+    return naturalRow;
+  }
+  const sectionGap = naturalRow.sectionGap;
+  const totalLabelWidth = naturalRow.layouts.reduce((sum, segment) => sum + segment.labelWidth, 0);
+  const availableValueWidth = Math.max(
+    72,
+    Math.floor(contentWidth - totalLabelWidth - Math.max(0, safeSegments.length - 1) * sectionGap)
+  );
+  const minValueWidths = naturalRow.layouts.map((segment) => resolveMetadataMinValueWidth(segment));
+  const naturalValueWidths = naturalRow.layouts.map((segment) => segment.valueWidth);
+  const valueWidths = naturalValueWidths.slice();
+  let overflow = naturalRow.totalWidth - contentWidth;
+  const shrinkOrder = ["location", "ip", "time"];
+  shrinkOrder.forEach((kind) => {
+    if (overflow <= 0) return;
+    naturalRow.layouts.forEach((segment, index) => {
+      if (overflow <= 0 || segment.kind !== kind) return;
+      const minWidth = minValueWidths[index];
+      const reducible = Math.max(0, valueWidths[index] - minWidth);
+      if (!reducible) return;
+      const reduction = Math.min(reducible, overflow);
+      valueWidths[index] -= reduction;
+      overflow -= reduction;
+    });
   });
-  const fixedWidth = fixedLayouts.reduce((sum, segment) => sum + segment.segmentWidth, 0);
-  const totalGapWidth = Math.max(0, safeSegments.length - 1) * sectionGap;
-  const promptValueWidth = Math.max(
-    180,
-    Math.floor(contentWidth - fixedWidth - totalGapWidth - labelWidth)
+  if (overflow > 0) {
+    const minTotalWidth = minValueWidths.reduce((sum, width) => sum + width, 0);
+    if (minTotalWidth > availableValueWidth) {
+      const flexibleIndexes = naturalRow.layouts.map((segment, index) => ({ segment, index })).filter(({ segment }) => segment.kind !== "time");
+      let extraOverflow = minTotalWidth - availableValueWidth;
+      flexibleIndexes.forEach(({ index }) => {
+        if (extraOverflow <= 0) return;
+        const minFloor = 40;
+        const reducible = Math.max(0, minValueWidths[index] - minFloor);
+        if (!reducible) return;
+        const reduction = Math.min(reducible, extraOverflow);
+        valueWidths[index] -= reduction;
+        extraOverflow -= reduction;
+      });
+    }
+  }
+  return buildStripRowLayout(safeSegments, {
+    valueMaxWidths: valueWidths
+  });
+};
+var buildPromptWrapLayout = (segment, contentWidth) => {
+  const label = normalizeWhitespace(segment?.label || "Prompt") || "Prompt";
+  const rawValue = normalizeWhitespace(segment?.rawValue || segment?.value || "-") || "-";
+  const labelFontSize = DEFAULT_STRIP_LABEL_FONT_SIZE;
+  const valueFontSize = DEFAULT_STRIP_VALUE_FONT_SIZE;
+  const labelWidth = Math.max(
+    DEFAULT_STRIP_LABEL_WIDTH,
+    estimateTextWidth(label, labelFontSize) + DEFAULT_STRIP_LABEL_PADDING
   );
-  const promptLayout = promptSegment ? {
-    ...promptSegment,
-    fontSize: promptFontSize,
+  const safeTotalWidth = Math.max(labelWidth + 56, Number(contentWidth) || 0);
+  const valueWidth = Math.max(
+    56,
+    safeTotalWidth - labelWidth - DEFAULT_STRIP_CONTENT_SAFE_PADDING_X
+  );
+  const result = splitTextToLines(rawValue, valueWidth, valueFontSize, DEFAULT_STRIP_PROMPT_MAX_LINES);
+  const lineHeight = Math.max(18, Math.round(valueFontSize * DEFAULT_STRIP_LINE_HEIGHT_RATIO));
+  const lineWidths = result.lines.map((line) => estimateTextWidth(line, valueFontSize) + DEFAULT_STRIP_VALUE_PADDING);
+  const measuredValueWidth = Math.min(
+    valueWidth,
+    Math.max(56, ...lineWidths)
+  );
+  const rowHeight = Math.round(Math.max(labelFontSize, valueFontSize) * 1.42);
+  return {
+    mode: result.lines.length === 1 ? "single" : "wrapped",
+    label,
+    rawValue,
+    labelFontSize,
     labelWidth,
-    renderValue: fitTextToWidth(promptSegment.rawValue || promptSegment.value || "-", promptValueWidth, promptFontSize),
-    segmentWidth: labelWidth + promptValueWidth
-  } : null;
-  return [
-    ...promptLayout ? [promptLayout] : [],
-    ...fixedLayouts
-  ];
+    valueFontSize,
+    valueWidth,
+    lines: result.lines,
+    truncated: result.truncated,
+    lineHeight,
+    blockHeight: result.lines.length === 1 ? rowHeight : Math.max(lineHeight, result.lines.length * lineHeight),
+    totalWidth: labelWidth + measuredValueWidth
+  };
+};
+var buildStripLayout = (segments, contentWidth) => {
+  const safeSegments = Array.isArray(segments) ? segments.filter(Boolean) : [];
+  const promptSegment = safeSegments.find((segment) => segment.kind === "prompt") || safeSegments[0] || null;
+  const metadataSegments = safeSegments.filter((segment) => segment !== promptSegment);
+  const zoneGap = DEFAULT_STRIP_ZONE_GAP;
+  let metadataRow = buildMetadataRowLayout(
+    metadataSegments,
+    Math.max(220, contentWidth)
+  );
+  let metadataStartX = Math.max(0, contentWidth - (metadataRow?.totalWidth || 0));
+  let promptAvailableWidth = Math.max(
+    220,
+    metadataStartX - zoneGap - DEFAULT_STRIP_PROMPT_TRAILING_PADDING
+  );
+  if (promptAvailableWidth < DEFAULT_STRIP_PROMPT_MIN_TOTAL_WIDTH && metadataSegments.length > 0) {
+    const tighterMetadataWidth = Math.max(180, contentWidth - DEFAULT_STRIP_PROMPT_MIN_TOTAL_WIDTH - zoneGap);
+    metadataRow = buildMetadataRowLayout(metadataSegments, tighterMetadataWidth);
+    metadataStartX = Math.max(0, contentWidth - (metadataRow?.totalWidth || 0));
+    promptAvailableWidth = Math.max(
+      220,
+      metadataStartX - zoneGap - DEFAULT_STRIP_PROMPT_TRAILING_PADDING
+    );
+  }
+  const preferredPromptWidth = Math.min(
+    promptAvailableWidth,
+    Math.max(280, Math.round(contentWidth * DEFAULT_STRIP_PROMPT_PREFERRED_WIDTH_RATIO))
+  );
+  let promptRow = buildPromptWrapLayout(promptSegment, preferredPromptWidth);
+  if (promptRow?.truncated && promptAvailableWidth > preferredPromptWidth + 24) {
+    promptRow = buildPromptWrapLayout(promptSegment, promptAvailableWidth);
+  }
+  const contentHeight = Math.max(
+    promptRow?.blockHeight || 0,
+    metadataRow?.rowHeight || 0,
+    24
+  );
+  const verticalPadding = contentHeight > (metadataRow?.rowHeight || 0) ? 18 : 16;
+  const stripHeight = Math.max(
+    contentHeight > (metadataRow?.rowHeight || 0) ? DEFAULT_STRIP_WRAPPED_MIN_HEIGHT : DEFAULT_STRIP_ONE_LINE_HEIGHT,
+    Math.ceil(contentHeight + verticalPadding * 2)
+  );
+  return {
+    mode: "zoned",
+    height: stripHeight,
+    contentHeight,
+    promptRow,
+    promptStartX: 0,
+    metadataRow,
+    metadataStartX
+  };
+};
+var renderStripRow = (row, options = {}) => {
+  const startX = Number(options.startX) || 0;
+  const centerY = Number(options.centerY) || 0;
+  const fontFamily = String(options.fontFamily || "");
+  const showDividers = options.showDividers !== false;
+  const layouts = Array.isArray(row?.layouts) ? row.layouts : [];
+  if (!layouts.length) {
+    return "";
+  }
+  const rowHeight = Math.max(18, Number(row?.rowHeight) || 18);
+  const dividerHalfHeight = Math.max(12, Math.round(rowHeight * 0.56));
+  const sectionGap = Math.max(0, Number(row?.sectionGap) || 0);
+  const svgSegments = [];
+  let currentX = startX;
+  layouts.forEach((segment, index) => {
+    const label = escapeXml(segment.label || "");
+    const value = escapeXml(segment.renderValue || "-");
+    const labelX = currentX;
+    const valueX = currentX + segment.labelWidth;
+    svgSegments.push(`
+            <text
+                x="${labelX}"
+                y="${centerY}"
+                fill="#111111"
+                fill-opacity="0.54"
+                font-family="${fontFamily}"
+                font-size="${segment.labelFontSize}"
+                font-weight="650"
+                dominant-baseline="middle"
+            >${label}</text>
+            <text
+                x="${valueX}"
+                y="${centerY}"
+                fill="#111111"
+                font-family="${fontFamily}"
+                font-size="${segment.valueFontSize}"
+                font-weight="${segment.kind === "prompt" ? 760 : 710}"
+                dominant-baseline="middle"
+            >${value}</text>
+        `);
+    currentX += segment.segmentWidth;
+    if (showDividers && index < layouts.length - 1) {
+      const lineX = currentX + Math.round(sectionGap / 2);
+      svgSegments.push(`
+                <line
+                    x1="${lineX}"
+                    y1="${centerY - dividerHalfHeight}"
+                    x2="${lineX}"
+                    y2="${centerY + dividerHalfHeight}"
+                    stroke="#94a3b8"
+                    stroke-opacity="0.34"
+                    stroke-width="1"
+                />
+            `);
+      currentX += sectionGap;
+    }
+  });
+  return svgSegments.join("");
+};
+var renderStripDivider = (x, centerY, height) => {
+  const safeX = Number(x) || 0;
+  const safeCenterY = Number(centerY) || 0;
+  const safeHeight = Math.max(18, Number(height) || 18);
+  const halfHeight = Math.max(12, Math.round(safeHeight * 0.56));
+  return `
+        <line
+            x1="${safeX}"
+            y1="${safeCenterY - halfHeight}"
+            x2="${safeX}"
+            y2="${safeCenterY + halfHeight}"
+            stroke="#94a3b8"
+            stroke-opacity="0.34"
+            stroke-width="1"
+        />
+    `;
 };
 var buildWatermarkifySvg = (meta, imageWidth, imageHeight) => {
   const hasWatermark = meta?.watermark?.enabled !== false && normalizeText(meta?.watermarkText);
@@ -5194,67 +5588,97 @@ var buildWatermarkifySvg = (meta, imageWidth, imageHeight) => {
     parts.push(`<g id="watermarks">${stamps.join("")}</g>`);
   }
   if (hasStrip) {
-    const stripHeight = DEFAULT_STRIP_HEIGHT;
-    const stripY = height - stripHeight;
     const logoSize = 28;
     const logoX = DEFAULT_STRIP_PADDING_LEFT;
-    const logoY = stripY + Math.round((stripHeight - logoSize) / 2);
     const contentStartX = logoX + logoSize + DEFAULT_STRIP_GAP;
     const contentWidth = width - contentStartX - DEFAULT_STRIP_PADDING_RIGHT;
+    const stripLayout = buildStripLayout(meta.stripSegments, contentWidth);
+    const stripHeight = stripLayout.height;
+    const stripY = height - stripHeight;
+    const logoY = Number((stripY + (stripHeight - logoSize) / 2).toFixed(2));
+    let stripContentSvg = "";
     const centerY = stripY + stripHeight / 2 + 1;
-    const layouts = buildStripSegmentLayouts(meta.stripSegments, contentWidth);
-    const svgSegments = [];
-    let currentX = contentStartX;
-    layouts.forEach((segment, index) => {
-      const label = escapeXml(segment.label || "");
-      const value = escapeXml(segment.renderValue || "-");
-      const labelX = currentX;
-      const valueX = currentX + segment.labelWidth;
-      svgSegments.push(`
+    const promptRow = stripLayout.promptRow;
+    const metadataRow = stripLayout.metadataRow;
+    const promptParts = [];
+    const hasPrompt = Boolean(promptRow?.label);
+    const hasMetadata = Array.isArray(metadataRow?.layouts) && metadataRow.layouts.length > 0;
+    const zoneDividerX = hasPrompt && hasMetadata ? contentStartX + stripLayout.metadataStartX - DEFAULT_STRIP_ZONE_GAP / 2 : null;
+    if (promptRow?.mode === "single") {
+      promptParts.push(renderStripRow({
+        layouts: [
+          {
+            kind: "prompt",
+            label: promptRow.label,
+            renderValue: promptRow.lines[0] || "-",
+            labelFontSize: promptRow.labelFontSize,
+            valueFontSize: promptRow.valueFontSize,
+            labelWidth: promptRow.labelWidth,
+            segmentWidth: promptRow.labelWidth + promptRow.valueWidth
+          }
+        ],
+        sectionGap: 0,
+        rowHeight: promptRow.blockHeight
+      }, {
+        startX: contentStartX + stripLayout.promptStartX,
+        centerY,
+        fontFamily,
+        showDividers: false
+      }));
+    } else if (promptRow) {
+      const promptStartX = contentStartX + stripLayout.promptStartX;
+      const labelX = promptStartX;
+      const valueX = promptStartX + promptRow.labelWidth;
+      const blockTop = centerY - promptRow.blockHeight / 2;
+      const labelY = centerY;
+      promptParts.push(`
                 <text
                     x="${labelX}"
-                    y="${centerY}"
-                    fill="#111111"
-                    fill-opacity="0.42"
-                    font-family="${fontFamily}"
-                    font-size="12"
-                    font-weight="600"
-                    dominant-baseline="middle"
-                >${label}</text>
-                <text
-                    x="${valueX}"
-                    y="${centerY}"
+                    y="${labelY}"
                     fill="#111111"
+                    fill-opacity="0.54"
                     font-family="${fontFamily}"
-                    font-size="${segment.fontSize}"
-                    font-weight="${segment.kind === "prompt" ? 760 : 710}"
+                    font-size="${promptRow.labelFontSize}"
+                    font-weight="650"
                     dominant-baseline="middle"
-                >${value}</text>
+                >${escapeXml(promptRow.label)}</text>
             `);
-      currentX += segment.segmentWidth;
-      if (index < layouts.length - 1) {
-        const lineX = currentX + 8;
-        svgSegments.push(`
-                    <line
-                        x1="${lineX}"
-                        y1="${stripY + 26}"
-                        x2="${lineX}"
-                        y2="${stripY + stripHeight - 26}"
-                        stroke="#94a3b8"
-                        stroke-opacity="0.34"
-                        stroke-width="1"
-                    />
+      promptRow.lines.forEach((line, index) => {
+        const lineY = blockTop + index * promptRow.lineHeight + promptRow.lineHeight / 2;
+        promptParts.push(`
+                    <text
+                        x="${valueX}"
+                        y="${lineY}"
+                        fill="#111111"
+                        font-family="${fontFamily}"
+                        font-size="${promptRow.valueFontSize}"
+                        font-weight="760"
+                        dominant-baseline="middle"
+                    >${escapeXml(line)}</text>
                 `);
-        currentX += DEFAULT_STRIP_GAP + 16;
-      }
-    });
+      });
+    }
+    stripContentSvg = [
+      promptParts.join(""),
+      zoneDividerX == null ? "" : renderStripDivider(
+        zoneDividerX,
+        centerY,
+        Math.max(promptRow?.blockHeight || 0, metadataRow?.rowHeight || 0)
+      ),
+      renderStripRow(metadataRow, {
+        startX: contentStartX + stripLayout.metadataStartX,
+        centerY,
+        fontFamily,
+        showDividers: true
+      })
+    ].join("");
     parts.push(`
             <g id="strip">
                 <rect x="0" y="${stripY}" width="${width}" height="${stripHeight}" fill="#ffffff" fill-opacity="0.985" />
                 <rect x="0" y="${stripY}" width="${width}" height="1" fill="#111111" fill-opacity="0.10" />
                 <rect x="${DEFAULT_STRIP_PADDING_LEFT}" y="${stripY}" width="${Math.max(120, Math.round(width * 0.42))}" height="2" fill="url(#stripAccent)" />
                 ${meta.stripLogoSrc ? `<image href="${escapeXml(meta.stripLogoSrc)}" x="${logoX}" y="${logoY}" width="${logoSize}" height="${logoSize}" />` : ""}
-                ${svgSegments.join("")}
+                ${stripContentSvg}
             </g>
         `);
   }
@@ -5293,7 +5717,7 @@ var watermarkifyScreenshotBuffer = async (buffer, meta) => {
 };
 
 // src/share.js
-var logger11 = createInternalLogger("Share");
+var logger12 = createInternalLogger("Share");
 var DEFAULT_TIMEOUT_MS2 = 50 * 1e3;
 var DEFAULT_PAYLOAD_SNAPSHOT_MAX_LEN = 500;
 var DEFAULT_POLL_INTERVAL_MS = 120;
@@ -5370,6 +5794,20 @@ var normalizeShare = (share) => {
     xurl: normalizeXurl(source.xurl)
   };
 };
+var resolveCaptureScreenWatermarkify = (page, optionValue) => {
+  if (optionValue === false) {
+    return normalizeScreenshotWatermarkify(false);
+  }
+  const runtimeQuery = String(page?.[PageRuntimeStateKey]?.query || "").trim();
+  if (optionValue == null || optionValue === true) {
+    return normalizeScreenshotWatermarkify(runtimeQuery ? { query: runtimeQuery } : true);
+  }
+  const optionSource = optionValue && typeof optionValue === "object" ? optionValue : {};
+  return normalizeScreenshotWatermarkify({
+    ...runtimeQuery ? { query: runtimeQuery } : {},
+    ...optionSource
+  });
+};
 var getByPathSegments = (source, pathSegments) => {
   if (!Array.isArray(pathSegments) || pathSegments.length === 0) return void 0;
   let current = source;
@@ -5416,7 +5854,7 @@ var createDomShareMonitor = async (page, options = {}) => {
   const onMatch = typeof options.onMatch === "function" ? options.onMatch : null;
   const onTelemetry = typeof options.onTelemetry === "function" ? options.onTelemetry : null;
   let matched = false;
-  logger11.info(`DOM \u76D1\u542C\u51C6\u5907\u6302\u8F7D: selectors=${toJsonInline(selectors, 120)}, mode=${mode}`);
+  logger12.info(`DOM \u76D1\u542C\u51C6\u5907\u6302\u8F7D: selectors=${toJsonInline(selectors, 120)}, mode=${mode}`);
   const monitor = await Mutation.useMonitor(page, selectors, {
     mode,
     onMutation: (context = {}) => {
@@ -5434,12 +5872,12 @@ ${text}`;
         });
       }
       if (mutationCount <= 5 || mutationCount % 50 === 0) {
-        logger11.info(`DOM \u53D8\u5316\u5DF2\u6355\u83B7: mutationCount=${mutationCount}, mutationNodes=${mutationNodes.length}`);
+        logger12.info(`DOM \u53D8\u5316\u5DF2\u6355\u83B7: mutationCount=${mutationCount}, mutationNodes=${mutationNodes.length}`);
       }
       const [candidate] = Utils.parseLinks(rawDom, { prefix }) || [];
       if (!candidate) return;
       matched = true;
-      logger11.success("captureLink.domHit", `DOM \u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: mutationCount=${mutationCount}, link=${candidate}`);
+      logger12.success("captureLink.domHit", `DOM \u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: mutationCount=${mutationCount}, link=${candidate}`);
       if (onMatch) {
         onMatch({
           link: candidate,
@@ -5455,7 +5893,7 @@ ${text}`;
   return {
     stop: async () => {
       const result = await monitor.stop();
-      logger11.info(`DOM \u76D1\u542C\u5DF2\u505C\u6B62: totalMutations=${result?.totalMutations || 0}`);
+      logger12.info(`DOM \u76D1\u542C\u5DF2\u505C\u6B62: totalMutations=${result?.totalMutations || 0}`);
       return result;
     }
   };
@@ -5495,8 +5933,8 @@ var Share = {
     if (share.mode === "response" && apiMatchers.length === 0) {
       throw new Error("Share.captureLink requires share.xurl[0] api matcher when mode=response");
     }
-    logger11.start("captureLink", `mode=${share.mode}, timeoutMs=${timeoutMs}, prefix=${share.prefix}`);
-    logger11.info(`captureLink \u914D\u7F6E: xurl=${toJsonInline(share.xurl)}, domMode=${domMode}, domSelectors=${toJsonInline(domSelectors, 120)}`);
+    logger12.start("captureLink", `mode=${share.mode}, timeoutMs=${timeoutMs}, prefix=${share.prefix}`);
+    logger12.info(`captureLink \u914D\u7F6E: xurl=${toJsonInline(share.xurl)}, domMode=${domMode}, domSelectors=${toJsonInline(domSelectors, 120)}`);
     const stats = {
       actionTimedOut: false,
       domMutationCount: 0,
@@ -5521,7 +5959,7 @@ var Share = {
         link: validated,
         payloadText: String(payloadText || "")
       };
-      logger11.info(`\u5019\u9009\u94FE\u63A5\u5DF2\u786E\u8BA4: source=${source}, link=${validated}`);
+      logger12.info(`\u5019\u9009\u94FE\u63A5\u5DF2\u786E\u8BA4: source=${source}, link=${validated}`);
       return true;
     };
     const resolveResponseCandidate = (responseText) => {
@@ -5556,7 +5994,7 @@ var Share = {
       try {
         await monitor.stop();
       } catch (error) {
-        logger11.warning(`\u505C\u6B62 DOM \u76D1\u542C\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+        logger12.warning(`\u505C\u6B62 DOM \u76D1\u542C\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
       }
     };
     const onResponse = async (response) => {
@@ -5569,29 +6007,29 @@ var Share = {
           stats.responseSampleUrls.push(url);
         }
         if (stats.responseObserved <= 5) {
-          logger11.info(`\u63A5\u53E3\u54CD\u5E94\u91C7\u6837(${stats.responseObserved}): ${url}`);
+          logger12.info(`\u63A5\u53E3\u54CD\u5E94\u91C7\u6837(${stats.responseObserved}): ${url}`);
         }
         if (!apiMatchers.some((matcher) => url.includes(matcher))) return;
         stats.responseMatched += 1;
         stats.lastMatchedUrl = url;
-        logger11.info(`\u63A5\u53E3\u547D\u4E2D\u5339\u914D(${stats.responseMatched}): ${url}`);
+        logger12.info(`\u63A5\u53E3\u547D\u4E2D\u5339\u914D(${stats.responseMatched}): ${url}`);
         const text = await response.text();
         const hit = resolveResponseCandidate(text);
         if (!hit?.link) {
           if (stats.responseMatched <= 3) {
-            logger11.info(`\u63A5\u53E3\u89E3\u6790\u5B8C\u6210\u4F46\u672A\u63D0\u53D6\u5230\u5206\u4EAB\u94FE\u63A5: payloadSize=${text.length}`);
+            logger12.info(`\u63A5\u53E3\u89E3\u6790\u5B8C\u6210\u4F46\u672A\u63D0\u53D6\u5230\u5206\u4EAB\u94FE\u63A5: payloadSize=${text.length}`);
           }
           return;
         }
         stats.responseResolved += 1;
-        logger11.success("captureLink.responseHit", `\u63A5\u53E3\u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: url=${url}, link=${hit.link}`);
+        logger12.success("captureLink.responseHit", `\u63A5\u53E3\u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: url=${url}, link=${hit.link}`);
         setCandidate("response", hit.link, hit.payloadText);
       } catch (error) {
-        logger11.warning(`\u63A5\u53E3\u54CD\u5E94\u5904\u7406\u5F02\u5E38: ${error instanceof Error ? error.message : String(error)}`);
+        logger12.warning(`\u63A5\u53E3\u54CD\u5E94\u5904\u7406\u5F02\u5E38: ${error instanceof Error ? error.message : String(error)}`);
       }
     };
     if (share.mode === "dom") {
-      logger11.info("\u5F53\u524D\u4E3A DOM \u6A21\u5F0F\uFF0C\u4EC5\u542F\u7528 DOM \u76D1\u542C");
+      logger12.info("\u5F53\u524D\u4E3A DOM \u6A21\u5F0F\uFF0C\u4EC5\u542F\u7528 DOM \u76D1\u542C");
       domMonitor = await createDomShareMonitor(page, {
         prefix: share.prefix,
         selectors: domSelectors,
@@ -5606,14 +6044,14 @@ var Share = {
       });
     }
     if (share.mode === "response") {
-      logger11.info(`\u5F53\u524D\u4E3A\u63A5\u53E3\u6A21\u5F0F\uFF0C\u6302\u8F7D response \u76D1\u542C: apiMatchers=${toJsonInline(apiMatchers, 160)}`);
+      logger12.info(`\u5F53\u524D\u4E3A\u63A5\u53E3\u6A21\u5F0F\uFF0C\u6302\u8F7D response \u76D1\u542C: apiMatchers=${toJsonInline(apiMatchers, 160)}`);
       page.on("response", onResponse);
     }
     const deadline = Date.now() + timeoutMs;
     const getRemainingMs = () => Math.max(0, deadline - Date.now());
     try {
       const actionTimeout = getRemainingMs();
-      logger11.start("captureLink.performActions", `\u6267\u884C\u52A8\u4F5C\u9884\u7B97=${actionTimeout}ms`);
+      logger12.start("captureLink.performActions", `\u6267\u884C\u52A8\u4F5C\u9884\u7B97=${actionTimeout}ms`);
       if (actionTimeout > 0) {
         let timer = null;
         let actionError = null;
@@ -5627,21 +6065,21 @@ var Share = {
         const actionResult = await Promise.race([actionPromise, timeoutPromise]);
         if (timer) clearTimeout(timer);
         if (actionResult === "__ACTION_ERROR__") {
-          logger11.fail("captureLink.performActions", actionError);
+          logger12.fail("captureLink.performActions", actionError);
           throw actionError;
         }
         if (actionResult === "__ACTION_TIMEOUT__") {
           stats.actionTimedOut = true;
-          logger11.warning(`performActions \u5DF2\u8D85\u65F6 (${actionTimeout}ms)\uFF0C\u52A8\u4F5C\u53EF\u80FD\u4ECD\u5728\u5F02\u6B65\u6267\u884C`);
+          logger12.warning(`performActions \u5DF2\u8D85\u65F6 (${actionTimeout}ms)\uFF0C\u52A8\u4F5C\u53EF\u80FD\u4ECD\u5728\u5F02\u6B65\u6267\u884C`);
         } else {
-          logger11.success("captureLink.performActions", "\u6267\u884C\u52A8\u4F5C\u5B8C\u6210");
+          logger12.success("captureLink.performActions", "\u6267\u884C\u52A8\u4F5C\u5B8C\u6210");
         }
       }
       let nextProgressLogTs = Date.now() + 3e3;
       while (true) {
         const selected = share.mode === "dom" ? candidates.dom : candidates.response;
         if (selected?.link) {
-          logger11.success("captureLink", `\u6355\u83B7\u6210\u529F: source=${share.mode}, link=${selected.link}`);
+          logger12.success("captureLink", `\u6355\u83B7\u6210\u529F: source=${share.mode}, link=${selected.link}`);
           return {
             link: selected.link,
             payloadText: selected.payloadText,
@@ -5653,7 +6091,7 @@ var Share = {
         if (remaining <= 0) break;
         const now = Date.now();
         if (now >= nextProgressLogTs) {
-          logger11.info(
+          logger12.info(
             `captureLink \u7B49\u5F85\u4E2D: remaining=${remaining}ms, domMutationCount=${stats.domMutationCount}, responseMatched=${stats.responseMatched}`
           );
           nextProgressLogTs = now + 5e3;
@@ -5661,11 +6099,11 @@ var Share = {
         await (0, import_delay2.default)(Math.max(0, Math.min(DEFAULT_POLL_INTERVAL_MS, remaining)));
       }
       if (share.mode === "response" && stats.responseMatched === 0) {
-        logger11.warning(
+        logger12.warning(
           `\u63A5\u53E3\u76D1\u542C\u672A\u547D\u4E2D: apiMatchers=${toJsonInline(apiMatchers, 220)}, \u54CD\u5E94\u6837\u672CURLs=${toJsonInline(stats.responseSampleUrls, 420)}`
         );
       }
-      logger11.warning(
+      logger12.warning(
         `captureLink \u8D85\u65F6\u672A\u62FF\u5230\u94FE\u63A5: mode=${share.mode}, actionTimedOut=${stats.actionTimedOut}, domMutationCount=${stats.domMutationCount}, responseObserved=${stats.responseObserved}, responseMatched=${stats.responseMatched}, lastMatchedUrl=${stats.lastMatchedUrl || "none"}`
       );
       return {
@@ -5677,7 +6115,7 @@ var Share = {
     } finally {
       if (share.mode === "response") {
         page.off("response", onResponse);
-        logger11.info("response \u76D1\u542C\u5DF2\u5378\u8F7D");
+        logger12.info("response \u76D1\u542C\u5DF2\u5378\u8F7D");
       }
       await stopDomMonitor();
     }
@@ -5693,12 +6131,12 @@ var Share = {
    * @returns {Promise<string>} base64 png
    */
   async captureScreen(page, options = {}) {
-    const originalViewport = page.viewportSize();
-    const defaultBuffer = Math.round((originalViewport?.height || 1080) / 2);
+    const originalViewport = await resolveCurrentViewportSize(page);
+    const defaultBuffer = Math.round((originalViewport.height || 1080) / 2);
     const buffer = options.buffer ?? defaultBuffer;
     const restore = options.restore ?? false;
     const maxHeight = options.maxHeight ?? 8e3;
-    const screenshotWatermarkify = normalizeScreenshotWatermarkify(options.watermarkify ?? true);
+    const screenshotWatermarkify = resolveCaptureScreenWatermarkify(page, options.watermarkify);
     try {
       const maxScrollHeight = await page.evaluate(() => {
         let maxHeight2 = document.body.scrollHeight;
@@ -5722,7 +6160,7 @@ var Share = {
       });
       const targetHeight = Math.min(maxScrollHeight + buffer, maxHeight);
       await page.setViewportSize({
-        width: originalViewport?.width || 1280,
+        width: originalViewport.width,
         height: targetHeight
       });
       await (0, import_delay2.default)(1e3);
@@ -5754,9 +6192,7 @@ var Share = {
             el.classList.remove("__pk_expanded__");
           });
         });
-        if (originalViewport) {
-          await page.setViewportSize(originalViewport);
-        }
+        await page.setViewportSize(originalViewport);
       }
     }
   }