opendevbrowser 0.0.34 → 0.0.35

package/dist/{chunk-QXJDJDSZ.js → chunk-Z3ADLR7I.js}

@@ -7,7 +7,7 @@ import {
   readCookiesFromSource,
   resolveBundledProviderRuntime,
   resolveSessionRelayRoute
-} from "./chunk-XRDCSHKZ.js";
+} from "./chunk-AHQC4A6P.js";
 import {
   loadGlobalConfig,
   resolveConfig
@@ -17,14 +17,16 @@ import {
 } from "./chunk-ASMHEEKY.js";
 import {
   buildMacroResolveSuccessHandoff,
+  classifyPinterestCandidate,
   detectSocialSearchShell,
+  isCanonicalPinterestPinUrl,
   isChallengeAutomationMode,
   resolveWorkflowArtifactRoot,
   runInspiredesignWorkflow,
   runProductVideoWorkflow,
   runResearchWorkflow,
   runShoppingWorkflow
-} from "./chunk-5FDXH4CS.js";
+} from "./chunk-WTWSBEBW.js";
 import {
   buildBlockerArtifacts,
   classifyBlockerSignal,
@@ -419,15 +421,31 @@ import { mkdir } from "fs/promises";
 import { dirname, resolve } from "path";
 var INSPIREDESIGN_CAPTURE_TIMEOUT_MS = 3e4;
 var INSPIREDESIGN_CAPTURE_MAX_CHARS = 12e3;
+var INSPIREDESIGN_MOTION_INTERVAL_MS = 500;
+var INSPIREDESIGN_MOTION_MAX_FRAMES = 3;
+var INSPIREDESIGN_LATE_SCREENCAST_STOP_TIMEOUT_MS = 1e3;
+var INSPIREDESIGN_PIN_MEDIA_CAPTURE_TIMEOUT_MS = 9e4;
+var PINTEREST_PIN_MEDIA_EXTENSION_WARMUP_TIMEOUT_MS = 3e4;
+var PINTEREST_PIN_MEDIA_NETWORK_IDLE_TIMEOUT_MS = 5e3;
+var EXACT_CANONICAL_PINTEREST_PIN_HOST = "www.pinterest.com";
 var ACTIVE_SESSION_COOKIE_REUSE_UNAVAILABLE_MESSAGE = "Deep capture only honors configured provider cookie sources; active session cookies are not reused.";
 var DOM_CAPTURE_HELPER_UNAVAILABLE_MESSAGE = "DOM capture helper unavailable in this execution lane.";
 var VISUAL_CAPTURE_HELPER_UNAVAILABLE_MESSAGE = "Visual evidence screenshot helper unavailable in this execution lane.";
 var VISUAL_CAPTURE_PATH_UNAVAILABLE_MESSAGE = "Visual evidence path was not configured for screenshot capture.";
 var VISUAL_CAPTURE_EMPTY_MESSAGE = "Visual evidence screenshot did not return a file path.";
+var PIN_MEDIA_CAPTURE_HELPER_UNAVAILABLE_MESSAGE = "Pinterest pin media capture helper unavailable in this execution lane.";
+var PIN_MEDIA_CAPTURE_PATH_UNAVAILABLE_MESSAGE = "Pinterest pin media evidence path was not configured.";
+var PIN_MEDIA_CAPTURE_NOT_FOUND_MESSAGE = "Pinterest pin media capture did not find a primary media candidate.";
+var PIN_MEDIA_CAPTURE_PATH_MISMATCH_MESSAGE = "Pinterest pin media evidence temp path did not match the requested artifact path.";
+var PRIMARY_CAPTURE_SESSION_UNAVAILABLE_MESSAGE = "Primary media capture session helper unavailable in this execution lane.";
+var VISUAL_VIEWPORT_PROBE_FAILED_WARNING = "viewport_url_unverified";
+var PINTEREST_VIEWPORT_LOGIN_WARNING = "login_or_challenge_state";
+var PINTEREST_VIEWPORT_CHROME_WARNING = "interface_chrome_shell";
 var SNAPSHOT_CAPTURE_EMPTY_MESSAGE = "Snapshot capture returned empty content.";
 var CLONE_CAPTURE_EMPTY_MESSAGE = "Clone capture returned empty component and CSS previews.";
 var DOM_CAPTURE_EMPTY_MESSAGE = "DOM capture returned empty HTML.";
 var SKIPPED_AFTER_TRANSPORT_TIMEOUT_SUFFIX = "transport timeout.";
+var PINTEREST_VIEWPORT_MEDIA_PROBE_MAX_NODES = 400;
 var createRemainingCaptureTimeout = (timeoutMs) => {
   const startedAtMs = Date.now();
   let firstRead = true;
@@ -439,10 +457,18 @@ var createRemainingCaptureTimeout = (timeoutMs) => {
     return Math.max(1, timeoutMs - Math.max(0, Date.now() - startedAtMs));
   };
 };
+var createCappedRemainingCaptureTimeout = (remainingTimeoutMs, capMs) => {
+  const cappedRemainingTimeoutMs = createRemainingCaptureTimeout(capMs);
+  return () => Math.min(remainingTimeoutMs(), cappedRemainingTimeoutMs());
+};
 var clampInspiredesignCaptureTimeout = (timeoutMs) => {
   if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) return INSPIREDESIGN_CAPTURE_TIMEOUT_MS;
   return Math.max(1, Math.min(timeoutMs, INSPIREDESIGN_CAPTURE_TIMEOUT_MS));
 };
