opendevbrowser 0.0.34 → 0.0.35

package/dist/{chunk-XRDCSHKZ.js → chunk-AHQC4A6P.js}

@@ -52,11 +52,13 @@ import {
   createDefaultRuntime,
   extractStructuredContent,
   inspectChallengePlanFromRuntime,
+  inspectPinterestPinMediaBuffer,
+  isPinterestPinMediaEvidenceContentType,
   resolveChallengeAutomationPolicy,
   resolveProviderRuntimePolicy,
   resolveWorkflowArtifactRoot,
   toSnippet
-} from "./chunk-5FDXH4CS.js";
+} from "./chunk-WTWSBEBW.js";
 import {
   buildBlockerArtifacts,
   classifyBlockerSignal,
@@ -3664,8 +3666,9 @@ import { parse, resolve as resolve6 } from "path";
 
 // src/browser/browser-manager.ts
 import { randomUUID as randomUUID11 } from "crypto";
-import { access as access2, mkdir as mkdir5, rm as rm3, writeFile as writeFile3 } from "fs/promises";
-import { join as join10 } from "path";
+import { constants as fsConstants } from "fs";
+import { access as access2, mkdir as mkdir5, open, rm as rm3, unlink, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join10 } from "path";
 import { freemem, totalmem } from "os";
 import { Mutex } from "async-mutex";
 
@@ -6713,6 +6716,469 @@ var BrowserScreencastRecorder = class {
 
 // src/browser/browser-manager.ts
 var LEGACY_EXTENSION_OPERATION_TIMEOUT_MS = 5e3;
+var PINTEREST_PIN_MEDIA_DEFAULT_TIMEOUT_MS = 5e3;
+var PINTEREST_PIN_MEDIA_DOM_INSPECTION_MAX_TIMEOUT_MS = 1e4;
+var PINTEREST_PIN_MEDIA_CDP_SESSION_MAX_TIMEOUT_MS = 5e3;
+var PINTEREST_PIN_MEDIA_CDP_DETACH_MAX_TIMEOUT_MS = 1e3;
+var PINTEREST_PIN_MEDIA_FETCH_MAX_TIMEOUT_MS = 2e4;
+var PINTEREST_PIN_MEDIA_MAX_BYTES = 2e7;
+var PINTEREST_PIN_MEDIA_MAX_REDIRECTS = 3;
+var PINTEREST_PIN_MEDIA_MIN_EDGE_PX = 160;
+var PINTEREST_PIN_MEDIA_REJECTION_LIMIT = 12;
+var PINTEREST_PIN_IMAGE_MEDIA_HOST = "i.pinimg.com";
+var PINTEREST_PIN_VIDEO_MEDIA_HOST = "v.pinimg.com";
+var PINTEREST_PIN_VIDEO_MEDIA_HOST_PATTERN = /^v\d+(?:-[a-z]+)?\.pinimg\.com$/i;
+var PINTEREST_PIN_MEDIA_VIDEO_CONTENT_TYPE = "video/mp4";
+var PINTEREST_PIN_MEDIA_GENERIC_BINARY_CONTENT_TYPES = /* @__PURE__ */ new Set([
+  "application/octet-stream",
+  "application/x-binary",
+  "binary/octet-stream"
+]);
+var MP4_FILE_TYPE_BOX_MIN_BYTES = 12;
+var MP4_FILE_TYPE_BOX_MARKER_START = 4;
+var MP4_FILE_TYPE_BOX_MARKER_END = 8;
+var MP4_FILE_TYPE_BOX_MARKER = "ftyp";
+var HTTP_REDIRECT_STATUS_MIN = 300;
+var HTTP_REDIRECT_STATUS_MAX_EXCLUSIVE = 400;
+var PINTEREST_PIN_MEDIA_NOFOLLOW_FLAG = typeof fsConstants.O_NOFOLLOW === "number" ? fsConstants.O_NOFOLLOW : 0;
+var PINTEREST_PIN_MEDIA_OUTPUT_OPEN_FLAGS = fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | PINTEREST_PIN_MEDIA_NOFOLLOW_FLAG;
+function pinterestPinSourceChanged(pageUrl, extractedSourceUrl) {
+  const pagePinId = extractPinterestPinId(pageUrl);
+  const extractedPinId = extractPinterestPinId(extractedSourceUrl);
+  return Boolean(pagePinId && extractedPinId && pagePinId !== extractedPinId);
+}
+function readAuthoritativePinterestSourceUrl(pageUrl, extractedSourceUrl) {
+  return extractPinterestPinId(extractedSourceUrl) ? extractedSourceUrl : pageUrl;
+}
+function extractPinterestPinId(value) {
+  if (!value) {
+    return void 0;
+  }
+  const match = value.match(/\/pin\/(\d+)/i);
+  return match?.[1];
+}
+function isFirstPartyPinterestMediaUrl(value) {
+  if (!value) {
+    return false;
+  }
+  try {
+    const parsed = new URL(value);
+    const hostname = parsed.hostname.toLowerCase();
+    return parsed.protocol === "https:" && (hostname === PINTEREST_PIN_IMAGE_MEDIA_HOST || hostname === PINTEREST_PIN_VIDEO_MEDIA_HOST || PINTEREST_PIN_VIDEO_MEDIA_HOST_PATTERN.test(hostname));
+  } catch {
+    return false;
+  }
+}
+function isFirstPartyPinterestVideoMediaUrl(value) {
+  if (!value) {
+    return false;
+  }
+  try {
+    const parsed = new URL(value);
+    const hostname = parsed.hostname.toLowerCase();
+    return parsed.protocol === "https:" && parsed.pathname.toLowerCase().endsWith(".mp4") && (hostname === PINTEREST_PIN_VIDEO_MEDIA_HOST || PINTEREST_PIN_VIDEO_MEDIA_HOST_PATTERN.test(hostname));
+  } catch {
+    return false;
+  }
+}
+function normalizePinterestResponseContentType(contentType) {
+  const normalized = contentType?.split(";")[0]?.trim().toLowerCase();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function isLikelyMp4Bytes(bytes) {
+  return bytes.length >= MP4_FILE_TYPE_BOX_MIN_BYTES && bytes.subarray(MP4_FILE_TYPE_BOX_MARKER_START, MP4_FILE_TYPE_BOX_MARKER_END).toString("ascii") === MP4_FILE_TYPE_BOX_MARKER;
+}
+function isCompatiblePinterestVideoContentType(contentType) {
+  return !contentType || contentType === PINTEREST_PIN_MEDIA_VIDEO_CONTENT_TYPE || PINTEREST_PIN_MEDIA_GENERIC_BINARY_CONTENT_TYPES.has(contentType);
+}
+function isCompatiblePinterestImageContentType(contentType) {
+  return !contentType || PINTEREST_PIN_MEDIA_GENERIC_BINARY_CONTENT_TYPES.has(contentType) || isPinterestPinMediaEvidenceContentType(contentType) && contentType.startsWith("image/");
+}
+function assertFetchedPinterestCandidateMatchesKind(candidate, fetched) {
+  const contentType = normalizePinterestResponseContentType(fetched.contentType);
+  if (candidate.kind === "video") {
+    if (!isFirstPartyPinterestVideoMediaUrl(fetched.finalUrl)) {
+      throw new Error("Pinterest pin media video fetch returned a non-MP4 final URL.");
+    }
+    if (!isCompatiblePinterestVideoContentType(contentType)) {
+      throw new Error("Pinterest pin media video fetch returned non-MP4 content.");
+    }
+    if (!isLikelyMp4Bytes(fetched.bytes)) {
+      throw new Error("Pinterest pin media video fetch returned bytes without an MP4 file type box.");
+    }
+    return;
+  }
+  if (!isCompatiblePinterestImageContentType(contentType)) {
+    throw new Error("Pinterest pin media image fetch returned non-image content.");
+  }
+  const byteInspection = inspectPinterestPinMediaBuffer(fetched.bytes);
+  if (!byteInspection.contentType?.startsWith("image/")) {
+    throw new Error("Pinterest pin media image fetch returned bytes without an image signature.");
+  }
+  if (contentType && !PINTEREST_PIN_MEDIA_GENERIC_BINARY_CONTENT_TYPES.has(contentType) && contentType !== byteInspection.contentType) {
+    throw new Error("Pinterest pin media image fetch returned bytes that do not match the response content type.");
+  }
+}
+function pinterestCandidateArea(candidate) {
+  const width = candidate.width ?? candidate.naturalWidth ?? candidate.rect?.width ?? 0;
+  const height = candidate.height ?? candidate.naturalHeight ?? candidate.rect?.height ?? 0;
+  return width * height;
+}
+function summarizeRejectedPinterestCandidate(candidate, reasons) {
+  return {
+    kind: candidate.kind,
+    ...candidate.mediaUrl ? { mediaUrl: candidate.mediaUrl } : {},
+    ...candidate.candidateSelector ? { candidateSelector: candidate.candidateSelector } : {},
+    ...candidate.candidateRole ? { candidateRole: candidate.candidateRole } : {},
+    ...candidate.alt ? { alt: candidate.alt } : {},
+    ...candidate.width ? { width: candidate.width } : {},
+    ...candidate.height ? { height: candidate.height } : {},
+    ...candidate.rect ? { rect: candidate.rect } : {},
+    ancestry: candidate.ancestry.slice(0, 6),
+    reasons
+  };
+}
+function rejectionReasonsForPinterestCandidate(candidate, sourcePinId) {
+  const reasons = [];
+  if (!isFirstPartyPinterestMediaUrl(candidate.mediaUrl)) {
+    reasons.push("non_first_party_media_url");
+  }
+  if (!candidate.visible) {
+    reasons.push("not_visible");
+  }
+  const width = candidate.width ?? candidate.naturalWidth ?? candidate.rect?.width ?? 0;
+  const height = candidate.height ?? candidate.naturalHeight ?? candidate.rect?.height ?? 0;
+  if (width < PINTEREST_PIN_MEDIA_MIN_EDGE_PX || height < PINTEREST_PIN_MEDIA_MIN_EDGE_PX) {
+    reasons.push("media_too_small");
+  }
+  if (!sourcePinId) {
+    reasons.push("missing_source_pin_id");
+  }
+  if (sourcePinId && candidate.linkedPinId && candidate.linkedPinId !== sourcePinId) {
+    reasons.push("linked_to_different_pin");
+  }
+  if (sourcePinId && !candidate.linkedPinId && !candidate.insideCanonicalMainPinMediaContainer) {
+    reasons.push("missing_pin_source_proof");
+  }
+  const noiseHasCanonicalSourceProof = Boolean(
+    candidate.insideCanonicalMainPinMediaContainer && sourcePinId && (!candidate.linkedPinId || candidate.linkedPinId === sourcePinId)
+  );
+  if (candidate.noiseSignals.length > 0 && !noiseHasCanonicalSourceProof) {
+    reasons.push(`noise_ancestry:${candidate.noiseSignals[0]}`);
+  }
+  return reasons;
+}
+function selectPinterestPinMediaCandidate(extraction, pageUrl) {
+  const sourcePinId = extractPinterestPinId(pageUrl);
+  const accepted = [];
+  const rejected = [];
+  for (const candidate of extraction.candidates) {
+    const reasons = rejectionReasonsForPinterestCandidate(candidate, sourcePinId);
+    if (reasons.length === 0) {
+      accepted.push(candidate);
+    } else if (rejected.length < PINTEREST_PIN_MEDIA_REJECTION_LIMIT) {
+      rejected.push(summarizeRejectedPinterestCandidate(candidate, reasons));
+    }
+  }
+  accepted.sort((left, right) => {
+    const scoreDelta = right.score - left.score;
+    return scoreDelta !== 0 ? scoreDelta : pinterestCandidateArea(right) - pinterestCandidateArea(left);
+  });
+  return { selected: accepted[0], acceptedCandidates: accepted, rejectedCandidates: rejected };
+}
+function warningsForSelectedPinterestCandidate(candidate) {
+  const warnings = /* @__PURE__ */ new Set();
+  for (const signal of candidate.noiseSignals) {
+    warnings.add(signal === "shopping" ? "pin_media_noise:ad_shopping" : `pin_media_noise:${signal}`);
+  }
+  return Array.from(warnings);
+}
+function pinterestCandidateCaptureFailureReason(error) {
+  if (error instanceof Error && error.name === "AbortError") return "selected_candidate_fetch_failed:aborted";
+  return "selected_candidate_fetch_failed";
+}
+function clampPinterestPinMediaOperationTimeout(timeoutMs, maxTimeoutMs) {
+  if (!Number.isFinite(timeoutMs)) {
+    return maxTimeoutMs;
+  }
+  return Math.max(1, Math.min(timeoutMs, maxTimeoutMs));
+}
+function isPinterestPinMediaDomInspectionTimeout(error) {
+  return error instanceof Error && error.message.startsWith("Pinterest pin media DOM inspection timed out");
+}
+function parsePinterestPinMediaCdpExtraction(result) {
+  if (result.exceptionDetails) {
+    const detail = result.exceptionDetails.exception?.description ?? result.exceptionDetails.text;
+    throw new Error(detail ?? "Pinterest pin media CDP inspection failed.");
+  }
+  const value = result.result?.value;
+  if (!value || typeof value.sourceUrl !== "string" || !Array.isArray(value.candidates)) {
+    throw new Error("Pinterest pin media CDP inspection returned an invalid result.");
+  }
+  return value;
+}
+async function withPinterestPinMediaOperationTimeout(operation, timeoutMs, message) {
+  let timer = null;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}
+function detachPinterestPinMediaCdpSession(session) {
+  void withPinterestPinMediaOperationTimeout(
+    session.detach(),
+    PINTEREST_PIN_MEDIA_CDP_DETACH_MAX_TIMEOUT_MS,
+    `Pinterest pin media CDP session detach timed out after ${PINTEREST_PIN_MEDIA_CDP_DETACH_MAX_TIMEOUT_MS}ms.`
+  ).catch(() => void 0);
+}
+function readPinterestPinMediaCandidatesInPage() {
+  const maxCandidates = 30;
+  const ancestryLimit = 6;
+  const selectors = [
+    "img.closeup-image-main-MainPinImage",
+    "img[class*='closeup-image-main-MainPinImage']",
+    "img[elementtiming='closeup-image-main-MainPinImage']",
+    "img.StoryPinImageBlock-MainPinImage",
+    "img[class*='StoryPinImageBlock-MainPinImage']",
+    "[data-test-id='closeup-image-main'] img",
+    "[data-test-id='closeup-image'] img",
+    "[id^='closeup-image-container-'] img",
+    "[class*='closeup-image-main-MainPinImage'] img",
+    "[class*='StoryPinImageBlock-MainPinImage'] img",
+    "video",
+    "video[poster]",
+    "[data-test-id*='pin'] video",
+    "[data-test-id*='pin'] video[poster]",
+    "[data-test-id*='closeup'] video",
+    "[data-test-id*='closeup'] video[poster]"
+  ];
+  const elements = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const selector of selectors) {
+    for (const element of Array.from(document.querySelectorAll(selector))) {
+      if (!seen.has(element) && elements.length < maxCandidates) {
+        seen.add(element);
+        elements.push(element);
+      }
+    }
+  }
+  const describeElement = (element) => {
+    const tag = element.tagName.toLowerCase();
+    const id2 = element.id ? `#${element.id.slice(0, 48)}` : "";
+    const classes = Array.from(element.classList).slice(0, 4).map((value) => `.${value.slice(0, 48)}`).join("");
+    const testId = element.getAttribute("data-test-id");
+    const role = element.getAttribute("role");
+    return [tag + id2 + classes, testId ? `data-test-id=${testId.slice(0, 80)}` : "", role ? `role=${role}` : ""].filter(Boolean).join(" ");
+  };
+  const ancestryFor = (element) => {
+    const ancestry = [];
+    let current = element;
+    while (current && ancestry.length < ancestryLimit) {
+      ancestry.push(describeElement(current));
+      current = current.parentElement;
+    }
+    return { ancestry, combined: ancestry.join(" ").toLowerCase() };
+  };
+  const readPinId = (element) => {
+    const link = element.closest("a[href*='/pin/']");
+    const href = link?.getAttribute("href") ?? "";
+    const match = href.match(/\/pin\/(\d+)/i);
+    return match?.[1];
+  };
+  const isInsideCanonicalMainPinMediaContainer = (element) => {
+    const container = element.closest([
+      "[data-test-id='pin-closeup']",
+      "[data-test-id='story-pin']",
+      "[data-test-id='closeup-layout']",
+      "[data-test-id='closeup-image']",
+      "[data-test-id='closeup-image-main']",
+      "[data-test-id='pdp-container']",
+      "[data-test-id='pin-closeup-image']",
+      "[data-test-id='pin-closeup-image-container']",
+      "[data-test-id='visual-content-container']"
+    ].join(","));
+    if (!container) {
+      return false;
+    }
+    let current = element;
+    while (current && current !== container) {
+      if (readNoiseSignals(describeElement(current).toLowerCase()).length > 0) {
+        return false;
+      }
+      current = current.parentElement;
+    }
+    return true;
+  };
+  const hasDelimitedNoiseToken = (combined, token) => new RegExp(`(^|[^a-z0-9])${token}($|[^a-z0-9])`).test(combined);
+  const readNoiseSignals = (combined) => {
+    const signals = [];
+    const checks = [
+      [(value) => value.includes("related"), "related"],
+      [(value) => value.includes("recommend"), "recommendation"],
+      [(value) => value.includes("rail"), "rail"],
+      [(value) => value.includes("carousel"), "carousel"],
+      [(value) => value.includes("grid"), "grid"],
+      [(value) => value.includes("search"), "search"],
+      [(value) => value.includes("avatar"), "avatar"],
+      [(value) => value.includes("profile"), "profile"],
+      [(value) => value.includes("comment"), "comment"],
+      [(value) => hasDelimitedNoiseToken(value, "ad") || hasDelimitedNoiseToken(value, "ads"), "ad"],
+      [(value) => value.includes("promoted"), "ad"],
+      [(value) => value.includes("sponsor"), "ad"],
+      [(value) => value.includes("shopping"), "shopping"],
+      [(value) => value.includes("shop"), "shopping"],
+      [(value) => value.includes("thumbnail"), "thumbnail"],
+      [(value) => value.includes("thumb"), "thumbnail"]
+    ];
+    for (const [matches, signal] of checks) {
+      if (matches(combined) && !signals.includes(signal)) {
+        signals.push(signal);
+      }
+    }
+    return signals;
+  };
+  const readRect = (element) => {
+    const rect = element.getBoundingClientRect();
+    return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+  };
+  const isVisible2 = (element, rect) => {
+    const style = window.getComputedStyle(element);
+    return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0" && rect.width > 0 && rect.height > 0;
+  };
+  const pickSrcsetUrl = (srcset) => {
+    const entries = srcset.split(",").map((entry) => entry.trim()).filter(Boolean);
+    const last2 = entries.at(-1);
+    return last2?.split(/\s+/)[0];
+  };
+  const isFirstPartyPinterestVideoHost = (hostname) => hostname === "v.pinimg.com" || /^v\d+(?:-[a-z]+)?\.pinimg\.com$/i.test(hostname);
+  const isFirstPartyPinterestVideoUrl = (value) => {
+    if (!value) return false;
+    try {
+      const parsed = new URL(value);
+      return parsed.protocol === "https:" && isFirstPartyPinterestVideoHost(parsed.hostname.toLowerCase()) && parsed.pathname.toLowerCase().endsWith(".mp4");
+    } catch {
+      return false;
+    }
+  };
+  const derivePinterestMp4UrlFromHls = (value) => {
+    if (!value) return void 0;
+    try {
+      const parsed = new URL(value);
+      const hostname = parsed.hostname.toLowerCase();
+      if (parsed.protocol !== "https:" || !isFirstPartyPinterestVideoHost(hostname)) {
+        return void 0;
+      }
+      const match = parsed.pathname.match(/^\/videos\/([^/]+)\/hls\/([a-f0-9]{2})\/([a-f0-9]{2})\/([a-f0-9]{2})\/([a-f0-9]+)(?:_\d+w)?\.m3u8$/i);
+      if (!match) return void 0;
+      const [, lane, first, second, third, digest] = match;
+      if (!lane || !first || !second || !third || !digest) return void 0;
+      parsed.pathname = `/videos/${lane}/720p/${first}/${second}/${third}/${digest}.mp4`;
+      parsed.search = "";
+      parsed.hash = "";
+      return parsed.toString();
+    } catch {
+      return void 0;
+    }
+  };
+  const readPinterestVideoUrl = (value) => isFirstPartyPinterestVideoUrl(value) ? value : derivePinterestMp4UrlFromHls(value);
+  const readVideoSourceUrl = (video) => {
+    const candidateUrls = [video.currentSrc, video.src];
+    for (const source of Array.from(video.querySelectorAll("source"))) {
+      const sourceUrl = source.src || source.getAttribute("src");
+      candidateUrls.push(sourceUrl ?? "");
+    }
+    const firstPartyDirectUrl = candidateUrls.map(readPinterestVideoUrl).find(Boolean);
+    if (firstPartyDirectUrl) return firstPartyDirectUrl;
+    return candidateUrls.find(Boolean);
+  };
+  const candidates = elements.flatMap((element) => {
+    const tag = element.tagName.toLowerCase();
+    const rect = readRect(element);
+    const { ancestry, combined } = ancestryFor(element);
+    const classText = (element.getAttribute("class") ?? "").toLowerCase();
+    const positiveSignals = [
+      classText.includes("closeup-image-main-mainpinimage") ? "closeup-image-main-MainPinImage" : "",
+      element.getAttribute("elementtiming") === "closeup-image-main-MainPinImage" ? "closeup-image-main-MainPinImage" : "",
+      classText.includes("storypinimageblock-mainpinimage") ? "StoryPinImageBlock-MainPinImage" : "",
+      tag === "video" ? "video" : "",
+      tag === "video" && element.hasAttribute("poster") ? "video[poster]" : ""
+    ].filter(Boolean);
+    if (tag === "video") {
+      const video = element;
+      const sharedVideoCandidate = {
+        poster: video.poster || void 0,
+        candidateRole: element.getAttribute("role") ?? element.closest("[role]")?.getAttribute("role") ?? void 0,
+        width: video.videoWidth || rect.width,
+        height: video.videoHeight || rect.height,
+        rect,
+        visible: isVisible2(element, rect),
+        ancestry,
+        linkedPinId: readPinId(element),
+        noiseSignals: readNoiseSignals(combined),
+        insideCanonicalMainPinMediaContainer: isInsideCanonicalMainPinMediaContainer(element)
+      };
+      const videoCandidates = [];
+      const videoSourceUrl = readVideoSourceUrl(video);
+      if (videoSourceUrl) {
+        videoCandidates.push({
+          ...sharedVideoCandidate,
+          kind: "video",
+          mediaUrl: videoSourceUrl,
+          candidateSelector: "video",
+          positiveSignals: [...positiveSignals, "video[source]"],
+          score: positiveSignals.length * 100 + 250 + rect.width * rect.height / 1e4
+        });
+      }
+      if (video.poster) {
+        videoCandidates.push({
+          ...sharedVideoCandidate,
+          kind: "video_poster",
+          mediaUrl: video.poster,
+          candidateSelector: "video[poster]",
+          positiveSignals,
+          score: positiveSignals.length * 100 + rect.width * rect.height / 1e4
+        });
+      }
+      return videoCandidates;
+    }
+    const image = tag === "img" ? element : element.querySelector("img");
+    if (!image) {
+      return [];
+    }
+    const imageRect = tag === "img" ? rect : readRect(image);
+    const srcset = image.getAttribute("srcset") ?? void 0;
+    const mediaUrl = image.currentSrc || image.src || pickSrcsetUrl(srcset ?? "");
+    return [{
+      kind: "image",
+      mediaUrl,
+      srcset,
+      candidateSelector: positiveSignals[0] ?? describeElement(image),
+      candidateRole: image.getAttribute("role") ?? image.closest("[role]")?.getAttribute("role") ?? void 0,
+      alt: image.getAttribute("alt") ?? void 0,
+      width: image.naturalWidth || imageRect.width,
+      height: image.naturalHeight || imageRect.height,
+      naturalWidth: image.naturalWidth || void 0,
+      naturalHeight: image.naturalHeight || void 0,
+      rect: imageRect,
+      visible: isVisible2(image, imageRect),
+      ancestry,
+      linkedPinId: readPinId(image),
+      positiveSignals,
+      noiseSignals: readNoiseSignals(combined),
+      insideCanonicalMainPinMediaContainer: isInsideCanonicalMainPinMediaContainer(image),
+      score: positiveSignals.length * 100 + imageRect.width * imageRect.height / 1e4
+    }];
+  });
+  return { sourceUrl: document.URL, candidates };
+}
 var DOM_GET_ATTR_DECLARATION = `
   function(name) {
     /* odb-dom-get-attr */
@@ -6916,6 +7382,104 @@ var DOM_FILE_INPUT_INFO_DECLARATION = `
     };
   }
 `;
+var assertPinterestPinMediaByteLimit = (byteLength) => {
+  if (byteLength > PINTEREST_PIN_MEDIA_MAX_BYTES) {
+    throw new Error(`Pinterest pin media fetch exceeded ${PINTEREST_PIN_MEDIA_MAX_BYTES} bytes.`);
+  }
+};
+var readPinterestPinMediaContentLength = (headers) => {
+  const value = headers.get("content-length");
+  if (!value) return void 0;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+};
+var isPinterestPinMediaRedirectStatus = (status) => status >= HTTP_REDIRECT_STATUS_MIN && status < HTTP_REDIRECT_STATUS_MAX_EXCLUSIVE;
+var readFirstPartyPinterestPinMediaRedirect = (baseUrl, location2) => {
+  if (!location2) {
+    throw new Error("Pinterest pin media fetch redirected without a location header.");
+  }
+  let redirectedUrl;
+  try {
+    redirectedUrl = new URL(location2, baseUrl).href;
+  } catch {
+    throw new Error("Pinterest pin media fetch redirected to an invalid media URL.");
+  }
+  if (!isFirstPartyPinterestMediaUrl(redirectedUrl)) {
+    throw new Error("Pinterest pin media fetch redirected outside first-party media.");
+  }
+  return redirectedUrl;
+};
+var discardPinterestPinMediaResponseBody = async (response) => {
+  await response.body?.cancel().catch(() => void 0);
+};
+var fetchPinterestPinMediaResponse = async (mediaUrl, signal) => {
+  let nextUrl = mediaUrl;
+  for (let redirectCount = 0; redirectCount <= PINTEREST_PIN_MEDIA_MAX_REDIRECTS; redirectCount += 1) {
+    const response = await fetch(nextUrl, { signal, redirect: "manual" });
+    if (!isPinterestPinMediaRedirectStatus(response.status)) {
+      const finalUrl = response.url || nextUrl;
+      if (!isFirstPartyPinterestMediaUrl(finalUrl)) {
+        await discardPinterestPinMediaResponseBody(response);
+        throw new Error("Pinterest pin media fetch redirected outside first-party media.");
+      }
+      return { response, finalUrl };
+    }
+    let redirectedUrl;
+    try {
+      redirectedUrl = readFirstPartyPinterestPinMediaRedirect(nextUrl, response.headers.get("location"));
+    } catch (error) {
+      await discardPinterestPinMediaResponseBody(response);
+      throw error;
+    }
+    nextUrl = redirectedUrl;
+    await discardPinterestPinMediaResponseBody(response);
+  }
+  throw new Error("Pinterest pin media fetch exceeded the first-party redirect limit.");
+};
+var readBoundedPinterestPinMediaBytes = async (response) => {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("Pinterest pin media fetch returned an empty media body.");
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      totalBytes += value.byteLength;
+      assertPinterestPinMediaByteLimit(totalBytes);
+      chunks.push(Buffer.from(value));
+    }
+    if (totalBytes === 0) {
+      throw new Error("Pinterest pin media fetch returned an empty media body.");
+    }
+    return Buffer.concat(chunks, totalBytes);
+  } catch (error) {
+    await reader.cancel().catch(() => void 0);
+    throw error;
+  }
+};
+var writePinterestPinMediaOutput = async (path4, bytes) => {
+  await mkdir5(dirname2(path4), { recursive: true });
+  let handle;
+  let createdOutput = false;
+  let writeFailed = false;
+  try {
+    handle = await open(path4, PINTEREST_PIN_MEDIA_OUTPUT_OPEN_FLAGS, 384);
+    createdOutput = true;
+    await handle.writeFile(bytes);
+  } catch {
+    writeFailed = createdOutput;
+    throw new Error("Pinterest pin media output path could not be opened as a new non-symlink file.");
+  } finally {
+    await handle?.close().catch(() => void 0);
+    if (writeFailed) {
+      await unlink(path4).catch(() => void 0);
+    }
+  }
+};
 var BrowserManager = class {
   store = new SessionStore();
   sessions = /* @__PURE__ */ new Map();
@@ -8258,6 +8822,166 @@ var BrowserManager = class {
       }
     });
   }
+  async capturePinterestPinMedia(sessionId, options) {
+    if (!options.path) {
+      throw new Error("Pinterest pin media capture requires an output path.");
+    }
+    return this.runTargetScoped(sessionId, options.targetId, async ({ managed, page, targetId }) => {
+      const pageSourceUrl = this.safePageUrl(page, "BrowserManager.capturePinterestPinMedia") ?? "";
+      const extraction = await this.evaluatePinterestPinMediaCandidates(managed, page, options.timeoutMs);
+      const sourceUrl = readAuthoritativePinterestSourceUrl(pageSourceUrl, extraction.sourceUrl);
+      if (pinterestPinSourceChanged(pageSourceUrl, extraction.sourceUrl)) {
+        return {
+          status: "not_found",
+          sourceUrl,
+          targetId,
+          rejectedCandidates: extraction.candidates.slice(0, PINTEREST_PIN_MEDIA_REJECTION_LIMIT).map((candidate) => summarizeRejectedPinterestCandidate(candidate, ["source_url_changed"]))
+        };
+      }
+      const selection = selectPinterestPinMediaCandidate(extraction, sourceUrl);
+      if (!selection.selected) {
+        return {
+          status: "not_found",
+          sourceUrl,
+          targetId,
+          rejectedCandidates: selection.rejectedCandidates
+        };
+      }
+      const rejectedCandidates = [...selection.rejectedCandidates];
+      let lastFailure;
+      const fetchTimeoutMs = clampPinterestPinMediaOperationTimeout(
+        options.timeoutMs ?? PINTEREST_PIN_MEDIA_DEFAULT_TIMEOUT_MS,
+        PINTEREST_PIN_MEDIA_FETCH_MAX_TIMEOUT_MS
+      );
+      for (const candidate of selection.acceptedCandidates) {
+        try {
+          const fetched = await this.fetchPinterestPinMediaBytes(candidate.mediaUrl ?? "", fetchTimeoutMs);
+          assertFetchedPinterestCandidateMatchesKind(candidate, fetched);
+          await writePinterestPinMediaOutput(options.path, fetched.bytes);
+          return this.buildPinterestPinMediaResult(
+            candidate,
+            rejectedCandidates,
+            {
+              contentType: fetched.contentType,
+              byteLength: fetched.bytes.byteLength,
+              path: options.path,
+              sourceUrl,
+              targetId,
+              mediaUrl: fetched.finalUrl
+            }
+          );
+        } catch (error) {
+          lastFailure = error;
+          if (rejectedCandidates.length < PINTEREST_PIN_MEDIA_REJECTION_LIMIT) {
+            rejectedCandidates.push(summarizeRejectedPinterestCandidate(
+              candidate,
+              [pinterestCandidateCaptureFailureReason(error)]
+            ));
+          }
+        }
+      }
+      throw lastFailure instanceof Error ? lastFailure : new Error("Pinterest pin media capture failed.");
+    });
+  }
+  async evaluatePinterestPinMediaCandidates(managed, page, timeoutMs = PINTEREST_PIN_MEDIA_DEFAULT_TIMEOUT_MS) {
+    const inspectionTimeoutMs = clampPinterestPinMediaOperationTimeout(
+      timeoutMs,
+      PINTEREST_PIN_MEDIA_DOM_INSPECTION_MAX_TIMEOUT_MS
+    );
+    try {
+      return await withPinterestPinMediaOperationTimeout(
+        page.evaluate(readPinterestPinMediaCandidatesInPage),
+        inspectionTimeoutMs,
+        `Pinterest pin media DOM inspection timed out after ${inspectionTimeoutMs}ms.`
+      );
+    } catch (error) {
+      if (!isPinterestPinMediaDomInspectionTimeout(error)) {
+        throw error;
+      }
+      return await this.evaluatePinterestPinMediaCandidatesViaCdp(managed, page, inspectionTimeoutMs, error);
+    }
+  }
+  async evaluatePinterestPinMediaCandidatesViaCdp(managed, page, timeoutMs, originalError) {
+    const sessionTimeoutMs = clampPinterestPinMediaOperationTimeout(
+      timeoutMs,
+      PINTEREST_PIN_MEDIA_CDP_SESSION_MAX_TIMEOUT_MS
+    );
+    const session = await withPinterestPinMediaOperationTimeout(
+      managed.context.newCDPSession(page),
+      sessionTimeoutMs,
+      `Pinterest pin media CDP session attach timed out after ${sessionTimeoutMs}ms.`
+    );
+    try {
+      const result = await withPinterestPinMediaOperationTimeout(
+        session.send("Runtime.evaluate", {
+          expression: `(${readPinterestPinMediaCandidatesInPage.toString()})()`,
+          awaitPromise: true,
+          returnByValue: true
+        }),
+        timeoutMs,
+        `Pinterest pin media CDP inspection timed out after ${timeoutMs}ms.`
+      );
+      return parsePinterestPinMediaCdpExtraction(result);
+    } catch {
+      throw originalError;
+    } finally {
+      detachPinterestPinMediaCdpSession(session);
+    }
+  }
+  async fetchPinterestPinMediaBytes(mediaUrl, timeoutMs = PINTEREST_PIN_MEDIA_DEFAULT_TIMEOUT_MS) {
+    if (!isFirstPartyPinterestMediaUrl(mediaUrl)) {
+      throw new Error("Pinterest pin media fetch rejected a non-first-party media URL.");
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const { response, finalUrl } = await fetchPinterestPinMediaResponse(mediaUrl, controller.signal);
+      if (!response.ok) {
+        await discardPinterestPinMediaResponseBody(response);
+        throw new Error(`Pinterest pin media fetch failed with status ${response.status}.`);
+      }
+      const contentLength = readPinterestPinMediaContentLength(response.headers);
+      if (contentLength !== void 0) {
+        try {
+          assertPinterestPinMediaByteLimit(contentLength);
+        } catch (error) {
+          await discardPinterestPinMediaResponseBody(response);
+          throw error;
+        }
+      }
+      const bytes = await readBoundedPinterestPinMediaBytes(response);
+      const contentType = response.headers.get("content-type") ?? void 0;
+      return { bytes, finalUrl, ...contentType ? { contentType } : {} };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  buildPinterestPinMediaResult(candidate, rejectedCandidates, metadata) {
+    const contentType = candidate.kind === "video" ? PINTEREST_PIN_MEDIA_VIDEO_CONTENT_TYPE : normalizePinterestResponseContentType(metadata.contentType);
+    return {
+      status: "captured",
+      sourceUrl: metadata.sourceUrl,
+      targetId: metadata.targetId,
+      kind: candidate.kind,
+      path: metadata.path,
+      mediaUrl: metadata.mediaUrl,
+      bytes: metadata.byteLength,
+      ...contentType ? { contentType } : {},
+      ...candidate.candidateSelector ? { candidateSelector: candidate.candidateSelector } : {},
+      ...candidate.candidateRole ? { candidateRole: candidate.candidateRole } : {},
+      ...candidate.alt ? { alt: candidate.alt } : {},
+      ...candidate.srcset ? { srcset: candidate.srcset } : {},
+      ...candidate.width ? { width: candidate.width } : {},
+      ...candidate.height ? { height: candidate.height } : {},
+      ...candidate.naturalWidth ? { naturalWidth: candidate.naturalWidth } : {},
+      ...candidate.naturalHeight ? { naturalHeight: candidate.naturalHeight } : {},
+      ...candidate.poster ? { poster: candidate.poster } : {},
+      ...candidate.rect ? { rect: candidate.rect } : {},
+      ancestry: candidate.ancestry.slice(0, 6),
+      rejectedCandidates,
+      ...warningsForSelectedPinterestCandidate(candidate).length > 0 ? { warnings: warningsForSelectedPinterestCandidate(candidate) } : {}
+    };
+  }
   async startScreencast(sessionId, options = {}) {
     return await this.runStructural(sessionId, async () => {
       const managed = this.getManaged(sessionId);
@@ -11365,6 +12089,12 @@ var OpsBrowserManager = class {
       ...warnings ? { warnings } : {}
     };
   }
+  async capturePinterestPinMedia(sessionId, options) {
+    if (!this.opsSessions.has(sessionId)) {
+      return await this.base.capturePinterestPinMedia(sessionId, options);
+    }
+    throw new Error("Pinterest pin media capture is not supported through extension ops sessions.");
+  }
   async startScreencast(sessionId, options = {}) {
     if (!this.opsSessions.has(sessionId)) {
       return await this.base.startScreencast(sessionId, options);
@@ -12916,7 +13646,7 @@ var parseJson2 = (data) => {
 // src/browser/canvas-manager.ts
 import { randomUUID as randomUUID19 } from "crypto";
 import { mkdir as mkdir9 } from "fs/promises";
-import { dirname as dirname5 } from "path";
+import { dirname as dirname6 } from "path";
 
 // src/browser/canvas-client.ts
 import { randomUUID as randomUUID15 } from "crypto";
@@ -24983,7 +25713,7 @@ function listBuiltInCanvasKitIds() {
 
 // src/canvas/repo-store.ts
 import { access as access3, mkdir as mkdir6, readFile as readFile2 } from "fs/promises";
-import { join as join13, dirname as dirname2, isAbsolute as isAbsolute3, resolve as resolve2 } from "path";
+import { join as join13, dirname as dirname3, isAbsolute as isAbsolute3, resolve as resolve2 } from "path";
 
 // src/canvas/code-sync/manifest.ts
 var isRecord6 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -25184,7 +25914,7 @@ function resolveCanvasFigmaAssetPath(worktree, fileKey, assetId, extension) {
 }
 async function saveCanvasDocument(worktree, document2, repoPath) {
   const resolvedPath = resolveCanvasRepoPath(worktree, document2.documentId, repoPath);
-  await mkdir6(dirname2(resolvedPath), { recursive: true });
+  await mkdir6(dirname3(resolvedPath), { recursive: true });
   writeFileAtomic(resolvedPath, `${JSON.stringify(stableValue(document2), null, 2)}
 `, { encoding: "utf-8" });
   return resolvedPath;
@@ -25206,7 +25936,7 @@ async function loadCanvasDocumentById(worktree, documentId) {
 }
 async function saveCanvasCodeSyncManifest(worktree, manifest, repoPath) {
   const resolvedPath = resolveCanvasCodeSyncManifestPath(worktree, manifest.documentId, manifest.bindingId, repoPath);
-  await mkdir6(dirname2(resolvedPath), { recursive: true });
+  await mkdir6(dirname3(resolvedPath), { recursive: true });
   writeFileAtomic(resolvedPath, `${JSON.stringify(stableValue(manifest), null, 2)}
 `, { encoding: "utf-8" });
   return resolvedPath;
@@ -25588,7 +26318,7 @@ import { resolve as resolve5, isAbsolute as isAbsolute5 } from "path";
 // src/canvas/adapter-plugins/loader.ts
 import { createHash as createHash4 } from "crypto";
 import { access as access4, readFile as readFile3 } from "fs/promises";
-import { dirname as dirname3, isAbsolute as isAbsolute4, join as join14, resolve as resolve4 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join14, resolve as resolve4 } from "path";
 import { pathToFileURL } from "url";
 
 // src/canvas/adapter-plugins/manifest.ts
@@ -25734,7 +26464,7 @@ async function resolveDeclarationRef(worktree, ref) {
   if (await exists(direct)) {
     const manifestPath2 = direct.endsWith(".json") ? direct : join14(direct, "canvas-adapter.plugin.json");
     return {
-      packageRoot: direct.endsWith(".json") ? dirname3(direct) : direct,
+      packageRoot: direct.endsWith(".json") ? dirname4(direct) : direct,
       manifestPath: manifestPath2
     };
   }
@@ -27384,9 +28114,9 @@ function importCodeSyncGraph(options) {
 
 // src/canvas/code-sync/write.ts
 import { mkdir as mkdir7 } from "fs/promises";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname5 } from "path";
 async function writeCodeSyncSource(repoPath, sourceText) {
-  await mkdir7(dirname4(repoPath), { recursive: true });
+  await mkdir7(dirname5(repoPath), { recursive: true });
   writeFileAtomic(repoPath, sourceText, { encoding: "utf-8" });
 }
 function finalizeCodeSyncManifest(manifest, updates) {
@@ -30458,7 +31188,7 @@ var CanvasManager = class {
     const repoRoot = this.resolveSessionRepoRoot(session, params2);
     const warnings = evaluateCanvasWarnings(document2, { forSave: exportTarget === "design_document" });
     const exportBase = resolveCanvasRepoPath(repoRoot, document2.documentId, ".opendevbrowser/canvas/exports");
-    await mkdir9(dirname5(exportBase), { recursive: true });
+    await mkdir9(dirname6(exportBase), { recursive: true });
     if (exportTarget === "design_document") {
       const validation = validateCanvasSave(document2);
       if (validation.missingBlocks.length > 0) {
@@ -33055,7 +33785,7 @@ function toAbsoluteUrl(value) {
   }
 }
 async function saveText(path4, content) {
-  await mkdir9(dirname5(path4), { recursive: true });
+  await mkdir9(dirname6(path4), { recursive: true });
   const { writeFileAtomic: writeFileAtomic2 } = await import("./fs-UMRKOBNN.js");
   writeFileAtomic2(path4, `${content}
 `, { encoding: "utf-8" });
@@ -35483,4 +36213,4 @@ export {
   createOpenDevBrowserCore
 };
 /* v8 ignore next -- @preserve */
-//# sourceMappingURL=chunk-XRDCSHKZ.js.map
+//# sourceMappingURL=chunk-AHQC4A6P.js.map