@skrillex1224/playwright-toolkit 2.1.210 → 2.1.211

package/dist/index.cjs

@@ -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) => {
@@ -4560,11 +4598,26 @@ 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_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,7 @@ var LOCATION_NETWORK_SUFFIX_PATTERNS = [
   /digitalocean$/i
 ];
 var cachedStripLogoSrcPromise = null;
+var cachedEnrichmentByContext = /* @__PURE__ */ new WeakMap();
 var normalizeText = (value) => String(value || "").trim();
 var toInline = (value, maxLen = 200) => {
   const text = normalizeText(value);
@@ -4600,6 +4654,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 ? "+" : "-";
@@ -4672,6 +4735,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);
@@ -4801,44 +4887,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) {
@@ -4883,10 +4968,14 @@ 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)
   };
+  if (!merged.ip || !merged.location) {
+    fillEnrichment(merged, cached);
+  }
   if (!merged.ip || !merged.location) {
     fillEnrichment(
       merged,
@@ -4910,6 +4999,7 @@ var resolveEnrichment = async (page, baseMeta, options) => {
       merged.location = headerLocation || merged.location;
     }
   }
+  writeCachedEnrichment(page, merged);
   return merged;
 };
 var buildWatermarkStamp = ({ prompt, captureTime, ip, location }) => {
@@ -4922,7 +5012,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 +5034,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 +5062,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 +5120,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 +5174,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 safeTotalWidth = Math.max(labelWidth + 56, Number(contentWidth) || 0);
+  const valueWidth = Math.max(
+    56,
+    safeTotalWidth - labelWidth - DEFAULT_STRIP_CONTENT_SAFE_PADDING_X
   );
-  const promptLayout = promptSegment ? {
-    ...promptSegment,
-    fontSize: promptFontSize,
+  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 +5549,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}"
+                    y="${labelY}"
                     fill="#111111"
-                    fill-opacity="0.42"
+                    fill-opacity="0.54"
                     font-family="${fontFamily}"
-                    font-size="12"
-                    font-weight="600"
+                    font-size="${promptRow.labelFontSize}"
+                    font-weight="650"
                     dominant-baseline="middle"
-                >${label}</text>
-                <text
-                    x="${valueX}"
-                    y="${centerY}"
-                    fill="#111111"
-                    font-family="${fontFamily}"
-                    font-size="${segment.fontSize}"
-                    font-weight="${segment.kind === "prompt" ? 760 : 710}"
-                    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>
         `);
   }
@@ -5370,6 +5755,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;
@@ -5693,12 +6092,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 +6121,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 +6153,7 @@ var Share = {
             el.classList.remove("__pk_expanded__");
           });
         });
-        if (originalViewport) {
-          await page.setViewportSize(originalViewport);
-        }
+        await page.setViewportSize(originalViewport);
       }
     }
   }