+var clampInspiredesignPinMediaCaptureTimeout = (timeoutMs) => {
+  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) return INSPIREDESIGN_PIN_MEDIA_CAPTURE_TIMEOUT_MS;
+  return Math.max(1, Math.min(timeoutMs, INSPIREDESIGN_PIN_MEDIA_CAPTURE_TIMEOUT_MS));
+};
 function sanitizeInspiredesignCaptureText(value) {
   if (value === void 0) return void 0;
   const redacted = redactSensitive(value);
@@ -476,6 +502,61 @@ var buildSkippedAfterTransportTimeoutAttempt = (label) => {
 var hasUsableCaptureText = (value) => {
   return typeof value === "string" && value.trim().length > 0;
 };
+var isPinterestUrl = (value) => {
+  if (!value) return false;
+  try {
+    const hostname = new URL(value).hostname.toLowerCase();
+    return hostname === "pinterest.com" || hostname.endsWith(".pinterest.com");
+  } catch {
+    return false;
+  }
+};
+var pinterestViewportClassification = (args) => {
+  if (!isPinterestUrl(args.url)) return void 0;
+  return classifyPinterestCandidate({
+    url: args.url,
+    title: args.title,
+    content: [
+      args.content,
+      ...args.warnings ?? []
+    ].filter((value) => typeof value === "string" && value.trim().length > 0).join(" "),
+    html: args.html
+  });
+};
+var pinterestViewportWarnings = (args) => {
+  const quality = pinterestViewportClassification(args)?.sourcePageQuality;
+  if (quality === "login_challenge") return [PINTEREST_VIEWPORT_LOGIN_WARNING];
+  if (quality === "search_shell" || quality === "chrome_only") return [PINTEREST_VIEWPORT_CHROME_WARNING];
+  return [];
+};
+var pinterestViewportPageQuality = (args) => {
+  return pinterestViewportClassification(args)?.sourcePageQuality;
+};
+var normalizeMotionSourceUrlForComparison = (value) => {
+  if (!value) return void 0;
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+    url.hash = "";
+    url.search = "";
+    return url.toString();
+  } catch {
+    return void 0;
+  }
+};
+var motionSourceDiagnosticReasons = (startedProbe, endedProbe) => {
+  const startedUrl = normalizeMotionSourceUrlForComparison(startedProbe.sourceUrl);
+  const endedUrl = normalizeMotionSourceUrlForComparison(endedProbe.sourceUrl);
+  if (!startedUrl || !endedUrl) return ["motion_source_unverified"];
+  return startedUrl === endedUrl ? [] : ["motion_source_changed"];
+};
+var motionPageQualityDiagnosticReasons = (startedProbe, endedProbe) => {
+  const qualities = [
+    { sourceUrl: startedProbe.sourceUrl, quality: startedProbe.pinterestPageQuality },
+    { sourceUrl: endedProbe.sourceUrl, quality: endedProbe.pinterestPageQuality }
+  ];
+  return qualities.some((entry) => isPinterestUrl(entry.sourceUrl) && entry.quality !== "pin_media") ? ["motion_source_page_quality_not_pin_media"] : [];
+};
 var resolveInspiredesignCaptureCookiePolicy = (options) => {
   if (options.cookiePolicyOverride) return options.cookiePolicyOverride;
   return options.useCookies === false ? "off" : "auto";
@@ -532,6 +613,25 @@ var importConfiguredCaptureCookies = async (manager, sessionId, source, timeoutM
     sourceMessage: loaded.message
   };
 };
+var prepareCaptureSessionState = async ({
+  manager,
+  sessionId,
+  url,
+  remainingTimeoutMs,
+  options
+}) => {
+  const cookiePolicy = resolveInspiredesignCaptureCookiePolicy(options);
+  const importState = cookiePolicy === "off" ? { sourceConfigured: false, sourceAvailable: false } : await importConfiguredCaptureCookies(
+    manager,
+    sessionId,
+    options.cookieSource,
+    remainingTimeoutMs()
+  );
+  if (cookiePolicy === "required") {
+    await verifyRequiredCaptureCookies(manager, sessionId, url, importState, remainingTimeoutMs());
+  }
+  manager.setSessionChallengeAutomationMode?.(sessionId, options.challengeAutomationMode);
+};
 var captureSnapshotArtifact = async (manager, sessionId, remainingTimeoutMs) => {
   try {
     const snapshot = await withCaptureDeadline(
@@ -631,15 +731,145 @@ var captureDomArtifact = async (manager, sessionId, remainingTimeoutMs) => {
     };
   }
 };
-var buildVisualEvidenceMetadata = (status, detail, warnings = [], tempPath) => ({
+var buildVisualEvidenceMetadata = (status, detail, warnings = [], tempPath, sourceUrl, pinterestPageQuality) => ({
   status,
   kind: "viewport",
   fullPage: false,
   capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+  ...sourceUrl ? { sourceUrl } : {},
+  ...pinterestPageQuality ? { pinterestPageQuality } : {},
   ...tempPath ? { tempPath } : {},
   warnings,
   ...detail ? { failure: sanitizeInspiredesignCaptureText(detail) } : {}
 });
+var collectPinterestPinMediaNotFoundReasons = (result) => {
+  const reasons = result.rejectedCandidates.flatMap((candidate) => candidate.reasons);
+  return [...new Set(reasons.length > 0 ? reasons : ["pin_media_candidate_not_found"])].map((reason) => sanitizeInspiredesignCaptureText(reason)).filter((reason) => Boolean(reason));
+};
+var buildPinMediaEvidenceMetadata = (status, referenceId, url, detail, options = {}) => ({
+  status,
+  kind: options.kind ?? "image",
+  capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+  referenceId,
+  url,
+  ...options.sourceUrl ? { sourceUrl: options.sourceUrl } : {},
+  ...options.startedSourceUrl ? { startedSourceUrl: options.startedSourceUrl } : {},
+  ...options.endedSourceUrl ? { endedSourceUrl: options.endedSourceUrl } : {},
+  ...options.pinterestPageQuality ? { pinterestPageQuality: options.pinterestPageQuality } : {},
+  ...options.mediaUrl ? { mediaUrl: options.mediaUrl } : {},
+  ...options.candidateSelector ? { candidateSelector: options.candidateSelector } : {},
+  ...options.candidateRole ? { candidateRole: options.candidateRole } : {},
+  ...options.candidateAlt ? { candidateAlt: options.candidateAlt } : {},
+  ...options.width ? { width: options.width } : {},
+  ...options.height ? { height: options.height } : {},
+  ...options.contentType ? { contentType: options.contentType } : {},
+  ...options.tempPath ? { tempPath: options.tempPath } : {},
+  warnings: options.warnings ?? [],
+  ...detail ? { failure: sanitizeInspiredesignCaptureText(detail) } : {},
+  rejectionReasons: options.rejectionReasons ?? []
+});
+var mergePinMediaWarnings = (viewportProbe, result) => [...viewportProbe.warnings, ...result.warnings ?? []];
+var viewportProbeFromPinMediaResult = (result) => ({
+  ...result.sourceUrl ? { sourceUrl: result.sourceUrl } : {},
+  warnings: []
+});
+var hasCapturedPinMediaDirectProof = (result, sourceUrl) => Boolean(sourceUrl && result.mediaUrl && result.path);
+var buildCapturedPinMediaMetadata = (result, referenceId, url, requestedPath, viewportProbe, fallbackPageQuality) => {
+  const sourceUrl = result.sourceUrl || viewportProbe.sourceUrl;
+  if (!result.path || resolve(result.path) !== resolve(requestedPath)) {
+    return buildPinMediaEvidenceMetadata(
+      "failed",
+      referenceId,
+      url,
+      PIN_MEDIA_CAPTURE_PATH_MISMATCH_MESSAGE,
+      {
+        kind: result.kind ?? "image",
+        sourceUrl,
+        endedSourceUrl: sourceUrl,
+        pinterestPageQuality: viewportProbe.pinterestPageQuality ?? fallbackPageQuality,
+        warnings: [...mergePinMediaWarnings(viewportProbe, result), "pin_media_temp_path_mismatch"],
+        rejectionReasons: ["pin_media_temp_path_mismatch"]
+      }
+    );
+  }
+  const pinterestPageQuality = hasCapturedPinMediaDirectProof(result, sourceUrl) ? "pin_media" : viewportProbe.pinterestPageQuality ?? fallbackPageQuality ?? "unknown";
+  return buildPinMediaEvidenceMetadata("captured", referenceId, url, void 0, {
+    kind: result.kind ?? "image",
+    tempPath: requestedPath,
+    sourceUrl,
+    endedSourceUrl: sourceUrl,
+    pinterestPageQuality,
+    mediaUrl: result.mediaUrl,
+    candidateSelector: result.candidateSelector,
+    candidateRole: result.candidateRole,
+    candidateAlt: result.alt,
+    width: result.naturalWidth ?? result.width,
+    height: result.naturalHeight ?? result.height,
+    contentType: result.contentType,
+    warnings: mergePinMediaWarnings(viewportProbe, result)
+  });
+};
+var capturePinterestViewportHtml = async (manager, sessionId, sourceUrl, remainingTimeoutMs) => {
+  if (!isPinterestUrl(sourceUrl) || typeof manager.clonePageHtmlWithOptions !== "function") return void 0;
+  const timeoutMs = remainingTimeoutMs();
+  if (timeoutMs <= 1) return void 0;
+  try {
+    const clone = await withCaptureDeadline(
+      manager.clonePageHtmlWithOptions(
+        sessionId,
+        void 0,
+        {
+          maxNodes: PINTEREST_VIEWPORT_MEDIA_PROBE_MAX_NODES,
+          inlineStyles: false
+        },
+        timeoutMs
+      ),
+      timeoutMs,
+      "Pinterest viewport media probe"
+    );
+    return sanitizeInspiredesignCaptureText(clone.html);
+  } catch {
+    return void 0;
+  }
+};
+var captureViewportSourceUrl = async (manager, sessionId, remainingTimeoutMs) => {
+  try {
+    const snapshot = await withCaptureDeadline(
+      manager.snapshot(sessionId, "outline", 1e3, void 0, void 0, remainingTimeoutMs()),
+      remainingTimeoutMs(),
+      "visual evidence viewport probe"
+    );
+    const warnings = [
+      ...snapshot.url ? [] : [VISUAL_VIEWPORT_PROBE_FAILED_WARNING],
+      ...pinterestViewportWarnings({
+        url: snapshot.url,
+        title: snapshot.title,
+        content: snapshot.content,
+        warnings: snapshot.warnings
+      })
+    ];
+    const html = await capturePinterestViewportHtml(
+      manager,
+      sessionId,
+      snapshot.url,
+      remainingTimeoutMs
+    );
+    const pinterestPageQuality = pinterestViewportPageQuality({
+      url: snapshot.url,
+      title: snapshot.title,
+      content: snapshot.content,
+      html,
+      warnings: snapshot.warnings
+    });
+    return {
+      ...snapshot.url ? { sourceUrl: snapshot.url } : {},
+      ...pinterestPageQuality ? { pinterestPageQuality } : {},
+      warnings
+    };
+  } catch {
+    return { warnings: [VISUAL_VIEWPORT_PROBE_FAILED_WARNING] };
+  }
+};
 var captureVisualEvidenceArtifact = async (manager, sessionId, options, remainingTimeoutMs) => {
   const visualEvidence = options.visualEvidence ?? "off";
   if (visualEvidence === "off") return void 0;
@@ -657,6 +887,7 @@ var captureVisualEvidenceArtifact = async (manager, sessionId, options, remainin
   }
   try {
     await mkdir(dirname(options.visualEvidencePath), { recursive: true });
+    const viewportProbe = await captureViewportSourceUrl(manager, sessionId, remainingTimeoutMs);
     const screenshot = await withCaptureDeadline(
       manager.screenshot(sessionId, {
         path: options.visualEvidencePath,
@@ -671,7 +902,14 @@ var captureVisualEvidenceArtifact = async (manager, sessionId, options, remainin
     if (resolve(screenshot.path) !== resolve(options.visualEvidencePath)) {
       return buildVisualEvidenceMetadata("failed", "Visual evidence screenshot path did not match the requested artifact path.");
     }
-    return buildVisualEvidenceMetadata("captured", void 0, screenshot.warnings ?? [], options.visualEvidencePath);
+    return buildVisualEvidenceMetadata(
+      "captured",
+      void 0,
+      [...viewportProbe.warnings, ...screenshot.warnings ?? []],
+      options.visualEvidencePath,
+      viewportProbe.sourceUrl,
+      viewportProbe.pinterestPageQuality
+    );
   } catch (error) {
     return buildVisualEvidenceMetadata(
       "failed",
@@ -718,6 +956,412 @@ var captureInspiredesignArtifacts = async (manager, sessionId, remainingTimeoutM
   const visual = await captureVisualEvidenceArtifact(manager, sessionId, options, remainingTimeoutMs);
   return buildCaptureEvidence(snapshot, clone, dom, visual);
 };
+var delay = (ms) => new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+var shouldForceManagedPrimaryCapture = (browserMode) => browserMode === "managed";
+var exactCanonicalPinterestPinCaptureUrl = (url) => {
+  const trimmed = url.trim();
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return void 0;
+    if (!isCanonicalPinterestPinUrl(trimmed)) return void 0;
+    const pathSegments = parsed.pathname.split("/").filter(Boolean);
+    const pinId = pathSegments[1];
+    if (pathSegments[0] !== "pin" || typeof pinId !== "string") return void 0;
+    return `https://${EXACT_CANONICAL_PINTEREST_PIN_HOST}/pin/${pinId}/`;
+  } catch {
+    return void 0;
+  }
+};
+var shouldWarmCanonicalPinterestPinInExtension = (url, browserMode) => exactCanonicalPinterestPinCaptureUrl(url) !== void 0 && resolveCanonicalPinterestPinCaptureBrowserMode(url, browserMode) === "extension";
+var captureNetworkIdleWaitTimeout = (remainingTimeoutMs, maxNetworkIdleWaitMs) => {
+  const remaining = remainingTimeoutMs();
+  if (maxNetworkIdleWaitMs === void 0) return remaining;
+  return Math.max(1, Math.min(remaining, maxNetworkIdleWaitMs));
+};
+var resolveCanonicalPinterestPinCaptureBrowserMode = (url, browserMode) => {
+  if (exactCanonicalPinterestPinCaptureUrl(url) === void 0) return browserMode;
+  return browserMode === "managed" ? "managed" : "extension";
+};
+var warmCanonicalPinterestPinInExtension = async (manager, url, remainingTimeoutMs, options) => {
+  if (!shouldWarmCanonicalPinterestPinInExtension(url, options.browserMode)) return;
+  const launchTimeoutMs = remainingTimeoutMs();
+  const session = await withCaptureDeadline(
+    manager.launch({
+      headless: false,
+      startUrl: "about:blank",
+      persistProfile: false,
+      noExtension: false
+    }, launchTimeoutMs),
+    launchTimeoutMs,
+    "Pinterest canonical pin extension warmup launch"
+  );
+  try {
+    await prepareCaptureSessionState({
+      manager,
+      sessionId: session.sessionId,
+      url,
+      remainingTimeoutMs,
+      options
+    });
+    const gotoTimeoutMs = remainingTimeoutMs();
+    await withCaptureDeadline(
+      manager.goto(session.sessionId, url, "load", gotoTimeoutMs),
+      gotoTimeoutMs,
+      "Pinterest canonical pin extension warmup navigation"
+    );
+    const waitTimeoutMs = captureNetworkIdleWaitTimeout(remainingTimeoutMs, options.maxNetworkIdleWaitMs);
+    try {
+      await withCaptureDeadline(
+        manager.waitForLoad(session.sessionId, "networkidle", waitTimeoutMs),
+        waitTimeoutMs,
+        "Pinterest canonical pin extension warmup network idle wait"
+      );
+    } catch (error) {
+      if (!isIgnorableNetworkIdleWaitError(error)) throw error;
+    }
+  } finally {
+    await manager.disconnect(session.sessionId, false).catch(() => void 0);
+  }
+};
+var launchPrimaryCaptureSession = async (manager, url, remainingTimeoutMs, options) => {
+  const launchTimeoutMs = remainingTimeoutMs();
+  const session = await withCaptureDeadline(
+    manager.launch({
+      headless: options.browserMode !== "extension",
+      startUrl: "about:blank",
+      persistProfile: false,
+      noExtension: shouldForceManagedPrimaryCapture(options.browserMode)
+    }, launchTimeoutMs),
+    launchTimeoutMs,
+    "primary media capture session launch"
+  );
+  try {
+    await prepareCaptureSessionState({
+      manager,
+      sessionId: session.sessionId,
+      url,
+      remainingTimeoutMs,
+      options
+    });
+    const gotoTimeoutMs = remainingTimeoutMs();
+    await withCaptureDeadline(
+      manager.goto(session.sessionId, url, "load", gotoTimeoutMs),
+      gotoTimeoutMs,
+      "primary media capture navigation"
+    );
+    const waitTimeoutMs = captureNetworkIdleWaitTimeout(remainingTimeoutMs, options.maxNetworkIdleWaitMs);
+    try {
+      await withCaptureDeadline(
+        manager.waitForLoad(session.sessionId, "networkidle", waitTimeoutMs),
+        waitTimeoutMs,
+        "primary media capture network idle wait"
+      );
+    } catch (error) {
+      if (!isIgnorableNetworkIdleWaitError(error)) throw error;
+    }
+  } catch (error) {
+    await manager.disconnect(session.sessionId, true).catch(() => void 0);
+    throw error;
+  }
+  return session;
+};
+async function captureInspiredesignPrimaryVisualEvidenceFromManager(manager, url, options) {
+  if (typeof manager.launch !== "function") {
+    return buildVisualEvidenceMetadata(
+      "failed",
+      PRIMARY_CAPTURE_SESSION_UNAVAILABLE_MESSAGE,
+      ["primary_capture_session_unavailable"]
+    );
+  }
+  const captureTimeoutMs = clampInspiredesignCaptureTimeout(options.timeoutMs);
+  const remainingTimeoutMs = createRemainingCaptureTimeout(captureTimeoutMs);
+  let session;
+  try {
+    session = await launchPrimaryCaptureSession(
+      manager,
+      url,
+      remainingTimeoutMs,
+      options
+    );
+  } catch (error) {
+    return buildVisualEvidenceMetadata(
+      "failed",
+      detailFromCaptureError(error, "Primary visual evidence setup failed."),
+      ["primary_capture_setup_failed"]
+    );
+  }
+  try {
+    return await captureVisualEvidenceArtifact(manager, session.sessionId, {
+      visualEvidence: "required",
+      visualEvidencePath: options.visualEvidencePath
+    }, remainingTimeoutMs);
+  } finally {
+    await manager.disconnect(session.sessionId, true).catch(() => void 0);
+  }
+}
+async function captureInspiredesignPrimaryPinMediaEvidenceFromManager(manager, url, options) {
+  if (!options.pinMediaEvidencePath) {
+    return buildPinMediaEvidenceMetadata(
+      "failed",
+      options.referenceId,
+      url,
+      PIN_MEDIA_CAPTURE_PATH_UNAVAILABLE_MESSAGE,
+      { rejectionReasons: ["pin_media_path_unavailable"] }
+    );
+  }
+  if (typeof manager.launch !== "function") {
+    return buildPinMediaEvidenceMetadata(
+      "failed",
+      options.referenceId,
+      url,
+      PRIMARY_CAPTURE_SESSION_UNAVAILABLE_MESSAGE,
+      {
+        warnings: ["primary_capture_session_unavailable"],
+        rejectionReasons: ["primary_capture_session_unavailable"]
+      }
+    );
+  }
+  if (typeof manager.capturePinterestPinMedia !== "function") {
+    return buildPinMediaEvidenceMetadata(
+      "failed",
+      options.referenceId,
+      url,
+      PIN_MEDIA_CAPTURE_HELPER_UNAVAILABLE_MESSAGE,
+      {
+        warnings: ["pin_media_capture_helper_unavailable"],
+        rejectionReasons: ["pin_media_capture_helper_unavailable"]
+      }
+    );
+  }
+  const captureTimeoutMs = clampInspiredesignPinMediaCaptureTimeout(options.timeoutMs);
+  const captureUrl = exactCanonicalPinterestPinCaptureUrl(url) ?? url;
+  const resolvedBrowserMode = resolveCanonicalPinterestPinCaptureBrowserMode(captureUrl, options.browserMode);
+  const captureOptions = resolvedBrowserMode === options.browserMode ? options : { ...options, browserMode: resolvedBrowserMode };
+  const pinMediaCaptureOptions = {
+    ...captureOptions,
+    maxNetworkIdleWaitMs: PINTEREST_PIN_MEDIA_NETWORK_IDLE_TIMEOUT_MS
+  };
+  let session;
+  const remainingTimeoutMs = createRemainingCaptureTimeout(captureTimeoutMs);
+  try {
+    const warmupTimeoutMs = Math.min(captureTimeoutMs, PINTEREST_PIN_MEDIA_EXTENSION_WARMUP_TIMEOUT_MS);
+    await warmCanonicalPinterestPinInExtension(
+      manager,
+      captureUrl,
+      createCappedRemainingCaptureTimeout(remainingTimeoutMs, warmupTimeoutMs),
+      pinMediaCaptureOptions
+    ).catch(() => void 0);
+    session = await launchPrimaryCaptureSession(
+      manager,
+      captureUrl,
+      remainingTimeoutMs,
+      pinMediaCaptureOptions
+    );
+  } catch (error) {
+    return buildPinMediaEvidenceMetadata(
+      "failed",
+      options.referenceId,
+      url,
+      detailFromCaptureError(error, "Primary Pinterest pin media evidence setup failed."),
+      {
+        warnings: ["primary_capture_setup_failed"],
+        rejectionReasons: ["primary_capture_setup_failed"]
+      }
+    );
+  }
+  try {
+    await mkdir(dirname(options.pinMediaEvidencePath), { recursive: true });
+    const captureTimeout = remainingTimeoutMs();
+    const result = await withCaptureDeadline(
+      manager.capturePinterestPinMedia(session.sessionId, {
+        path: options.pinMediaEvidencePath,
+        timeoutMs: captureTimeout
+      }),
+      captureTimeout,
+      "Pinterest pin media evidence capture"
+    );
+    const viewportProbe = viewportProbeFromPinMediaResult(result);
+    if (result.status === "not_found") {
+      const sourceUrl = result.sourceUrl || viewportProbe.sourceUrl;
+      return buildPinMediaEvidenceMetadata(
+        "skipped",
+        options.referenceId,
+        url,
+        PIN_MEDIA_CAPTURE_NOT_FOUND_MESSAGE,
+        {
+          sourceUrl,
+          endedSourceUrl: sourceUrl,
+          pinterestPageQuality: viewportProbe.pinterestPageQuality ?? options.pinterestPageQuality ?? "unknown",
+          warnings: mergePinMediaWarnings(viewportProbe, result),
+          rejectionReasons: collectPinterestPinMediaNotFoundReasons(result)
+        }
+      );
+    }
+    return buildCapturedPinMediaMetadata(
+      result,
+      options.referenceId,
+      url,
+      options.pinMediaEvidencePath,
+      viewportProbe,
+      options.pinterestPageQuality
+    );
+  } catch (error) {
+    return buildPinMediaEvidenceMetadata(
+      "failed",
+      options.referenceId,
+      url,
+      detailFromCaptureError(error, "Primary Pinterest pin media evidence capture failed."),
+      {
+        warnings: ["primary_pin_media_capture_failed"],
+        rejectionReasons: ["primary_pin_media_capture_failed"]
+      }
+    );
+  } finally {
+    await manager.disconnect(session.sessionId, true).catch(() => void 0);
+  }
+}
+async function captureInspiredesignPrimaryMotionEvidenceFromManager(manager, url, options) {
+  if (!manager.startScreencast || !manager.stopScreencast) {
+    return {
+      status: "failed",
+      kind: "screencast",
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      frameCount: 0,
+      warnings: ["screencast_helper_unavailable"],
+      failure: "Screencast helper unavailable in this execution lane.",
+      diagnostic: true,
+      diagnosticReasons: ["screencast_helper_unavailable"]
+    };
+  }
+  if (typeof manager.launch !== "function") {
+    return {
+      status: "failed",
+      kind: "screencast",
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      frameCount: 0,
+      warnings: ["primary_capture_session_unavailable"],
+      failure: PRIMARY_CAPTURE_SESSION_UNAVAILABLE_MESSAGE,
+      diagnostic: true,
+      diagnosticReasons: ["primary_capture_session_unavailable"]
+    };
+  }
+  const captureTimeoutMs = clampInspiredesignCaptureTimeout(options.timeoutMs);
+  const remainingTimeoutMs = createRemainingCaptureTimeout(captureTimeoutMs);
+  let session;
+  try {
+    session = await launchPrimaryCaptureSession(
+      manager,
+      url,
+      remainingTimeoutMs,
+      options
+    );
+  } catch (error) {
+    return {
+      status: "failed",
+      kind: "screencast",
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      frameCount: 0,
+      warnings: ["primary_capture_setup_failed"],
+      failure: detailFromCaptureError(error, "Primary motion evidence setup failed."),
+      diagnostic: true,
+      diagnosticReasons: ["primary_capture_setup_failed"]
+    };
+  }
+  try {
+    const startedViewportProbe = await captureViewportSourceUrl(manager, session.sessionId, remainingTimeoutMs);
+    const startTimeoutMs = remainingTimeoutMs();
+    let stopLateStart = false;
+    const startScreencast = manager.startScreencast(session.sessionId, {
+      outputDir: options.outputDir,
+      intervalMs: INSPIREDESIGN_MOTION_INTERVAL_MS,
+      maxFrames: INSPIREDESIGN_MOTION_MAX_FRAMES
+    });
+    startScreencast.then(async (screencast2) => {
+      if (stopLateStart) {
+        const lateStop = manager.stopScreencast?.(session.sessionId, screencast2.screencastId);
+        if (lateStop) {
+          await withCaptureDeadline(
+            lateStop,
+            INSPIREDESIGN_LATE_SCREENCAST_STOP_TIMEOUT_MS,
+            "late primary motion capture stop"
+          ).catch(() => void 0);
+        }
+      }
+    }).catch(() => void 0);
+    const screencast = await withCaptureDeadline(
+      startScreencast.catch((error) => {
+        stopLateStart = false;
+        throw error;
+      }),
+      startTimeoutMs,
+      "primary motion capture start"
+    ).catch((error) => {
+      stopLateStart = true;
+      throw error;
+    });
+    let result;
+    try {
+      const sampleTimeoutMs = remainingTimeoutMs();
+      if (sampleTimeoutMs <= 1) {
+        throw new Error("Deep capture primary motion capture sampling exceeded timeout budget.");
+      }
+      await withCaptureDeadline(
+        delay(Math.min(INSPIREDESIGN_MOTION_INTERVAL_MS * INSPIREDESIGN_MOTION_MAX_FRAMES, sampleTimeoutMs)),
+        sampleTimeoutMs,
+        "primary motion capture sampling"
+      );
+    } finally {
+      const stopTimeoutMs = remainingTimeoutMs();
+      result = await withCaptureDeadline(
+        manager.stopScreencast(session.sessionId, screencast.screencastId),
+        stopTimeoutMs,
+        "primary motion capture stop"
+      );
+    }
+    if (!result) {
+      throw new Error("Motion evidence screencast did not return stop metadata.");
+    }
+    const endedViewportProbe = await captureViewportSourceUrl(manager, session.sessionId, remainingTimeoutMs);
+    const diagnosticReasons = [
+      ...result.frameCount === 0 ? ["zero_frame_capture"] : [],
+      ...motionSourceDiagnosticReasons(startedViewportProbe, endedViewportProbe),
+      ...motionPageQualityDiagnosticReasons(startedViewportProbe, endedViewportProbe)
+    ];
+    const pinterestPageQuality = endedViewportProbe.pinterestPageQuality ?? startedViewportProbe.pinterestPageQuality;
+    return {
+      status: "captured",
+      kind: "screencast",
+      capturedAt: result.endedAt,
+      replay: { tempPath: result.manifestPath },
+      replayHtml: { tempPath: result.replayHtmlPath },
+      ...result.previewPath ? { preview: { tempPath: result.previewPath } } : {},
+      outputDir: result.outputDir,
+      frameCount: result.frameCount,
+      warnings: [...startedViewportProbe.warnings, ...endedViewportProbe.warnings, ...result.warnings ?? []],
+      ...endedViewportProbe.sourceUrl ?? startedViewportProbe.sourceUrl ? { sourceUrl: endedViewportProbe.sourceUrl ?? startedViewportProbe.sourceUrl } : {},
+      ...startedViewportProbe.sourceUrl ? { startedSourceUrl: startedViewportProbe.sourceUrl } : {},
+      ...endedViewportProbe.sourceUrl ? { endedSourceUrl: endedViewportProbe.sourceUrl } : {},
+      ...pinterestPageQuality ? { pinterestPageQuality } : {},
+      ...startedViewportProbe.pinterestPageQuality ? { startedPinterestPageQuality: startedViewportProbe.pinterestPageQuality } : {},
+      ...endedViewportProbe.pinterestPageQuality ? { endedPinterestPageQuality: endedViewportProbe.pinterestPageQuality } : {},
+      diagnostic: diagnosticReasons.length > 0,
+      diagnosticReasons
+    };
+  } catch (error) {
+    return {
+      status: "failed",
+      kind: "screencast",
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      frameCount: 0,
+      warnings: ["motion_capture_failed"],
+      failure: detailFromCaptureError(error, "Motion evidence screencast failed."),
+      diagnostic: true,
+      diagnosticReasons: ["motion_capture_failed"]
+    };
+  } finally {
+    await manager.disconnect(session.sessionId, true).catch(() => void 0);
+  }
+}
 async function captureInspiredesignReferenceFromManager(manager, url, options = {}) {
   const cookiePolicy = resolveInspiredesignCaptureCookiePolicy(options);
   const captureTimeoutMs = clampInspiredesignCaptureTimeout(options.timeoutMs);
@@ -2230,6 +2874,18 @@ async function handleDaemonCommand(core, request) {
               captureReference: async (url, options) => captureInspiredesignReferenceFromManager(core.manager, url, {
                 ...options,
                 cookieSource: core.config.providers?.cookieSource
+              }),
+              captureVisualEvidence: async (url, options) => captureInspiredesignPrimaryVisualEvidenceFromManager(core.manager, url, {
+                ...options,
+                cookieSource: core.config.providers?.cookieSource
+              }),
+              captureMotionEvidence: async (url, options) => captureInspiredesignPrimaryMotionEvidenceFromManager(core.manager, url, {
+                ...options,
+                cookieSource: core.config.providers?.cookieSource
+              }),
+              capturePinMediaEvidence: async (url, options) => captureInspiredesignPrimaryPinMediaEvidenceFromManager(core.manager, url, {
+                ...options,
+                cookieSource: core.config.providers?.cookieSource
               })
             }
           );
@@ -3061,7 +3717,7 @@ function clampWaitTimeout(timeoutMs) {
 }
 async function waitForRelayHandshake(relay, observedPort, timeoutMs) {
   const start = Date.now();
-  let delay = WAIT_MIN_DELAY_MS;
+  let delay2 = WAIT_MIN_DELAY_MS;
   while (Date.now() - start < timeoutMs) {
     const relayStatus = relay.status();
     if (relayStatus.extensionHandshakeComplete) {
@@ -3074,8 +3730,8 @@ async function waitForRelayHandshake(relay, observedPort, timeoutMs) {
     if (observedStatus?.extensionHandshakeComplete) {
       return true;
     }
-    await new Promise((resolve3) => setTimeout(resolve3, delay));
-    delay = Math.min(delay * 2, WAIT_MAX_DELAY_MS);
+    await new Promise((resolve3) => setTimeout(resolve3, delay2));
+    delay2 = Math.min(delay2 * 2, WAIT_MAX_DELAY_MS);
   }
   return false;
 }
@@ -3740,6 +4396,9 @@ function persistDaemonStatusMetadata(base, status, config) {
 export {
   inspectSession,
   buildCorrelatedAuditBundle,
+  captureInspiredesignPrimaryVisualEvidenceFromManager,
+  captureInspiredesignPrimaryPinMediaEvidenceFromManager,
+  captureInspiredesignPrimaryMotionEvidenceFromManager,
   captureInspiredesignReferenceFromManager,
   executeMacroWithRuntime,
   fetchWithTimeout,
@@ -3761,4 +4420,4 @@ export {
   fetchDaemonStatusFromMetadata,
   persistDaemonStatusMetadata
 };
-//# sourceMappingURL=chunk-QXJDJDSZ.js.map
+//# sourceMappingURL=chunk-Z3ADLR7I.js.map