opendevbrowser 0.0.33 → 0.0.35

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

@@ -52,10 +52,13 @@ import {
   createDefaultRuntime,
   extractStructuredContent,
   inspectChallengePlanFromRuntime,
+  inspectPinterestPinMediaBuffer,
+  isPinterestPinMediaEvidenceContentType,
   resolveChallengeAutomationPolicy,
   resolveProviderRuntimePolicy,
+  resolveWorkflowArtifactRoot,
   toSnippet
-} from "./chunk-FBKPDILE.js";
+} from "./chunk-WTWSBEBW.js";
 import {
   buildBlockerArtifacts,
   classifyBlockerSignal,
@@ -3662,9 +3665,10 @@ function createCoreRuntimeAssemblies(args2) {
 import { parse, resolve as resolve6 } from "path";
 
 // src/browser/browser-manager.ts
-import { randomUUID as randomUUID10 } from "crypto";
-import { access as access2, mkdir as mkdir5, rm as rm3, writeFile as writeFile3 } from "fs/promises";
-import { join as join9 } from "path";
+import { randomUUID as randomUUID11 } from "crypto";
+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";
 
@@ -4952,6 +4956,28 @@ function sanitizeWsEndpoint(wsEndpoint) {
   }
 }
 
+// src/providers/browser-output-artifacts.ts
+import { randomUUID as randomUUID7 } from "crypto";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join7 } from "path";
+var BROWSER_SCREENSHOT_ARTIFACT_NAMESPACE = "screenshot";
+var BROWSER_SCREENCAST_ARTIFACT_NAMESPACE = "screencast";
+var SAFE_BROWSER_ARTIFACT_NAMESPACE_PATTERN = /^[a-z0-9_-]+$/;
+function createBrowserOutputArtifactDirectory(input) {
+  const namespace = input.namespace.trim();
+  if (namespace.length === 0) {
+    throw new Error("Browser output artifact namespace cannot be empty.");
+  }
+  if (!SAFE_BROWSER_ARTIFACT_NAMESPACE_PATTERN.test(namespace)) {
+    throw new Error("Browser output artifact namespace can only contain lowercase letters, numbers, underscores, and hyphens.");
+  }
+  const root = resolveWorkflowArtifactRoot(void 0, { workspaceRoot: input.workspaceRoot });
+  const runId = randomUUID7();
+  const artifactPath = join7(root, namespace, runId);
+  mkdirSync2(artifactPath, { recursive: true, mode: 448 });
+  return { artifactPath, namespace, runId };
+}
+
 // src/browser/manager-types.ts
 var SCREENCAST_RETENTION_MS = 10 * 6e4;
 
@@ -5575,7 +5601,7 @@ var SessionStore = class {
 };
 
 // src/browser/target-manager.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 var TARGET_INFO_TIMEOUT_MS = 2e3;
 var TargetManager = class {
   targets = /* @__PURE__ */ new Map();
@@ -5583,7 +5609,7 @@ var TargetManager = class {
   nameToTarget = /* @__PURE__ */ new Map();
   targetToName = /* @__PURE__ */ new Map();
   registerPage(page, name) {
-    const targetId = randomUUID7();
+    const targetId = randomUUID8();
     this.targets.set(targetId, page);
     if (!this.activeTargetId) {
       this.activeTargetId = targetId;
@@ -5901,7 +5927,7 @@ import { execFileSync } from "child_process";
 import { createDecipheriv, createHash as createHash3, pbkdf2Sync } from "crypto";
 import { cp, mkdtemp as mkdtemp2, mkdir as mkdir3, rm as rm2, stat as stat3 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname, join as join7 } from "path";
+import { dirname, join as join8 } from "path";
 var ROOT_COPY_ENTRIES = ["Local State"];
 var PROFILE_COPY_ENTRIES = [
   "Preferences",
@@ -5959,7 +5985,7 @@ async function stageSystemChromeProfile(source, stagingRoot) {
   let copiedCookieStore = false;
   for (const entry of ROOT_COPY_ENTRIES) {
     try {
-      await copyEntry(join7(source.userDataDir, entry), join7(stagingRoot, entry));
+      await copyEntry(join8(source.userDataDir, entry), join8(stagingRoot, entry));
     } catch (error) {
       warnings.push(`Chrome bootstrap skipped ${entry}: ${getErrorMessage(error)}`);
     }
@@ -5967,8 +5993,8 @@ async function stageSystemChromeProfile(source, stagingRoot) {
   for (const entry of PROFILE_COPY_ENTRIES) {
     try {
       const copied = await copyEntry(
-        join7(source.profilePath, entry),
-        join7(stagingRoot, source.profileDirectory, entry)
+        join8(source.profilePath, entry),
+        join8(stagingRoot, source.profileDirectory, entry)
       );
       if (copied && COOKIE_STORE_ENTRY_SET.has(entry)) {
         copiedCookieStore = true;
@@ -6074,8 +6100,8 @@ async function loadSystemChromeCookiesFromSqlite(source, platform = process.plat
     return { cookies: [], warnings: [], attempted: false };
   }
   const cookieDbCandidates = [
-    join7(source.profilePath, "Cookies"),
-    join7(source.profilePath, "Network", "Cookies")
+    join8(source.profilePath, "Cookies"),
+    join8(source.profilePath, "Network", "Cookies")
   ];
   const cookieDbPath = await firstExistingPath(cookieDbCandidates);
   if (!cookieDbPath) {
@@ -6145,7 +6171,7 @@ async function loadSystemChromeCookies(executablePath) {
       warnings: direct.warnings
     };
   }
-  const stagingRoot = await mkdtemp2(join7(tmpdir(), "opendevbrowser-chrome-cookie-bootstrap-"));
+  const stagingRoot = await mkdtemp2(join8(tmpdir(), "opendevbrowser-chrome-cookie-bootstrap-"));
   try {
     const staged = await stageSystemChromeProfile(source, stagingRoot);
     if (!staged.copiedCookieStore) {
@@ -6203,7 +6229,7 @@ function getErrorMessage(error) {
 }
 
 // src/browser/global-challenge-coordinator.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 var PRESERVE_WINDOW_MS = 15 * 60 * 1e3;
 var VERIFY_WINDOW_MS = 5 * 60 * 1e3;
 var toIso = (value) => value.toISOString();
@@ -6225,7 +6251,7 @@ var GlobalChallengeCoordinator = class {
   claimOrRefresh(args2) {
     const now = args2.now ?? /* @__PURE__ */ new Date();
     const existing = this.bySessionId.get(args2.sessionId);
-    const challengeId = existing?.summary.challengeId ?? randomUUID8();
+    const challengeId = existing?.summary.challengeId ?? randomUUID9();
     const previousTimeline = existing?.timeline ?? [];
     const nextEntry = {
       at: toIso(now),
@@ -6317,8 +6343,8 @@ var GlobalChallengeCoordinator = class {
 
 // src/browser/screencast-recorder.ts
 import { copyFile, mkdir as mkdir4, readdir, writeFile as writeFile2 } from "fs/promises";
-import { randomUUID as randomUUID9 } from "crypto";
-import { isAbsolute as isAbsolute2, join as join8, resolve } from "path";
+import { randomUUID as randomUUID10 } from "crypto";
+import { isAbsolute as isAbsolute2, join as join9, resolve } from "path";
 var DEFAULT_SCREENCAST_INTERVAL_MS = 1e3;
 var MIN_SCREENCAST_INTERVAL_MS = 250;
 var DEFAULT_SCREENCAST_MAX_FRAMES = 300;
@@ -6365,12 +6391,16 @@ async function ensureEmptyDirectory(path4) {
   }
   await mkdir4(path4, { recursive: true });
 }
-function resolveOutputDir(worktree, sessionId, screencastId, outputDir) {
+function resolveOutputDir(worktree, outputDir) {
   if (typeof outputDir === "string" && outputDir.trim().length > 0) {
     const trimmed = outputDir.trim();
-    return isAbsolute2(trimmed) ? trimmed : resolve(worktree, trimmed);
+    return { outputDir: isAbsolute2(trimmed) ? trimmed : resolve(worktree, trimmed) };
   }
-  return join8(worktree, ".opendevbrowser", "replays", "screencasts", sessionId, screencastId);
+  const artifact = createBrowserOutputArtifactDirectory({
+    workspaceRoot: worktree,
+    namespace: BROWSER_SCREENCAST_ARTIFACT_NAMESPACE
+  });
+  return { outputDir: artifact.artifactPath, artifactPath: artifact.artifactPath };
 }
 function renderReplayHtml(manifest) {
   const encodedManifest = JSON.stringify(manifest).replaceAll("<", "\\u003c");
@@ -6470,6 +6500,7 @@ var BrowserScreencastRecorder = class {
   sessionId;
   targetId;
   outputDir;
+  artifactPath;
   startedAt;
   intervalMs;
   maxFrames;
@@ -6490,18 +6521,20 @@ var BrowserScreencastRecorder = class {
   finalPage;
   frames = [];
   constructor(args2) {
-    this.screencastId = args2.screencastId ?? randomUUID9();
+    this.screencastId = args2.screencastId ?? randomUUID10();
     this.sessionId = args2.sessionId;
     this.targetId = args2.targetId;
-    this.outputDir = resolveOutputDir(args2.worktree, args2.sessionId, this.screencastId, args2.options?.outputDir);
+    const output = resolveOutputDir(args2.worktree, args2.options?.outputDir);
+    this.outputDir = output.outputDir;
+    this.artifactPath = output.artifactPath;
     this.intervalMs = resolveIntervalMs(args2.options?.intervalMs);
     this.maxFrames = resolveMaxFrames(args2.options?.maxFrames);
     this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.startedAtMs = Date.parse(this.startedAt);
-    this.framesDir = join8(this.outputDir, FRAMES_DIRECTORY);
-    this.manifestPath = join8(this.outputDir, MANIFEST_FILENAME);
-    this.replayHtmlPath = join8(this.outputDir, REPLAY_FILENAME);
-    this.previewPath = join8(this.outputDir, PREVIEW_FILENAME);
+    this.framesDir = join9(this.outputDir, FRAMES_DIRECTORY);
+    this.manifestPath = join9(this.outputDir, MANIFEST_FILENAME);
+    this.replayHtmlPath = join9(this.outputDir, REPLAY_FILENAME);
+    this.previewPath = join9(this.outputDir, PREVIEW_FILENAME);
     this.captureFrameImpl = args2.captureFrame;
     this.completionPromise = new Promise((resolvePromise) => {
       this.resolveCompletion = resolvePromise;
@@ -6539,6 +6572,7 @@ var BrowserScreencastRecorder = class {
       sessionId: this.sessionId,
       targetId: this.targetId,
       outputDir: this.outputDir,
+      ...this.artifactPath ? { artifact_path: this.artifactPath } : {},
       startedAt: this.startedAt,
       intervalMs: this.intervalMs,
       maxFrames: this.maxFrames,
@@ -6583,7 +6617,7 @@ var BrowserScreencastRecorder = class {
   async captureFrame() {
     const index = this.frames.length + 1;
     const frameFilename = `${String(index).padStart(6, "0")}.png`;
-    const framePath = join8(this.framesDir, frameFilename);
+    const framePath = join9(this.framesDir, frameFilename);
     const task = Promise.resolve().then(async () => {
       const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
       const result = await this.captureFrameImpl(framePath);
@@ -6599,7 +6633,7 @@ var BrowserScreencastRecorder = class {
         index,
         capturedAt,
         elapsedMs: Math.max(Date.parse(capturedAt) - this.startedAtMs, 0),
-        relativePath: normalizeRelativePath(join8(FRAMES_DIRECTORY, frameFilename))
+        relativePath: normalizeRelativePath(join9(FRAMES_DIRECTORY, frameFilename))
       });
       if (this.frames.length === 1) {
         await copyFile(framePath, this.previewPath);
@@ -6664,6 +6698,7 @@ var BrowserScreencastRecorder = class {
       sessionId: this.sessionId,
       targetId: this.targetId,
       outputDir: this.outputDir,
+      ...this.artifactPath ? { artifact_path: this.artifactPath } : {},
       startedAt: this.startedAt,
       endedAt,
       endedReason: reason,
@@ -6681,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 */
@@ -6884,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();
@@ -7060,7 +7656,7 @@ var BrowserManager = class {
       warnings.push("System Chrome not found. Downloaded Chrome for Testing.");
       executablePath = download.executablePath;
     }
-    const profileDir = persistProfile ? cachePaths.profileDir : join9(cachePaths.projectRoot, "temp-profiles", randomUUID10());
+    const profileDir = persistProfile ? cachePaths.profileDir : join10(cachePaths.projectRoot, "temp-profiles", randomUUID11());
     await mkdir5(profileDir, { recursive: true });
     let context = null;
     try {
@@ -7075,7 +7671,7 @@ var BrowserManager = class {
       if (!browser) {
         throw new Error("Browser instance unavailable");
       }
-      const sessionId = randomUUID10();
+      const sessionId = randomUUID11();
       const targets = new TargetManager();
       const pages = context.pages();
       if (pages.length === 0) {
@@ -8182,9 +8778,18 @@ var BrowserManager = class {
       throw new Error("Screenshot ref and fullPage options are mutually exclusive.");
     }
     return this.runTargetScoped(sessionId, options.targetId, async ({ managed, page, targetId: resolvedTargetId }) => {
+      let artifact;
+      let outputPath = options.path;
+      if (typeof outputPath !== "string") {
+        artifact = createBrowserOutputArtifactDirectory({
+          workspaceRoot: this.worktree,
+          namespace: BROWSER_SCREENSHOT_ARTIFACT_NAMESPACE
+        });
+        outputPath = join10(artifact.artifactPath, "capture.png");
+      }
       const screenshotOptions = {
         type: "png",
-        path: options.path
+        path: outputPath
       };
       if (options.ref) {
         await this.callFunctionOnResolvedRef(managed, options.ref, DOM_SCROLL_INTO_VIEW_DECLARATION, [], resolvedTargetId);
@@ -8194,33 +8799,189 @@ var BrowserManager = class {
         screenshotOptions.fullPage = true;
       }
       try {
-        if (options.path) {
-          await this.withLegacyExtensionOperationTimeout(
-            managed,
-            page.screenshot(screenshotOptions),
-            `page.screenshot: Timeout ${LEGACY_EXTENSION_OPERATION_TIMEOUT_MS}ms exceeded.`
-          );
-          return { path: options.path };
-        }
-        const buffer = await this.withLegacyExtensionOperationTimeout(
+        await this.withLegacyExtensionOperationTimeout(
           managed,
           page.screenshot(screenshotOptions),
           `page.screenshot: Timeout ${LEGACY_EXTENSION_OPERATION_TIMEOUT_MS}ms exceeded.`
         );
-        return { base64: buffer.toString("base64") };
+        return {
+          path: outputPath,
+          ...artifact ? { artifact_path: artifact.artifactPath } : {}
+        };
       } catch (error) {
         const fallback = await this.captureScreenshotViaCdp(managed, page, error, options);
         if (!fallback) {
           throw error;
         }
-        if (options.path) {
-          await writeFile3(options.path, Buffer.from(fallback.base64, "base64"));
-          return fallback.warnings ? { path: options.path, warnings: fallback.warnings } : { path: options.path };
+        await writeFile3(outputPath, Buffer.from(fallback.base64, "base64"));
+        return {
+          path: outputPath,
+          ...artifact ? { artifact_path: artifact.artifactPath } : {},
+          ...fallback.warnings ? { warnings: fallback.warnings } : {}
+        };
+      }
+    });
+  }
+  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)]
+            ));
+          }
         }
-        return fallback;
       }
+      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);
@@ -10512,7 +11273,7 @@ var BrowserManager = class {
         }
         context = await browser.newContext();
       }
-      const sessionId = randomUUID10();
+      const sessionId = randomUUID11();
       const targets = new TargetManager();
       const pages = context.pages();
       if (pages.length === 0) {
@@ -10705,7 +11466,8 @@ function truncateText(value, maxChars) {
 
 // src/browser/ops-browser-manager.ts
 import { writeFile as writeFile4 } from "fs/promises";
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
+import { join as join11 } from "path";
 var OpsBrowserManager = class {
   base;
   config;
@@ -10839,7 +11601,7 @@ var OpsBrowserManager = class {
       config: this.config
     });
     const client = await this.ensureOpsClient(connectEndpoint);
-    const leaseId = randomUUID11();
+    const leaseId = randomUUID12();
     const result = await client.request(
       "session.connect",
       {
@@ -11311,11 +12073,27 @@ var OpsBrowserManager = class {
       throw new Error("Screenshot failed");
     }
     const warnings = Array.isArray(result.warnings) ? result.warnings : typeof result.warning === "string" ? [result.warning] : void 0;
-    if (options.path) {
-      await writeFile4(options.path, Buffer.from(result.base64, "base64"));
-      return warnings ? { path: options.path, warnings } : { path: options.path };
+    let artifact;
+    let outputPath = options.path;
+    if (typeof outputPath !== "string") {
+      artifact = createBrowserOutputArtifactDirectory({
+        workspaceRoot: this.worktree,
+        namespace: BROWSER_SCREENSHOT_ARTIFACT_NAMESPACE
+      });
+      outputPath = join11(artifact.artifactPath, "capture.png");
     }
-    return warnings ? { base64: result.base64, warnings } : { base64: result.base64 };
+    await writeFile4(outputPath, Buffer.from(result.base64, "base64"));
+    return {
+      path: outputPath,
+      ...artifact ? { artifact_path: artifact.artifactPath } : {},
+      ...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)) {
@@ -12210,7 +12988,7 @@ var normalizeRecoverableOpsUrl = (url) => {
 };
 
 // src/browser/annotation-manager.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 import { WebSocket as WebSocket2 } from "ws";
 
 // src/annotate/timeout-messages.ts
@@ -12221,9 +12999,9 @@ var getAnnotationTimeoutMessage = (readySeen) => {
 };
 
 // src/annotate/direct-annotator.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 import { existsSync as existsSync2 } from "fs";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 var DEFAULT_TIMEOUT_MS = 12e4;
 var DIRECT_ANNOTATE_REQUIRED_FILES = [
   "dist/annotate-content.js",
@@ -12238,15 +13016,15 @@ function resolveDirectAnnotateAssets(resolvePath = () => getExtensionRuntimePath
   if (!extensionPath) {
     return { error: "Extension assets unavailable." };
   }
-  const scriptPath = join10(extensionPath, "dist", "annotate-content.js");
-  const stylePath = join10(extensionPath, "dist", "annotate-content.css");
+  const scriptPath = join12(extensionPath, "dist", "annotate-content.js");
+  const stylePath = join12(extensionPath, "dist", "annotate-content.css");
   if (!existsSync2(scriptPath) || !existsSync2(stylePath)) {
     return { error: "Direct annotate assets missing. Run `npm run extension:build` and retry." };
   }
   return { assets: { scriptPath, stylePath } };
 }
 async function runDirectAnnotate(manager, assets, request) {
-  const requestId = randomUUID12();
+  const requestId = randomUUID13();
   const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   return manager.withPage(request.sessionId, request.targetId ?? null, async (page) => {
     await ensureBindings(page);
@@ -12546,7 +13324,7 @@ var AnnotationManager = class {
     return this.requestRelay(options, false);
   }
   async requestStored(options) {
-    const requestId = randomUUID13();
+    const requestId = randomUUID14();
     const sharedPayload = this.agentInbox?.latestPayload();
     if (sharedPayload) {
       return {
@@ -12591,7 +13369,7 @@ var AnnotationManager = class {
     return this.relay?.getAnnotationUrl?.() ?? (this.config.relayPort > 0 ? `ws://127.0.0.1:${this.config.relayPort}/annotation` : null);
   }
   async requestDirect(options) {
-    const requestId = randomUUID13();
+    const requestId = randomUUID14();
     if (!options.sessionId) {
       return {
         version: 1,
@@ -12639,7 +13417,7 @@ var AnnotationManager = class {
     }
   }
   async requestRelay(options, requireExtension, commandName = "start") {
-    const requestId = randomUUID13();
+    const requestId = randomUUID14();
     const timeoutMs = options.timeoutMs ?? 12e4;
     let resolvedTabId = options.tabId;
     if (requireExtension && options.sessionId && this.manager) {
@@ -12866,12 +13644,12 @@ var parseJson2 = (data) => {
 };
 
 // src/browser/canvas-manager.ts
-import { randomUUID as randomUUID18 } from "crypto";
+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 randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 import { WebSocket as WebSocket3 } from "ws";
 var CanvasClient = class {
   url;
@@ -13047,7 +13825,7 @@ var CanvasClient = class {
     if (!this.socket || this.socket.readyState !== WebSocket3.OPEN) {
       await this.connect();
     }
-    const requestId = randomUUID14();
+    const requestId = randomUUID15();
     const request = {
       type: "canvas_request",
       requestId,
@@ -13193,7 +13971,7 @@ var CanvasClient = class {
     if (!this.socket || this.socket.readyState !== WebSocket3.OPEN) {
       return;
     }
-    const id2 = randomUUID14();
+    const id2 = randomUUID15();
     const ping = { type: "canvas_ping", id: id2 };
     await new Promise((resolve7, reject) => {
       const timeoutId = setTimeout(() => {
@@ -13260,7 +14038,7 @@ var isCanvasEvent = (value) => {
 var isRecord2 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 
 // src/canvas/document-store.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 
 // node_modules/lib0/map.js
 var create = () => /* @__PURE__ */ new Map();
@@ -21567,7 +22345,7 @@ function createDefaultNode(pageId, nodeId, name) {
     metadata: {}
   };
 }
-function createDefaultCanvasDocument(documentId = `dc_${randomUUID15()}`) {
+function createDefaultCanvasDocument(documentId = `dc_${randomUUID16()}`) {
   const createdAt = nowIso();
   const rootNodeId = `node_root_${documentId.slice(-8)}`;
   const pageId = "page_home";
@@ -21615,7 +22393,7 @@ function normalizeCanvasDocument(input) {
   const updatedAt = typeof base.updatedAt === "string" ? base.updatedAt : createdAt;
   return {
     schemaVersion: typeof base.schemaVersion === "string" ? base.schemaVersion : CANVAS_SCHEMA_VERSION,
-    documentId: typeof base.documentId === "string" ? base.documentId : `dc_${randomUUID15()}`,
+    documentId: typeof base.documentId === "string" ? base.documentId : `dc_${randomUUID16()}`,
     title: typeof base.title === "string" && base.title.trim() ? base.title : "Untitled Design Canvas",
     createdAt,
     updatedAt,
@@ -21648,7 +22426,7 @@ function normalizeCanvasDocument(input) {
     componentInventory: normalizeArray(base.componentInventory, normalizeCanvasComponentInventoryItem),
     tokens: normalizeCanvasTokenStore(base.tokens),
     assets: Array.isArray(base.assets) ? base.assets.map((asset) => ({
-      id: typeof asset.id === "string" ? asset.id : `asset_${randomUUID15()}`,
+      id: typeof asset.id === "string" ? asset.id : `asset_${randomUUID16()}`,
       sourceType: typeof asset.sourceType === "string" ? asset.sourceType : void 0,
       kind: typeof asset.kind === "string" ? asset.kind : void 0,
       repoPath: typeof asset.repoPath === "string" ? asset.repoPath : null,
@@ -21880,7 +22658,7 @@ function buildInventoryItemFromNode(document2, nodeId, options = {}) {
   const origin = options.origin && CANVAS_INVENTORY_ORIGINS.has(options.origin) ? options.origin : baseOrigin;
   const template = buildInventoryTemplate(document2, nodeId);
   return normalizeCanvasComponentInventoryItem({
-    id: options.itemId ?? `inventory_${randomUUID15().slice(0, 8)}`,
+    id: options.itemId ?? `inventory_${randomUUID16().slice(0, 8)}`,
     name: options.name ?? node.name,
     componentName: binding?.componentName ?? node.name,
     description: options.description ?? null,
@@ -22873,7 +23651,7 @@ var CanvasDocumentStore = class {
     }
     this.replaceDocument(nextDocument, this.revision + 1, "canvas.store.apply-patches");
     return {
-      transactionId: `txn_${randomUUID15()}`,
+      transactionId: `txn_${randomUUID16()}`,
       appliedRevision: this.revision,
       warnings: evaluateCanvasWarnings(this.document),
       evidenceRefs: []
@@ -22888,7 +23666,7 @@ var CanvasDocumentStore = class {
     }
     this.replaceDocument(normalizeCanvasDocument(document2), this.revision + 1, "canvas.store.replace-document");
     return {
-      transactionId: `txn_${randomUUID15()}`,
+      transactionId: `txn_${randomUUID16()}`,
       appliedRevision: this.revision,
       warnings: evaluateCanvasWarnings(this.document),
       evidenceRefs: []
@@ -23383,7 +24161,7 @@ function duplicateNodeSubtree(document2, nodeId, parentId, index, idMapInput) {
       throw new Error(`Unknown node: ${sourceNodeId}`);
     }
     const mappedId = isRecord4(idMapInput) ? idMapInput[sourceNode.id] : null;
-    const duplicateId = typeof mappedId === "string" && mappedId.trim().length > 0 ? mappedId : `${sourceNode.id}_copy_${randomUUID15().slice(0, 8)}`;
+    const duplicateId = typeof mappedId === "string" && mappedId.trim().length > 0 ? mappedId : `${sourceNode.id}_copy_${randomUUID16().slice(0, 8)}`;
     idMap.set(sourceNode.id, duplicateId);
     const nextMetadata = clone(sourceNode.metadata);
     if (isRecord4(nextMetadata.codeSync)) {
@@ -24935,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 join11, 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);
@@ -25119,24 +25897,24 @@ function resolveCanvasRepoPath(worktree, documentId, repoPath) {
   if (repoPath && repoPath.trim()) {
     return isAbsolute3(repoPath) ? repoPath : resolve2(worktree, repoPath);
   }
-  return join11(worktree, ".opendevbrowser", "canvas", `${documentId}.canvas.json`);
+  return join13(worktree, ".opendevbrowser", "canvas", `${documentId}.canvas.json`);
 }
 function resolveCanvasCodeSyncManifestPath(worktree, documentId, bindingId, repoPath) {
   if (repoPath && repoPath.trim()) {
     return isAbsolute3(repoPath) ? repoPath : resolve2(worktree, repoPath);
   }
-  return join11(worktree, ".opendevbrowser", "canvas", "code-sync", documentId, `${bindingId}.json`);
+  return join13(worktree, ".opendevbrowser", "canvas", "code-sync", documentId, `${bindingId}.json`);
 }
 function resolveCanvasFigmaAssetDir(worktree, fileKey) {
-  return join11(worktree, ".opendevbrowser", "canvas", "assets", "figma", fileKey);
+  return join13(worktree, ".opendevbrowser", "canvas", "assets", "figma", fileKey);
 }
 function resolveCanvasFigmaAssetPath(worktree, fileKey, assetId, extension) {
   const normalizedExtension = extension.startsWith(".") ? extension : `.${extension}`;
-  return join11(resolveCanvasFigmaAssetDir(worktree, fileKey), `${assetId}${normalizedExtension}`);
+  return join13(resolveCanvasFigmaAssetDir(worktree, fileKey), `${assetId}${normalizedExtension}`);
 }
 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;
@@ -25158,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;
@@ -25540,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 join12, 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
@@ -25636,7 +26414,7 @@ async function readJson(filePath) {
   return JSON.parse(await readFile3(filePath, "utf8"));
 }
 async function loadPackageJson(worktree) {
-  const packagePath = join12(worktree, "package.json");
+  const packagePath = join14(worktree, "package.json");
   try {
     return await readJson(packagePath);
   } catch (error) {
@@ -25684,14 +26462,14 @@ function applyDeclarationOverrides(manifest, declaration) {
 async function resolveDeclarationRef(worktree, ref) {
   const direct = isAbsolute4(ref) ? ref : resolve4(worktree, ref);
   if (await exists(direct)) {
-    const manifestPath2 = direct.endsWith(".json") ? direct : join12(direct, "canvas-adapter.plugin.json");
+    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
     };
   }
-  const nodeModulesPath = join12(worktree, "node_modules", ref);
-  const manifestPath = join12(nodeModulesPath, "canvas-adapter.plugin.json");
+  const nodeModulesPath = join14(worktree, "node_modules", ref);
+  const manifestPath = join14(nodeModulesPath, "canvas-adapter.plugin.json");
   return {
     packageRoot: nodeModulesPath,
     manifestPath
@@ -25702,7 +26480,7 @@ async function readDeclarationSource(worktree) {
   const openDevBrowserConfig = isRecord7(packageJson.opendevbrowser) ? packageJson.opendevbrowser : null;
   const canvasConfig = openDevBrowserConfig && isRecord7(openDevBrowserConfig.canvas) ? openDevBrowserConfig.canvas : null;
   const packageDeclarations = Array.isArray(canvasConfig?.adapterPlugins) ? canvasConfig.adapterPlugins : [];
-  const repoFile = join12(worktree, ".opendevbrowser", "canvas", "adapters.json");
+  const repoFile = join14(worktree, ".opendevbrowser", "canvas", "adapters.json");
   const repoDeclarations = await exists(repoFile) ? (await readJson(repoFile)).adapterPlugins ?? [] : [];
   return { packageDeclarations, repoDeclarations };
 }
@@ -25748,7 +26526,7 @@ function applyCapabilityOverridesToRegisteredAdapters(params2) {
 async function fingerprintPluginFiles(manifestPath, packageRoot, manifest) {
   const entryPath = resolve4(packageRoot, manifest.entry);
   const fixturePath = resolve4(packageRoot, manifest.fixtureDir);
-  const packageJsonPath = join12(packageRoot, "package.json");
+  const packageJsonPath = join14(packageRoot, "package.json");
   const [manifestContent, entryContent, packageJsonContent] = await Promise.all([
     readFile3(manifestPath, "utf8"),
     readFile3(entryPath, "utf8"),
@@ -27102,7 +27880,7 @@ function collectGraphOrder(graph, nodeKey) {
 }
 
 // src/canvas/code-sync/import.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 
 // src/canvas/code-sync/graph.ts
 function locatorKey(locator) {
@@ -27232,7 +28010,7 @@ function buildNodeName(graphNode) {
   return graphNode.tagName ?? "Element";
 }
 function buildNodeId(graphNode, manifestLookup) {
-  return manifestLookup.get(locatorKey(graphNode.locator)) ?? `node_sync_${randomUUID16().slice(0, 8)}`;
+  return manifestLookup.get(locatorKey(graphNode.locator)) ?? `node_sync_${randomUUID17().slice(0, 8)}`;
 }
 function preorder(graph, nodeKey) {
   const node = graph.nodes[nodeKey];
@@ -27336,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) {
@@ -28200,11 +28978,11 @@ function maxIso(values) {
 }
 
 // src/browser/canvas-session-sync-manager.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 var CanvasSessionSyncManager = class {
   sessions = /* @__PURE__ */ new Map();
   initializeSession(canvasSessionId, leaseId, clientId) {
-    const initialClientId = normalizeClientId(clientId) ?? `canvas_owner_${randomUUID17().slice(0, 8)}`;
+    const initialClientId = normalizeClientId(clientId) ?? `canvas_owner_${randomUUID18().slice(0, 8)}`;
     const attachedAt = (/* @__PURE__ */ new Date()).toISOString();
     const attachedClients = /* @__PURE__ */ new Map();
     attachedClients.set(initialClientId, {
@@ -28232,7 +29010,7 @@ var CanvasSessionSyncManager = class {
     if (!state) {
       throw new Error(`Unknown canvas session for attach: ${canvasSessionId}`);
     }
-    const resolvedClientId = normalizeClientId(clientId) ?? `canvas_client_${randomUUID17().slice(0, 8)}`;
+    const resolvedClientId = normalizeClientId(clientId) ?? `canvas_client_${randomUUID18().slice(0, 8)}`;
     const previous = state.attachedClients.get(resolvedClientId);
     const attachedAt = previous?.attachedAt ?? (/* @__PURE__ */ new Date()).toISOString();
     let role = "observer";
@@ -29675,8 +30453,8 @@ var CanvasManager = class {
     const repoRoot = optionalString5(params2.repoRoot) ?? this.worktree;
     const mode = requireCanvasSessionMode(params2.mode);
     const document2 = repoPath ? normalizeCanvasDocument(await loadCanvasDocument(repoRoot, repoPath)) : createDefaultCanvasDocument(requestedDocumentId ?? void 0);
-    const sessionId = `canvas_${randomUUID18()}`;
-    const leaseId = `lease_${randomUUID18()}`;
+    const sessionId = `canvas_${randomUUID19()}`;
+    const leaseId = `lease_${randomUUID19()}`;
     const planState = resolveGenerationPlanState(document2.designGovernance.generationPlan);
     const session = {
       canvasSessionId: sessionId,
@@ -29718,7 +30496,7 @@ var CanvasManager = class {
   attachSession(params2) {
     const session = this.requireSession(params2);
     const attachMode = requireAttachMode(params2.attachMode);
-    const nextLeaseId = attachMode === "lease_reclaim" ? `lease_${randomUUID18()}` : session.leaseId;
+    const nextLeaseId = attachMode === "lease_reclaim" ? `lease_${randomUUID19()}` : session.leaseId;
     const attached = this.sessionSyncManager.attach(
       session.canvasSessionId,
       nextLeaseId,
@@ -30075,7 +30853,7 @@ var CanvasManager = class {
     const session = this.requireSession(params2);
     this.assertLease(session, params2);
     const nodeId = requireString2(params2.nodeId, "nodeId");
-    const bindingId = optionalString5(params2.bindingId) ?? `binding_sync_${randomUUID18().slice(0, 8)}`;
+    const bindingId = optionalString5(params2.bindingId) ?? `binding_sync_${randomUUID19().slice(0, 8)}`;
     const binding = createCodeSyncBinding(params2, nodeId, bindingId);
     const baseRevision = session.store.getRevision();
     await this.applyDocumentPatches(session, baseRevision, [{
@@ -30410,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) {
@@ -30859,7 +31637,7 @@ var CanvasManager = class {
         prototypeId
       });
     } else if (status.mode === "extension" && this.supportsOpsOverlayTransport(session) && typeof this.browserManager.mountCanvasOverlay === "function") {
-      const mountId2 = `mount_${randomUUID18()}`;
+      const mountId2 = `mount_${randomUUID19()}`;
       result = await this.browserManager.mountCanvasOverlay(session.browserSessionId, targetId, {
         mountId: mountId2,
         title: session.store.getDocument().title,
@@ -30869,7 +31647,7 @@ var CanvasManager = class {
     } else {
       result = await this.mountDirectOverlay(session.browserSessionId, targetId, session.store.getDocument(), prototypeId);
     }
-    const mountId = typeof result.mountId === "string" ? result.mountId : `mount_${randomUUID18()}`;
+    const mountId = typeof result.mountId === "string" ? result.mountId : `mount_${randomUUID19()}`;
     session.overlayMounts.set(mountId, { mountId, targetId, mountedAt: (/* @__PURE__ */ new Date()).toISOString() });
     const previewState = session.activeTargets.get(targetId)?.previewState ?? "background";
     if (!usesCanvasRelayOverlay) {
@@ -31209,7 +31987,7 @@ var CanvasManager = class {
   subscribeFeedback(params2) {
     const session = this.requireSession(params2);
     const polled = this.pollFeedback(params2);
-    const subscriptionId = `canvas_sub_${randomUUID18()}`;
+    const subscriptionId = `canvas_sub_${randomUUID19()}`;
     const heartbeatMs = FEEDBACK_HEARTBEAT_MS;
     const subscription = {
       id: subscriptionId,
@@ -32507,7 +33285,7 @@ function readInsertPlacement(params2) {
 }
 function materializeInventoryItem(item, pageId, parentId, placement) {
   const template = readInventoryTemplate(item);
-  const idMap = new Map(template.nodes.map((node) => [node.id, `node_inventory_${randomUUID18().slice(0, 8)}`]));
+  const idMap = new Map(template.nodes.map((node) => [node.id, `node_inventory_${randomUUID19().slice(0, 8)}`]));
   const root = template.nodes.find((node) => node.id === template.rootNodeId) ?? template.nodes[0];
   const offsetX = (placement.x ?? root.rect.x) - root.rect.x;
   const offsetY = (placement.y ?? root.rect.y) - root.rect.y;
@@ -32683,11 +33461,11 @@ function buildStarterInventoryUpsertPatches(kitIds, frameworkId, adapterId) {
   }));
 }
 function buildStarterShell(definition, pageId, parentId, placement) {
-  const rootNodeId = `node_starter_${randomUUID18().slice(0, 8)}`;
-  const eyebrowNodeId = `node_starter_${randomUUID18().slice(0, 8)}`;
-  const headlineNodeId = `node_starter_${randomUUID18().slice(0, 8)}`;
-  const bodyNodeId = `node_starter_${randomUUID18().slice(0, 8)}`;
-  const actionNodeId = definition.shell.actionLabel ? `node_starter_${randomUUID18().slice(0, 8)}` : null;
+  const rootNodeId = `node_starter_${randomUUID19().slice(0, 8)}`;
+  const eyebrowNodeId = `node_starter_${randomUUID19().slice(0, 8)}`;
+  const headlineNodeId = `node_starter_${randomUUID19().slice(0, 8)}`;
+  const bodyNodeId = `node_starter_${randomUUID19().slice(0, 8)}`;
+  const actionNodeId = definition.shell.actionLabel ? `node_starter_${randomUUID19().slice(0, 8)}` : null;
   const rect = {
     ...definition.shell.rect,
     x: placement.x ?? definition.shell.rect.x,
@@ -33007,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" });
@@ -33338,7 +34116,7 @@ function ensureDuplicatePatchIds(document2, patch) {
   }
   const subtreeNodeIds = collectSubtreeNodeIds(document2, patch.nodeId);
   const idMap = Object.fromEntries(
-    subtreeNodeIds.map((nodeId) => [nodeId, `${nodeId}_copy_${randomUUID18().slice(0, 8)}`])
+    subtreeNodeIds.map((nodeId) => [nodeId, `${nodeId}_copy_${randomUUID19().slice(0, 8)}`])
   );
   return {
     ...patch,
@@ -33357,7 +34135,7 @@ function buildCanvasHistoryEntry(beforeDocument, patches, options) {
     scratchStore.applyPatches(scratchStore.getRevision(), [patch]);
   }
   return {
-    id: `history_${randomUUID18().slice(0, 8)}`,
+    id: `history_${randomUUID19().slice(0, 8)}`,
     source: options.source,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     forwardPatches: structuredClone(patches),
@@ -33588,7 +34366,7 @@ function attachDetails(error, details) {
 
 // src/relay/relay-server.ts
 import { createServer } from "http";
-import { timingSafeEqual, randomUUID as randomUUID19 } from "crypto";
+import { timingSafeEqual, randomUUID as randomUUID20 } from "crypto";
 import { WebSocket as WebSocket4, WebSocketServer } from "ws";
 var DEFAULT_DISCOVERY_PORT = 8787;
 var CONFIG_PATH = "/config";
@@ -33596,7 +34374,7 @@ var PAIR_PATH = "/pair";
 var STATUS_PATH = "/status";
 var CDP_TOKEN_QUERY_KEY = "token";
 var RelayServer = class _RelayServer {
-  instanceId = randomUUID19();
+  instanceId = randomUUID20();
   epoch = Date.now();
   running = false;
   baseUrl = null;
@@ -33729,7 +34507,7 @@ var RelayServer = class _RelayServer {
       });
     });
     this.opsWss.on("connection", (socket, _request) => {
-      const clientId = randomUUID19();
+      const clientId = randomUUID20();
       this.opsClients.set(clientId, socket);
       socket.on("message", (data) => {
         this.handleOpsClientMessage(clientId, data);
@@ -33753,7 +34531,7 @@ var RelayServer = class _RelayServer {
       void _request;
     });
     this.canvasWss.on("connection", (socket, _request) => {
-      const clientId = randomUUID19();
+      const clientId = randomUUID20();
       this.canvasClients.set(clientId, socket);
       socket.on("message", (data) => {
         this.handleCanvasClientMessage(clientId, data);
@@ -35435,4 +36213,4 @@ export {
   createOpenDevBrowserCore
 };
 /* v8 ignore next -- @preserve */
-//# sourceMappingURL=chunk-EOX6U6Q4.js.map
+//# sourceMappingURL=chunk-AHQC4A6P.js.map