@wenathlan/extension 1.1.39 → 1.1.41

package/dist/index.js

@@ -1,3 +1,503 @@
+// capture.ts
+var captureformats = ["png", "jpeg", "webp"];
+var capturetargets = ["memory", "download", "clipboard"];
+var capturekinds = ["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"];
+function captureoptionsof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const options = value;
+  const normalized = {};
+  if (options.format === "png" || options.format === "jpeg" || options.format === "webp") normalized.format = options.format;
+  if (typeof options.quality === "number" && Number.isFinite(options.quality)) normalized.quality = options.quality;
+  if (typeof options.pixelratio === "number" && Number.isFinite(options.pixelratio)) normalized.pixelratio = options.pixelratio;
+  if (typeof options.annotate === "boolean") normalized.annotate = options.annotate;
+  if (options.exporttarget === "memory" || options.exporttarget === "download" || options.exporttarget === "clipboard") normalized.exporttarget = options.exporttarget;
+  return normalized;
+}
+function capturevisible(input) {
+  const ratio = input.options.pixelratio ?? 1;
+  return {
+    id: input.id,
+    runid: input.runid,
+    stepid: input.stepid,
+    kind: "shotview",
+    format: input.options.format ?? "png",
+    width: Math.round(input.viewport.width * ratio),
+    height: Math.round(input.viewport.height * ratio),
+    capturedat: input.at,
+    bytes: input.dataurl,
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.options.annotate === true ? { annotated: true } : {},
+    ...input.options.exporttarget !== void 0 ? { exporttarget: input.options.exporttarget } : {},
+    ...input.target !== void 0 ? { target: input.target } : {}
+  };
+}
+function capturestitched(input) {
+  const ratio = input.options.pixelratio ?? 1;
+  return {
+    id: input.id,
+    runid: input.runid,
+    stepid: input.stepid,
+    kind: "shotfullpage",
+    format: input.options.format ?? "png",
+    width: Math.round(input.plan.scrollwidth * ratio),
+    height: Math.round(input.plan.scrollheight * ratio),
+    capturedat: input.at,
+    bytes: input.dataurl,
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.options.annotate === true ? { annotated: true } : {},
+    ...input.options.exporttarget !== void 0 ? { exporttarget: input.options.exporttarget } : {}
+  };
+}
+function captureelement(input) {
+  const ratio = input.options.pixelratio ?? 1;
+  const scaled = scaledrect(input.rect, ratio);
+  return {
+    id: input.id,
+    runid: input.runid,
+    stepid: input.stepid,
+    kind: "shotelement",
+    format: input.options.format ?? "png",
+    width: scaled.width,
+    height: scaled.height,
+    capturedat: input.at,
+    bytes: input.dataurl,
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.options.annotate === true ? { annotated: true } : {},
+    ...input.options.exporttarget !== void 0 ? { exporttarget: input.options.exporttarget } : {},
+    ...input.target !== void 0 ? { target: input.target } : {}
+  };
+}
+function captureregion(input) {
+  const ratio = input.options.pixelratio ?? 1;
+  const scaled = scaledrect(input.rect, ratio);
+  return {
+    id: input.id,
+    runid: input.runid,
+    stepid: input.stepid,
+    kind: "shotregion",
+    format: input.options.format ?? "png",
+    width: scaled.width,
+    height: scaled.height,
+    capturedat: input.at,
+    bytes: input.dataurl,
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.options.annotate === true ? { annotated: true } : {},
+    ...input.options.exporttarget !== void 0 ? { exporttarget: input.options.exporttarget } : {},
+    ...input.target !== void 0 ? { target: input.target } : {}
+  };
+}
+function pairstates(before, after, action, at, id) {
+  if (!before) return { skipped: "before", reason: "The before shot was not captured, so no state pair exists." };
+  if (!after) return { skipped: "after", reason: `The action of kind ${action.kind} failed before the after shot, so the state pair is skipped.` };
+  return {
+    pair: {
+      id,
+      beforeid: before.id,
+      afterid: after.id,
+      actionkind: action.kind,
+      ...action.target !== void 0 ? { target: action.target } : {},
+      ...action.domsnapshotid !== void 0 ? { domsnapshotid: action.domsnapshotid } : {},
+      at
+    },
+    reason: `Paired the before shot ${before.id} with the after shot ${after.id} around the ${action.kind} action.`
+  };
+}
+function capturestates(input) {
+  if (input.policy !== "beforeafter") return { reason: `The ${input.policy} capture policy takes no state pair around the ${input.actionkind} action.` };
+  return pairstates(input.before, input.after, { kind: input.actionkind, ...input.target !== void 0 ? { target: input.target } : {}, ...input.domsnapshotid !== void 0 ? { domsnapshotid: input.domsnapshotid } : {} }, input.at, input.id);
+}
+function buildstitchplan(input) {
+  const overlap = Math.max(0, Math.round(input.overlap ?? 0));
+  const stepy = Math.max(1, input.viewportheight - overlap);
+  const columns = Math.max(1, Math.ceil(input.scrollwidth / input.viewportwidth));
+  const rows = input.scrollheight <= input.viewportheight ? 1 : Math.max(1, Math.ceil((input.scrollheight - overlap) / stepy));
+  const tiles = [];
+  for (let column = 0; column < columns; column += 1) {
+    for (let row = 0; row < rows; row += 1) {
+      const x = Math.min(column * input.viewportwidth, Math.max(0, input.scrollwidth - input.viewportwidth));
+      const y = rows === 1 ? 0 : Math.min(row * stepy, Math.max(0, input.scrollheight - input.viewportheight));
+      tiles.push({ x: Math.round(x), y: Math.round(y) });
+    }
+  }
+  return { columns, rows, tiles, overlap, scrollwidth: Math.round(input.scrollwidth), scrollheight: Math.round(input.scrollheight), viewportwidth: Math.round(input.viewportwidth), viewportheight: Math.round(input.viewportheight) };
+}
+function seamweights(overlap) {
+  if (overlap <= 0) return [];
+  const weights = [];
+  for (let index = 0; index < overlap; index += 1) weights.push((index + 1) / (overlap + 1));
+  return weights;
+}
+function blendrows(upper, lower) {
+  const weights = seamweights(upper.length);
+  return upper.map((value, index) => {
+    const weight = weights[index] ?? 1;
+    return value * (1 - weight) + (lower[index] ?? value) * weight;
+  });
+}
+function fixedheadermatch(band, firstband) {
+  if (band.length === 0 || band.length !== firstband.length) return false;
+  return band.every((value, index) => value === firstband[index]);
+}
+function scaledrect(rect, pixelratio) {
+  const ratio = pixelratio >= 1 ? pixelratio : 1;
+  return { x: Math.round(rect.x * ratio), y: Math.round(rect.y * ratio), width: Math.round(rect.width * ratio), height: Math.round(rect.height * ratio) };
+}
+function croprect(rect, viewport) {
+  const x = Math.max(0, rect.x);
+  const y = Math.max(0, rect.y);
+  return { x: Math.round(x), y: Math.round(y), width: Math.round(Math.max(0, Math.min(rect.width, viewport.width - x))), height: Math.round(Math.max(0, Math.min(rect.height, viewport.height - y))) };
+}
+function crossesviewport(rect, viewport) {
+  return rect.x < 0 || rect.y < 0 || rect.x + rect.width > viewport.width || rect.y + rect.height > viewport.height;
+}
+function regionsteps(containerheight, viewportstep) {
+  if (containerheight <= 0 || viewportstep <= 0) return [0];
+  const steps = [];
+  for (let top = 0; top < containerheight; top += viewportstep) {
+    const clamped = Math.min(top, Math.max(0, containerheight - viewportstep));
+    if (!steps.includes(clamped)) steps.push(clamped);
+  }
+  return steps;
+}
+function buildsheet(cells, layout) {
+  const columns = Math.max(1, Math.round(layout.columns));
+  const rows = Math.max(1, Math.ceil(cells.length / columns));
+  const placed = cells.map((cell, index) => {
+    const column = index % columns;
+    const row = Math.floor(index / columns);
+    const label = cell.label ?? "";
+    const caption = layout.label === "none" ? "" : layout.label === "index" ? `${index + 1}` : layout.label === "selector" ? cell.selector : label ? `${index + 1} \xB7 ${cell.selector} \xB7 ${label}` : `${index + 1} \xB7 ${cell.selector}`;
+    return { index, column, row, selector: cell.selector, label, caption };
+  });
+  return { columns, rows, cells: placed };
+}
+function capturepart(value) {
+  return value.replace(/[^a-z0-9-]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase() || "capture";
+}
+function buildname(rule, parts, extension) {
+  const segments = [];
+  if (rule.run) segments.push(capturepart(parts.run));
+  if (rule.step) segments.push(capturepart(parts.step));
+  if (rule.sequence) segments.push(String(Math.max(0, Math.round(parts.sequence))));
+  if (rule.kind) segments.push(capturepart(parts.kind));
+  const safeextension = extension.replace(/^\.+/, "").toLowerCase() || "png";
+  return `${(segments.length > 0 ? segments : ["capture"]).join("-")}.${safeextension}`;
+}
+function annotationplanof(input) {
+  const inset = Math.min(24, Math.max(8, Math.round(Math.min(input.width, input.height) / 12)));
+  const plan = {
+    marker: { x: inset, y: inset, number: Math.max(1, Math.round(input.step)) },
+    footer: `${new Date(input.at).toISOString()} \xB7 ${input.url}`
+  };
+  if (input.rect !== void 0) {
+    const expansion = 2;
+    plan.outline = { x: Math.round(input.rect.x - expansion), y: Math.round(input.rect.y - expansion), width: Math.round(input.rect.width + expansion * 2), height: Math.round(input.rect.height + expansion * 2) };
+  }
+  return plan;
+}
+
+// media.ts
+var mediakinds = ["capturepdf", "recordscreen", "captureaudio", "captureframe", "downloadimages", "shotcanvas", "probestream", "readmedia", "readassets", "timelapse", "convertimage", "makethumbs"];
+var defaultpaperwidth = 8.5;
+var defaultpaperheight = 11;
+var defaultmargins = { top: 0.4, right: 0.4, bottom: 0.4, left: 0.4 };
+var pdfpointsperinch = 72;
+var basefontsize = 11;
+function pdfoptionsof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const options = value;
+  const normalized = {};
+  if (typeof options.paperwidth === "number" && Number.isFinite(options.paperwidth)) normalized.paperwidth = options.paperwidth;
+  if (typeof options.paperheight === "number" && Number.isFinite(options.paperheight)) normalized.paperheight = options.paperheight;
+  if (options.margins && typeof options.margins === "object" && !Array.isArray(options.margins)) {
+    const margins = options.margins;
+    const top = typeof margins.top === "number" ? margins.top : defaultmargins.top;
+    const right = typeof margins.right === "number" ? margins.right : defaultmargins.right;
+    const bottom = typeof margins.bottom === "number" ? margins.bottom : defaultmargins.bottom;
+    const left = typeof margins.left === "number" ? margins.left : defaultmargins.left;
+    normalized.margins = { top, right, bottom, left };
+  }
+  if (typeof options.scale === "number" && Number.isFinite(options.scale)) normalized.scale = options.scale;
+  if (typeof options.landscape === "boolean") normalized.landscape = options.landscape;
+  if (typeof options.paginate === "boolean") normalized.paginate = options.paginate;
+  return normalized;
+}
+function pdfpagesize(options) {
+  const width = (options.paperwidth ?? defaultpaperwidth) * pdfpointsperinch;
+  const height = (options.paperheight ?? defaultpaperheight) * pdfpointsperinch;
+  return options.landscape === true ? { width: height, height: width } : { width, height };
+}
+function pdfmargins(options) {
+  const margins = options.margins ?? defaultmargins;
+  return { top: margins.top * pdfpointsperinch, right: margins.right * pdfpointsperinch, bottom: margins.bottom * pdfpointsperinch, left: margins.left * pdfpointsperinch };
+}
+function pdffontsize(options) {
+  return basefontsize * (options.scale ?? 1);
+}
+function pdftextlayout(text2, options) {
+  const size = pdfpagesize(options);
+  const margins = pdfmargins(options);
+  const fontsize = pdffontsize(options);
+  const leading = fontsize * 1.35;
+  const linesperpage = Math.max(1, Math.floor((size.height - margins.top - margins.bottom) / leading));
+  const columns = Math.max(1, Math.floor((size.width - margins.left - margins.right) / (fontsize * 0.5)));
+  const wrapped = [];
+  for (const paragraph of text2.split(/\r?\n/)) {
+    let line = "";
+    for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+      const candidate = line ? `${line} ${word}` : word;
+      if (candidate.length <= columns) {
+        line = candidate;
+        continue;
+      }
+      if (line) wrapped.push(line);
+      if (word.length <= columns) {
+        line = word;
+        continue;
+      }
+      for (let index = 0; index < word.length; index += columns) wrapped.push(word.slice(index, index + columns));
+      line = "";
+    }
+    wrapped.push(line);
+    if (wrapped.length >= linesperpage) break;
+  }
+  return wrapped.slice(0, linesperpage);
+}
+function pdfsegments(scrollheight, viewportheight, breaks) {
+  if (scrollheight <= 0) return [];
+  const step = viewportheight > 0 ? viewportheight : scrollheight;
+  const cuts = [0, ...breaks.filter((top) => Number.isFinite(top) && top > 0 && top < scrollheight).map((top) => Math.round(top))].filter((top, index2, list) => list.indexOf(top) === index2).sort((left, right) => left - right);
+  const segments = [];
+  let index = 0;
+  let cursor = 0;
+  while (cursor < scrollheight) {
+    while (index < cuts.length && (cuts[index] ?? 0) <= cursor) index += 1;
+    const nextcut = index < cuts.length ? cuts[index] : void 0;
+    const next = nextcut !== void 0 ? Math.min(nextcut, scrollheight) : Math.min(cursor + step, scrollheight);
+    if (next <= cursor) break;
+    segments.push({ top: cursor, height: next - cursor });
+    cursor = next;
+  }
+  return segments.length > 0 ? segments : [{ top: 0, height: scrollheight }];
+}
+function pdfescape(text2) {
+  let escaped = "";
+  for (const character of text2) {
+    const code = character.charCodeAt(0);
+    if (character === "(" || character === ")" || character === "\\") escaped += `\\${character}`;
+    else if (code >= 32 && code <= 255) escaped += character;
+    else escaped += "?";
+  }
+  return escaped;
+}
+function buildpdf(pages, options) {
+  const size = pdfpagesize(options);
+  const margins = pdfmargins(options);
+  const fontsize = pdffontsize(options);
+  const leading = fontsize * 1.35;
+  const laidout = (pages.length > 0 ? pages : [""]).map((text2) => pdftextlayout(text2, options));
+  const objects = [];
+  const kids = laidout.map((_, index) => `${4 + index * 2} 0 R`).join(" ");
+  objects.push(`<< /Type /Catalog /Pages 2 0 R >>`);
+  objects.push(`<< /Type /Pages /Kids [${kids}] /Count ${laidout.length} >>`);
+  objects.push(`<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>`);
+  for (let pageindex = 0; pageindex < laidout.length; pageindex += 1) {
+    const lines = laidout[pageindex] ?? [];
+    const operators = ["BT", `/F1 ${fontsize} Tf`, `${leading.toFixed(2)} TL`, `${margins.left.toFixed(2)} ${(size.height - margins.top - fontsize).toFixed(2)} Td`];
+    for (let lineindex = 0; lineindex < lines.length; lineindex += 1) {
+      if (lineindex > 0) operators.push("T*");
+      operators.push(`(${pdfescape(lines[lineindex] ?? "")}) Tj`);
+    }
+    operators.push("ET");
+    const content = operators.join("\n");
+    objects.push(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${size.width.toFixed(2)} ${size.height.toFixed(2)}] /Resources << /Font << /F1 3 0 R >> >> /Contents ${5 + pageindex * 2} 0 R >>`);
+    objects.push(`<< /Length ${content.length} >>
+stream
+${content}
+endstream`);
+  }
+  let document = "%PDF-1.4\n";
+  const offsets = [];
+  for (let index = 0; index < objects.length; index += 1) {
+    offsets.push(document.length);
+    document += `${index + 1} 0 obj
+${objects[index]}
+endobj
+`;
+  }
+  const xrefstart = document.length;
+  document += `xref
+0 ${objects.length + 1}
+0000000000 65535 f 
+`;
+  for (const offset of offsets) document += `${String(offset).padStart(10, "0")} 00000 n 
+`;
+  document += `trailer
+<< /Size ${objects.length + 1} /Root 1 0 R >>
+startxref
+${xrefstart}
+%%EOF
+`;
+  return { document, bytes: document.length, pages: laidout.length, pagewidth: Math.round(size.width), pageheight: Math.round(size.height) };
+}
+function recordingoptionsof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const options = value;
+  const normalized = {};
+  if (options.scope === "tab" || options.scope === "run") normalized.scope = options.scope;
+  if (typeof options.fps === "number" && Number.isFinite(options.fps)) normalized.fps = options.fps;
+  if (typeof options.bitrate === "number" && Number.isFinite(options.bitrate)) normalized.bitrate = options.bitrate;
+  if (typeof options.audio === "boolean") normalized.audio = options.audio;
+  return normalized;
+}
+function newrecording(input) {
+  return {
+    id: input.id,
+    runid: input.runid,
+    stepid: input.stepid,
+    tabid: input.tabid,
+    kind: input.kind,
+    scope: input.options.scope ?? "tab",
+    format: input.kind === "audio" ? "evidence" : "frames",
+    startedat: input.at,
+    at: input.at,
+    ...input.options.fps !== void 0 ? { fps: input.options.fps } : {},
+    ...input.options.bitrate !== void 0 ? { bitrate: input.options.bitrate } : {},
+    ...input.options.audio !== void 0 ? { audio: input.options.audio } : {},
+    frames: []
+  };
+}
+function finishrecording(record2, endat) {
+  return { ...record2, endedat: endat, duration: Math.max(0, endat - record2.startedat) };
+}
+function frameinterval(fps) {
+  if (!Number.isFinite(fps) || fps <= 0) return 1e3;
+  return Math.max(1, Math.round(1e3 / fps));
+}
+function imagefilterof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const options = value;
+  const normalized = {};
+  if (typeof options.selector === "string" && options.selector.trim()) normalized.selector = options.selector.trim();
+  if (typeof options.minwidth === "number" && Number.isFinite(options.minwidth)) normalized.minwidth = options.minwidth;
+  if (typeof options.minheight === "number" && Number.isFinite(options.minheight)) normalized.minheight = options.minheight;
+  if (Array.isArray(options.formats) && options.formats.every((item) => typeof item === "string" && item.trim())) normalized.formats = options.formats;
+  return normalized;
+}
+function imagematches(image, filter) {
+  if (filter.minwidth !== void 0 && image.width < filter.minwidth) return false;
+  if (filter.minheight !== void 0 && image.height < filter.minheight) return false;
+  if (filter.formats !== void 0 && filter.formats.length > 0) {
+    const mime = image.mime.toLowerCase();
+    const matches = filter.formats.some((format) => {
+      const wanted = format.toLowerCase().trim();
+      return mime === wanted || mime === `image/${wanted}` || mime.endsWith(`/${wanted}`);
+    });
+    if (!matches) return false;
+  }
+  return true;
+}
+function dedupeimages(images) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const image of images) {
+    if (seen.has(image.url)) continue;
+    seen.add(image.url);
+    unique.push(image);
+  }
+  return unique;
+}
+function imagenames(rule, run, step, count, extension) {
+  const names = [];
+  for (let index = 1; index <= Math.max(0, Math.round(count)); index += 1) names.push(buildname(rule, { run, step, sequence: index, kind: "image" }, extension));
+  return names;
+}
+function lapseplanof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (typeof options.interval !== "number" || !Number.isFinite(options.interval)) return void 0;
+  if (typeof options.duration !== "number" || !Number.isFinite(options.duration)) return void 0;
+  const format = options.format === "jpeg" || options.format === "webp" ? options.format : "png";
+  return { interval: options.interval, duration: options.duration, format };
+}
+function lapseframes(plan) {
+  if (!(plan.interval > 0) || !(plan.duration > 0)) return [];
+  const frames = [];
+  for (let time = 0; time < plan.duration; time += plan.interval) frames.push(Math.round(time));
+  return frames;
+}
+function convertdirectiveof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (options.target !== "png" && options.target !== "jpeg" && options.target !== "webp") return void 0;
+  const normalized = { target: options.target };
+  if (options.source === "png" || options.source === "jpeg" || options.source === "webp") normalized.source = options.source;
+  if (typeof options.quality === "number" && Number.isFinite(options.quality)) normalized.quality = options.quality;
+  return normalized;
+}
+function thumbdirectiveof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const options = value;
+  if (typeof options.size !== "number" || !Number.isFinite(options.size) || options.size <= 0) return void 0;
+  if (options.fit !== "cover" && options.fit !== "contain") return void 0;
+  if (typeof options.suffix !== "string" || !options.suffix.trim()) return void 0;
+  return { size: options.size, fit: options.fit, suffix: options.suffix.trim() };
+}
+function thumbgeometry(source, directive) {
+  const size = Math.max(1, Math.round(directive.size));
+  if (directive.fit === "contain") {
+    const scale2 = Math.min(size / Math.max(1, source.width), size / Math.max(1, source.height));
+    const dw = Math.max(1, Math.round(source.width * scale2));
+    const dh = Math.max(1, Math.round(source.height * scale2));
+    return { sx: 0, sy: 0, sw: source.width, sh: source.height, dx: Math.floor((size - dw) / 2), dy: Math.floor((size - dh) / 2), dw, dh, width: size, height: size };
+  }
+  const scale = Math.max(size / Math.max(1, source.width), size / Math.max(1, source.height));
+  const sw = Math.min(source.width, Math.round(size / scale));
+  const sh = Math.min(source.height, Math.round(size / scale));
+  return { sx: Math.floor((source.width - sw) / 2), sy: Math.floor((source.height - sh) / 2), sw, sh, dx: 0, dy: 0, dw: size, dh: size, width: size, height: size };
+}
+function mediaentries(raw) {
+  return raw.map((entry) => ({
+    url: typeof entry.url === "string" ? entry.url : "",
+    mime: typeof entry.mime === "string" ? entry.mime : "",
+    duration: typeof entry.duration === "number" && Number.isFinite(entry.duration) ? entry.duration : 0,
+    width: typeof entry.width === "number" && Number.isFinite(entry.width) ? Math.round(entry.width) : 0,
+    height: typeof entry.height === "number" && Number.isFinite(entry.height) ? Math.round(entry.height) : 0,
+    codecs: typeof entry.codecs === "string" ? entry.codecs : "",
+    tracks: Array.isArray(entry.tracks) ? entry.tracks.filter((item) => typeof item === "string") : []
+  }));
+}
+function assetentries(raw) {
+  return raw.map((entry) => ({
+    kind: entry.kind === "logo" ? "logo" : "favicon",
+    url: typeof entry.url === "string" ? entry.url : "",
+    bytes: typeof entry.bytes === "number" && Number.isFinite(entry.bytes) ? entry.bytes : 0,
+    ...typeof entry.sizes === "string" && entry.sizes.trim() ? { sizes: entry.sizes.trim() } : {}
+  }));
+}
+function streamsummaries(raw) {
+  return raw.map((entry) => {
+    const tracks = Array.isArray(entry.tracks) ? entry.tracks : [];
+    return {
+      kind: typeof entry.kind === "string" ? entry.kind : "stream",
+      tracks: tracks.length,
+      label: typeof entry.label === "string" ? entry.label : "",
+      live: entry.live === true,
+      detail: tracks.map((track) => {
+        const item = track;
+        return {
+          kind: typeof item.kind === "string" ? item.kind : "",
+          label: typeof item.label === "string" ? item.label : "",
+          ...typeof item.width === "number" && Number.isFinite(item.width) ? { width: Math.round(item.width) } : {},
+          ...typeof item.height === "number" && Number.isFinite(item.height) ? { height: Math.round(item.height) } : {},
+          ...typeof item.framerate === "number" && Number.isFinite(item.framerate) ? { framerate: item.framerate } : {},
+          state: typeof item.state === "string" ? item.state : ""
+        };
+      })
+    };
+  });
+}
+
 // memory.ts
 var sessionmemory = class {
   constructor(adapter) {
@@ -731,24 +1231,136 @@ var sessionmemory = class {
   async getmimefilters() {
     return await this.adapter.get("mimefilters") ?? [];
   }
+  /** Stores one capture record with its bytes and step linkage, replacing the previous record of that id; the user configured capture retention window expires the oldest bytes while the metadata always survives for the audit trail. */
+  async addcapture(record2) {
+    const records = await this.getcaptures();
+    const retention = (await this.getsettings())?.captureretention;
+    const combined = [record2, ...records.filter((item) => item.id !== record2.id)];
+    const stored = retention === void 0 ? combined : combined.map((item, index) => index < retention ? item : expirecapturebytes(item));
+    await this.adapter.set("captures", stored);
+  }
+  /** Returns every stored capture record with its metadata, newest first. */
+  async getcaptures() {
+    return await this.adapter.get("captures") ?? [];
+  }
+  /** Returns one capture record with its bytes by its id. */
+  async getcapture(id) {
+    return (await this.getcaptures()).find((item) => item.id === id);
+  }
+  /** Returns the capture records filtered by run, step and kind. */
+  async listcaptures(filter) {
+    const records = await this.getcaptures();
+    return records.filter((item) => (filter.runid === void 0 || item.runid === filter.runid) && (filter.stepid === void 0 || item.stepid === filter.stepid) && (filter.kind === void 0 || item.kind === filter.kind));
+  }
+  /** Records one before and after shotpair of the run with its action context. */
+  async addpair(pair) {
+    const records = await this.getpairs();
+    await this.adapter.set("capturepairs", [pair, ...records.filter((item) => item.id !== pair.id)]);
+  }
+  /** Returns the shotpairs of one run resolved through their before records, newest first; an absent run returns every pair. */
+  async getpairs(runid) {
+    const records = await this.adapter.get("capturepairs") ?? [];
+    if (runid === void 0) return records;
+    const runs = /* @__PURE__ */ new Map();
+    for (const capture of await this.getcaptures()) runs.set(capture.id, capture.runid);
+    return records.filter((item) => runs.get(item.beforeid) === runid);
+  }
+  /** Stores one media record of the 1.1.41 family with its bytes and step linkage, replacing the previous record of that id; the user configured media retention window expires the oldest bytes while the metadata and the recording index always survive. */
+  async addmedia(record2) {
+    const records = await this.getmediarecords();
+    const retention = (await this.getsettings())?.mediaretention;
+    const combined = [record2, ...records.filter((item) => item.id !== record2.id)];
+    const stored = retention === void 0 ? combined : combined.map((item, index) => index < retention ? item : expiremediabytes(item));
+    await this.adapter.set("media", stored);
+  }
+  /** Returns every stored media record, newest first. */
+  async getmediarecords() {
+    return await this.adapter.get("media") ?? [];
+  }
+  /** Returns the media records filtered by run and kind; an absent filter returns every record. */
+  async listmedia(filter) {
+    const records = await this.getmediarecords();
+    return records.filter((item) => (filter.runid === void 0 || item.runid === filter.runid) && (filter.kind === void 0 || mediakindof(item) === filter.kind));
+  }
+  /** Returns one media record by its id. */
+  async getmediarecord(id) {
+    return (await this.getmediarecords()).find((item) => item.id === id);
+  }
+  /** Returns one recording with its file reference and frame index by its id. */
+  async getrecording(id) {
+    const found = await this.getmediarecord(id);
+    return found !== void 0 && "startedat" in found ? found : void 0;
+  }
+  /** Removes one media record by its id; the audit trail keeps its outcome evidence. */
+  async removemedia(id) {
+    await this.adapter.set("media", (await this.getmediarecords()).filter((item) => item.id !== id));
+  }
+  /** Stores one observed image batch of a downloadimages step, replacing the previous batch of that id. */
+  async addimagebatch(batch) {
+    const records = await this.adapter.get("imagebatches") ?? [];
+    await this.adapter.set("imagebatches", [batch, ...records.filter((item) => item.id !== batch.id)]);
+  }
+  /** Returns every observed image batch with its filter match counts, newest first. */
+  async getimagebatches() {
+    return await this.adapter.get("imagebatches") ?? [];
+  }
+  /** Stores one recording consent decision of an origin, replacing the previous record of that id. */
+  async setrecordingconsent(record2) {
+    const records = (await this.adapter.get("recordingconsents") ?? []).filter((item) => item.id !== record2.id);
+    await this.adapter.set("recordingconsents", [record2, ...records]);
+  }
+  /** Returns every recording consent decision with its prompt and origin, newest first. */
+  async getrecordingconsents() {
+    return await this.adapter.get("recordingconsents") ?? [];
+  }
 };
+function mediakindof(record2) {
+  if ("pages" in record2) return "pdf";
+  if ("startedat" in record2) return "recording";
+  if ("timestamp" in record2) return "frame";
+  if ("context" in record2) return "canvas";
+  if ("tracks" in record2) return "stream";
+  return "asset";
+}
+function expiremediabytes(record2) {
+  if ("dataurl" in record2) {
+    const source = record2;
+    const copy = { ...source };
+    delete copy.dataurl;
+    return { ...copy, bytesexpired: true };
+  }
+  if ("startedat" in record2) {
+    const source = record2;
+    const copy = { ...source };
+    delete copy.bytes;
+    return { ...copy, bytesexpired: true };
+  }
+  return record2;
+}
+function expirecapturebytes(record2) {
+  const { bytes, ...metadata } = record2;
+  void bytes;
+  return { ...metadata, bytesexpired: true };
+}
 function randomid() {
   return crypto.randomUUID();
 }
 
 // policy.ts
-var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts"]);
+var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts", "recordscreen", "captureaudio", "downloadimages"]);
 var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction"]);
-var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance", "verifydownload", "exportnetlog", "namecaptures"]);
+var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance", "verifydownload", "exportnetlog", "namecaptures", "shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet", "capturepdf", "captureframe", "readmedia", "readassets", "probestream", "timelapse", "shotcanvas", "convertimage", "makethumbs"]);
 var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
 var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus", "watchtab"]);
-var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow", "deriveselector", "fingerprintsection", "submitform", "retryform", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "scrapetable", "paginateextract"]);
+var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow", "deriveselector", "fingerprintsection", "submitform", "retryform", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "scrapetable", "paginateextract", "shotelement", "captureframe", "shotcanvas"]);
 var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor", "followlink", "setfragment", "handleauth", "navintent", "openclipboard", "checksafe", "reopentab", "spanav", "duplicatetab", "pintab", "mutetab", "movetab", "movetabwindow", "searchtabs", "badgetab", "attachmeta", "focuswindow", "maximizewindow", "minimizewindow", "restorewindow", "incognitowindow", "asksubmit", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "pausedownload", "resumedownload", "verifydownload", "writeclipboard", "quarantinedownload", "scanvirus"]);
 var tabscommandactions = /* @__PURE__ */ new Set(["querytabs", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "watchtab", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "savelayout", "restorelayout", "findclones", "searchtabs", "badgetab", "attachmeta", "listaudio", "reopenrun", "snapshotsession"]);
 var formactions = /* @__PURE__ */ new Set(["fillform", "filllabel", "fillplaceholder", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "submitform", "readerrors", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "handoffcaptcha", "fillcard", "fillcode", "consentpassword", "skiphoneypot", "detectlogin", "detecttemplate"]);
 var datasetactions = /* @__PURE__ */ new Set(["scrapetable", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "importcsv", "looprows", "transformvalues", "deduperows", "paginateextract", "mergepages", "stamplerows", "previewgrid", "streamdisk", "resumeextract", "logprovenance"]);
 var exportactions = /* @__PURE__ */ new Set(["exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk"]);
 var filesactions = /* @__PURE__ */ new Set(["batchdownload", "pausedownload", "resumedownload", "verifydownload", "interceptmime", "exportnetlog", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "namecaptures", "cleanupartifacts"]);
+var captureactions = /* @__PURE__ */ new Set(["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"]);
+var mediaactions = /* @__PURE__ */ new Set(["capturepdf", "recordscreen", "captureaudio", "captureframe", "downloadimages", "shotcanvas", "probestream", "readmedia", "readassets", "timelapse", "convertimage", "makethumbs"]);
 var fieldkinds = ["text", "email", "phone", "date", "number", "select", "check", "radio", "file", "password", "card", "code"];
 var layoutmutationactions = /* @__PURE__ */ new Set(["grouptabs", "colorgroup", "collapsegroup", "savelayout", "restorelayout"]);
 var groupcolors = ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"];
@@ -805,6 +1417,83 @@ function isexportkind(kind) {
 function isfileskind(kind) {
   return filesactions.has(kind);
 }
+function iscapturekind(kind) {
+  return captureactions.has(kind);
+}
+function capturegate(session, tabid, origin, now) {
+  if (!session || session.stoppedat) return { allowed: false, reason: "No active browser session exists for the capture." };
+  if (session.expiresat <= now) return { allowed: false, reason: "The browser session has expired and cannot capture." };
+  if (session.pausedat) return { allowed: false, reason: "The browser session is paused and cannot capture." };
+  if (session.tabid !== tabid) return { allowed: false, reason: `The capture needs the active tab grant of session tab ${session.tabid} and refuses tab ${tabid}.` };
+  if (!origingranted(session, origin)) return { allowed: false, reason: `The capture of ${origin} needs the session origin grants first.` };
+  return { allowed: true };
+}
+function validatecaptureoptions(value) {
+  if (value === void 0) return { allowed: true };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "The reviewed capture options must be an object in options.capture." };
+  const options = value;
+  if (options.format !== void 0 && options.format !== "png" && options.format !== "jpeg" && options.format !== "webp") return { allowed: false, reason: "The reviewed capture format must be png, jpeg or webp." };
+  if (options.quality !== void 0 && (typeof options.quality !== "number" || !Number.isFinite(options.quality) || options.quality < 0 || options.quality > 100)) return { allowed: false, reason: "The reviewed capture quality must stay between zero and one hundred; any value in that range is the user choice with no code cap." };
+  if (options.pixelratio !== void 0 && (typeof options.pixelratio !== "number" || !Number.isFinite(options.pixelratio) || options.pixelratio < 1)) return { allowed: false, reason: "The reviewed pixel ratio starts at one and climbs to any user configured ceiling with no code ceiling." };
+  if (options.annotate !== void 0 && typeof options.annotate !== "boolean") return { allowed: false, reason: "The reviewed capture annotation flag must be a boolean." };
+  if (options.exporttarget !== void 0 && options.exporttarget !== "memory" && options.exporttarget !== "download" && options.exporttarget !== "clipboard") return { allowed: false, reason: "The reviewed capture export target must be memory, download or clipboard." };
+  return { allowed: true };
+}
+function validateregionrect(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed regionrect with x, y, width and height in css pixels is required in options." };
+  const rect = value;
+  for (const field of ["x", "y", "width", "height"]) {
+    if (typeof rect[field] !== "number" || !Number.isFinite(rect[field])) return { allowed: false, reason: `The reviewed regionrect needs a numeric ${field} in css pixels.` };
+  }
+  if (rect.x < 0 || rect.y < 0) return { allowed: false, reason: "The reviewed regionrect refuses negative coordinates." };
+  if (rect.width <= 0 || rect.height <= 0) return { allowed: false, reason: "The reviewed regionrect needs positive width and height values." };
+  return { allowed: true };
+}
+function validatecapturenaming(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed capturenaming rule with run, step, sequence and kind flags is required." };
+  const rule = value;
+  const segments = ["run", "step", "sequence", "kind"];
+  for (const key of Object.keys(rule)) {
+    if (!segments.includes(key)) return { allowed: false, reason: `The reviewed capturenaming rule refuses the unknown ${key} segment; only run, step, sequence and kind participate.` };
+  }
+  for (const segment of segments) {
+    if (rule[segment] !== void 0 && typeof rule[segment] !== "boolean") return { allowed: false, reason: `The reviewed capturenaming ${segment} flag must be a boolean.` };
+  }
+  if (!segments.some((segment) => rule[segment] === true)) return { allowed: false, reason: "The reviewed capturenaming rule needs at least one enabled segment of run, step, sequence and kind." };
+  return { allowed: true };
+}
+function validatecapturegrammar(step, options) {
+  const kind = step.kind;
+  const optioncheck = validatecaptureoptions(options.capture);
+  if (!optioncheck.allowed) return optioncheck;
+  if (options.settle !== void 0 && (typeof options.settle !== "number" || !Number.isFinite(options.settle) || options.settle < 0)) return { allowed: false, reason: "The reviewed capture settle window must be zero or a positive number of milliseconds." };
+  if (options.overlap !== void 0 && (typeof options.overlap !== "number" || !Number.isInteger(options.overlap) || options.overlap < 0)) return { allowed: false, reason: "The reviewed stitch overlap must be zero or a positive number of rows." };
+  if (options.wait !== void 0 && (typeof options.wait !== "number" || !Number.isFinite(options.wait) || options.wait < 0)) return { allowed: false, reason: "The reviewed capture wait window must be zero or a positive number of milliseconds." };
+  if (options.naming !== void 0) {
+    const namingcheck = validatecapturenaming(options.naming);
+    if (!namingcheck.allowed) return namingcheck;
+  }
+  if (kind === "shotregion") {
+    const rectcheck = validateregionrect(options.regionrect);
+    if (!rectcheck.allowed) return rectcheck;
+    if (options.reviewed !== true) return { allowed: false, reason: "Every reviewed regionrect needs the explicit reviewed flag before shotregion runs." };
+    if (options.container !== void 0 && !isnonempty(options.container)) return { allowed: false, reason: "The reviewed scrollable container selector must be a non-empty string." };
+    if (options.steps !== void 0 && (typeof options.steps !== "number" || !Number.isInteger(options.steps) || options.steps < 1)) return { allowed: false, reason: "The reviewed container scroll steps must be a positive integer with no code ceiling." };
+  }
+  if (kind === "contactsheet") {
+    const elements = options.elements;
+    if (!Array.isArray(elements) || elements.length === 0 || !elements.every((item) => isnonempty(item))) return { allowed: false, reason: "A reviewed non-empty list of element selectors is required in options for the contact sheet; the cell count stays the user choice." };
+    const layout = options.sheet;
+    if (layout !== void 0) {
+      if (!layout || typeof layout !== "object" || Array.isArray(layout)) return { allowed: false, reason: "The reviewed sheetlayout must be an object with cellsize, columns and label." };
+      const sheet = layout;
+      if (typeof sheet.cellsize !== "number" || !Number.isFinite(sheet.cellsize) || sheet.cellsize <= 0) return { allowed: false, reason: "The reviewed contact sheet cell size must be a positive number of pixels." };
+      if (typeof sheet.columns !== "number" || !Number.isInteger(sheet.columns) || sheet.columns < 1) return { allowed: false, reason: "The reviewed contact sheet column count must be a positive integer with no code ceiling." };
+      if (sheet.label !== void 0 && sheet.label !== "none" && sheet.label !== "index" && sheet.label !== "selector" && sheet.label !== "both") return { allowed: false, reason: "The reviewed contact sheet label style must be none, index, selector or both." };
+    }
+  }
+  return { allowed: true };
+}
 function exportgranted(session, origin) {
   if (!origingranted(session, origin)) return { allowed: false, reason: `The export of extracted data from ${origin} needs the session origin grants before it leaves local memory.` };
   return { allowed: true };
@@ -1373,6 +2062,140 @@ function validatetabsgrammar(step, options) {
   if (kind === "reopenrun" && !isnonempty(options.run)) return { allowed: false, reason: "A reviewed run id is required in options to reopen its tabs." };
   return { allowed: true };
 }
+function ismediakind(kind) {
+  return mediaactions.has(kind);
+}
+function isrecordingkind(kind) {
+  return kind === "recordscreen" || kind === "captureaudio";
+}
+function mediagate(session, tabid, origin, now) {
+  if (!session || session.stoppedat) return { allowed: false, reason: "No active browser session exists for the media capture." };
+  if (session.expiresat <= now) return { allowed: false, reason: "The browser session has expired and cannot capture media." };
+  if (session.pausedat) return { allowed: false, reason: "The browser session is paused and cannot capture media." };
+  if (session.tabid !== tabid) return { allowed: false, reason: `The media capture needs the active tab grant of session tab ${session.tabid} and refuses tab ${tabid}.` };
+  if (!origingranted(session, origin)) return { allowed: false, reason: `The media capture of ${origin} needs the session origin grants first.` };
+  return { allowed: true };
+}
+function recordingconsentgranted(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const consentref = options.consentref;
+  if (typeof consentref !== "string" || !consentref.trim()) return { allowed: false, reason: "A recording of user activity requires a reviewed consent ref in options before it starts." };
+  return { allowed: true };
+}
+function lapsebudgetallowed(interval, duration, wait) {
+  if (!(interval > 0)) return { allowed: false, reason: "The reviewed lapse interval must be a positive number of milliseconds." };
+  if (!(duration > 0)) return { allowed: false, reason: "The reviewed lapse duration must be a positive number of milliseconds." };
+  if (wait !== void 0 && !(wait >= 0)) return { allowed: false, reason: "The reviewed wait budget must be zero or a positive number of milliseconds." };
+  if (wait !== void 0 && duration > wait) return { allowed: false, reason: `The lapse duration of ${duration} milliseconds exceeds the reviewed wait budget of ${wait} milliseconds; review a wider budget or a shorter duration.` };
+  return { allowed: true };
+}
+function validatemediagrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "capturepdf") {
+    const pdf = options.pdf;
+    if (pdf !== void 0) {
+      if (!pdf || typeof pdf !== "object" || Array.isArray(pdf)) return { allowed: false, reason: "The reviewed pdf options must be an object in options.pdf." };
+      const pdfoptions = pdf;
+      if (pdfoptions.paperwidth !== void 0 && (typeof pdfoptions.paperwidth !== "number" || !Number.isFinite(pdfoptions.paperwidth) || pdfoptions.paperwidth <= 0)) return { allowed: false, reason: "The reviewed pdf paper width must be a positive number of inches with no code cap." };
+      if (pdfoptions.paperheight !== void 0 && (typeof pdfoptions.paperheight !== "number" || !Number.isFinite(pdfoptions.paperheight) || pdfoptions.paperheight <= 0)) return { allowed: false, reason: "The reviewed pdf paper height must be a positive number of inches with no code cap." };
+      if (pdfoptions.margins !== void 0) {
+        const margins = pdfoptions.margins;
+        if (!margins || typeof margins !== "object" || Array.isArray(margins)) return { allowed: false, reason: "The reviewed pdf margins must be an object with top, right, bottom and left inches." };
+        for (const side of ["top", "right", "bottom", "left"]) {
+          const value = margins[side];
+          if (value === void 0) continue;
+          if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return { allowed: false, reason: `The reviewed pdf ${side} margin must be zero or a positive number of inches; negative margins are refused.` };
+        }
+      }
+      if (pdfoptions.scale !== void 0 && (typeof pdfoptions.scale !== "number" || !Number.isFinite(pdfoptions.scale) || pdfoptions.scale <= 0)) return { allowed: false, reason: "The reviewed pdf scale must be a positive number with no code cap." };
+      if (pdfoptions.landscape !== void 0 && typeof pdfoptions.landscape !== "boolean") return { allowed: false, reason: "The reviewed pdf landscape flag must be a boolean." };
+      if (pdfoptions.paginate !== void 0 && typeof pdfoptions.paginate !== "boolean") return { allowed: false, reason: "The reviewed pdf paginate flag must be a boolean." };
+    }
+    if (options.breakpoints !== void 0 && (!Array.isArray(options.breakpoints) || options.breakpoints.length === 0 || !options.breakpoints.every((item) => isnonempty(item)))) return { allowed: false, reason: "The reviewed pdf break points must be a non-empty list of selectors when present." };
+    if (options.exporttarget !== void 0 && options.exporttarget !== "memory" && options.exporttarget !== "download") return { allowed: false, reason: "The reviewed pdf export target must be memory or download; pdf documents do not route to the clipboard." };
+    if (options.name !== void 0 && !isnonempty(options.name)) return { allowed: false, reason: "The reviewed pdf artifact name must be a non-empty string." };
+  }
+  if (kind === "recordscreen" || kind === "captureaudio") {
+    const recording = options.recording;
+    if (recording !== void 0) {
+      if (!recording || typeof recording !== "object" || Array.isArray(recording)) return { allowed: false, reason: "The reviewed recording options must be an object in options.recording." };
+      const recordoptions = recording;
+      if (recordoptions.scope !== void 0 && recordoptions.scope !== "tab" && recordoptions.scope !== "run") return { allowed: false, reason: "The reviewed recording scope must be tab or run." };
+      if (recordoptions.fps !== void 0 && (typeof recordoptions.fps !== "number" || !Number.isFinite(recordoptions.fps) || recordoptions.fps <= 0)) return { allowed: false, reason: "The reviewed recording fps must be a positive number with no code ceiling." };
+      if (recordoptions.bitrate !== void 0 && (typeof recordoptions.bitrate !== "number" || !Number.isFinite(recordoptions.bitrate) || recordoptions.bitrate <= 0)) return { allowed: false, reason: "The reviewed recording bitrate must be a positive number with no code ceiling." };
+      if (recordoptions.audio !== void 0 && typeof recordoptions.audio !== "boolean") return { allowed: false, reason: "The reviewed recording audio flag must be a boolean." };
+    }
+    if (options.duration !== void 0 && (typeof options.duration !== "number" || !Number.isFinite(options.duration) || options.duration <= 0)) return { allowed: false, reason: "The reviewed recording duration must be a positive number of milliseconds with no code ceiling." };
+    const consent = recordingconsentgranted(step);
+    if (!consent.allowed) return consent;
+  }
+  if (kind === "captureframe") {
+    if (options.timestamp !== void 0 && (typeof options.timestamp !== "number" || !Number.isFinite(options.timestamp) || options.timestamp < 0)) return { allowed: false, reason: "The reviewed frame timestamp must be zero or a positive number of seconds." };
+    if (options.poster !== void 0 && typeof options.poster !== "boolean") return { allowed: false, reason: "The reviewed poster flag must be a boolean." };
+    const capturecheck = validatecaptureoptions(options.capture);
+    if (!capturecheck.allowed) return capturecheck;
+  }
+  if (kind === "downloadimages") {
+    const filter = options.imagefilter;
+    if (!filter || typeof filter !== "object" || Array.isArray(filter)) return { allowed: false, reason: "A reviewed imagefilter is required in options before any image downloads." };
+    const imagefilter = filter;
+    if (imagefilter.selector !== void 0 && !isnonempty(imagefilter.selector)) return { allowed: false, reason: "The reviewed imagefilter selector must be a non-empty selector from the reviewed selector grammar." };
+    if (imagefilter.minwidth !== void 0 && (typeof imagefilter.minwidth !== "number" || !Number.isFinite(imagefilter.minwidth) || imagefilter.minwidth < 0)) return { allowed: false, reason: "The reviewed imagefilter minimum width must be zero or a positive number of pixels." };
+    if (imagefilter.minheight !== void 0 && (typeof imagefilter.minheight !== "number" || !Number.isFinite(imagefilter.minheight) || imagefilter.minheight < 0)) return { allowed: false, reason: "The reviewed imagefilter minimum height must be zero or a positive number of pixels." };
+    if (imagefilter.formats !== void 0 && (!Array.isArray(imagefilter.formats) || imagefilter.formats.length === 0 || !imagefilter.formats.every((item) => isnonempty(item)))) return { allowed: false, reason: "The reviewed imagefilter format list must be a non-empty list of mime or extension patterns when present." };
+    if (options.naming !== void 0) {
+      const namingcheck = validatecapturenaming(options.naming);
+      if (!namingcheck.allowed) return namingcheck;
+    }
+  }
+  if (kind === "shotcanvas") {
+    const capturecheck = validatecaptureoptions(options.capture);
+    if (!capturecheck.allowed) return capturecheck;
+  }
+  if (kind === "probestream" && options.selector !== void 0 && !isnonempty(options.selector)) return { allowed: false, reason: "The reviewed stream probe scope selector must be a non-empty string." };
+  if (kind === "timelapse") {
+    const lapse = options.lapse;
+    if (!lapse || typeof lapse !== "object" || Array.isArray(lapse)) return { allowed: false, reason: "A reviewed lapse plan with interval, duration and format is required in options." };
+    const plan = lapse;
+    if (typeof plan.interval !== "number" || !Number.isFinite(plan.interval) || plan.interval <= 0) return { allowed: false, reason: "The reviewed lapse interval must be a positive number of milliseconds with no code ceiling." };
+    if (typeof plan.duration !== "number" || !Number.isFinite(plan.duration) || plan.duration <= 0) return { allowed: false, reason: "The reviewed lapse duration must be a positive number of milliseconds with no code ceiling." };
+    if (plan.format !== void 0 && plan.format !== "png" && plan.format !== "jpeg" && plan.format !== "webp") return { allowed: false, reason: "The reviewed lapse format must be png, jpeg or webp." };
+    const budget = lapsebudgetallowed(plan.interval, plan.duration, typeof options.wait === "number" ? options.wait : void 0);
+    if (!budget.allowed) return budget;
+    const capturecheck = validatecaptureoptions(options.capture);
+    if (!capturecheck.allowed) return capturecheck;
+  }
+  if (kind === "convertimage" || kind === "makethumbs") {
+    const single = options.capture;
+    const list = options.captures;
+    const hasone = isnonempty(single);
+    const haslist = Array.isArray(list) && list.length > 0 && list.every((item) => isnonempty(item));
+    if (!hasone && !haslist) return { allowed: false, reason: "A reviewed capture id or a reviewed non-empty capture id list is required in options." };
+    if (hasone && haslist) return { allowed: false, reason: "The reviewed step needs one capture id or a capture id list, not both." };
+  }
+  if (kind === "convertimage") {
+    const convert = options.convert;
+    if (!convert || typeof convert !== "object" || Array.isArray(convert)) return { allowed: false, reason: "A reviewed convert directive with a target format is required in options." };
+    const directive = convert;
+    if (directive.target !== "png" && directive.target !== "jpeg" && directive.target !== "webp") return { allowed: false, reason: "The reviewed conversion target must be png, jpeg or webp." };
+    if (directive.source !== void 0 && directive.source !== "png" && directive.source !== "jpeg" && directive.source !== "webp") return { allowed: false, reason: "The reviewed conversion source must be png, jpeg or webp." };
+    if (directive.quality !== void 0 && (typeof directive.quality !== "number" || !Number.isFinite(directive.quality) || directive.quality < 0 || directive.quality > 100)) return { allowed: false, reason: "The reviewed conversion quality must stay between zero and one hundred with no code cap inside that range." };
+  }
+  if (kind === "makethumbs") {
+    const thumb = options.thumb;
+    if (!thumb || typeof thumb !== "object" || Array.isArray(thumb)) return { allowed: false, reason: "A reviewed thumb directive with size, fit and suffix is required in options." };
+    const directive = thumb;
+    if (typeof directive.size !== "number" || !Number.isFinite(directive.size) || directive.size <= 0) return { allowed: false, reason: "The reviewed thumbnail size must be a positive number of pixels with no fixed set." };
+    if (directive.fit !== "cover" && directive.fit !== "contain") return { allowed: false, reason: "The reviewed thumbnail fit must be cover or contain." };
+    if (!isnonempty(directive.suffix)) return { allowed: false, reason: "The reviewed thumbnail naming suffix must be a non-empty string." };
+  }
+  return { allowed: true };
+}
 function validatestep(step, origin) {
   if (!allowedactions.has(step.kind)) return { allowed: false, reason: "Unsupported action kind." };
   if (!step.summary.trim()) return { allowed: false, reason: "A human-readable action summary is required." };
@@ -1590,6 +2413,14 @@ function validatestep(step, origin) {
     const filescheck = validatefilesgrammar(step, options);
     if (!filescheck.allowed) return filescheck;
   }
+  if (iscapturekind(step.kind)) {
+    const capturecheck = validatecapturegrammar(step, options);
+    if (!capturecheck.allowed) return capturecheck;
+  }
+  if (ismediakind(step.kind)) {
+    const mediacheck = validatemediagrammar(step, options);
+    if (!mediacheck.allowed) return mediacheck;
+  }
   if (step.kind === "tabcreate") {
     if (options.background !== void 0 && typeof options.background !== "boolean") return { allowed: false, reason: "The reviewed background flag must be a boolean." };
     if (options.window !== void 0 && (typeof options.window !== "number" || !Number.isInteger(options.window) || options.window < 0)) return { allowed: false, reason: "The reviewed target window id must be a non-negative integer." };
@@ -1649,6 +2480,26 @@ function canexecute(input) {
     if (!clipgate.allowed) return clipgate;
   }
   if (input.step.kind === "interceptmime" && !origingranted(input.session, input.origin)) return { allowed: false, reason: "The download interception is outside the session origin grants." };
+  if (iscapturekind(input.step.kind)) {
+    const capturegatecheck = capturegate(input.session, input.tabid, input.origin, now);
+    if (!capturegatecheck.allowed) return capturegatecheck;
+    let captureoptions = {};
+    try {
+      captureoptions = parseoptions(input.step);
+    } catch {
+      captureoptions = {};
+    }
+    const target = captureoptions.capture?.exporttarget;
+    if (target !== void 0 && target !== "memory" && target !== "download" && target !== "clipboard") return { allowed: false, reason: "The capture export target must be memory, download or clipboard." };
+  }
+  if (ismediakind(input.step.kind)) {
+    const mediagatecheck = mediagate(input.session, input.tabid, input.origin, now);
+    if (!mediagatecheck.allowed) return mediagatecheck;
+  }
+  if (isrecordingkind(input.step.kind)) {
+    const recordinggate = recordingconsentgranted(input.step);
+    if (!recordinggate.allowed) return recordinggate;
+  }
   if (input.step.kind === "openlink" || input.step.kind === "openprivate" || input.step.kind === "batchopen" || input.step.kind === "prefetch" || input.step.kind === "deeplink" || input.step.kind === "reopentab") {
     let options = {};
     try {
@@ -1670,7 +2521,7 @@ function canexecute(input) {
 }
 
 // version.ts
-var packageversion = "1.1.39";
+var packageversion = "1.1.41";
 
 // types.ts
 var protocolversion = packageversion;
@@ -1734,7 +2585,7 @@ function requestbody(input) {
   return JSON.stringify({ version: protocolversion, objective: input.objective, session: input.session, observation: input.observation, capabilities: input.capabilities });
 }
 function outcomeresponse(input) {
-  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, outcome: input.outcome, ...input.resolvedtarget ? { resolvedtarget: input.resolvedtarget } : {} });
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, outcome: input.outcome, ...input.resolvedtarget ? { resolvedtarget: input.resolvedtarget } : {}, ...input.capture ? { capture: input.capture } : {}, ...input.media ? { media: input.media } : {} });
 }
 function mapresponse(input) {
   return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, map: input.map });
@@ -1811,44 +2662,95 @@ function netlogreport(input) {
 function quarantinereport(input) {
   return { version: protocolversion, entries: input.entries };
 }
+function capturereport(input) {
+  return { version: protocolversion, records: input.records, pairs: input.pairs };
+}
+function mediareport(input) {
+  return { version: protocolversion, records: input.records, images: input.images };
+}
 export {
+  annotationplanof,
+  assetentries,
+  blendrows,
+  buildname,
+  buildpdf,
+  buildsheet,
+  buildstitchplan,
   canexecute,
+  captureelement,
+  captureformats,
+  capturekinds,
+  captureoptionsof,
+  captureregion,
+  capturereport,
+  capturestates,
+  capturestitched,
+  capturetargets,
+  capturevisible,
+  convertdirectiveof,
+  croprect,
+  crossesviewport,
   datasetresponse,
+  dedupeimages,
   actionrisk as deriveactionrisk,
   diffresponse,
   downloadreport,
   errorreportresponse,
   eventresponse,
   extractionreport,
+  finishrecording,
+  fixedheadermatch,
   formreportresponse,
+  frameinterval,
   generatedvalueallowed,
   heldkeysreport,
   hostpattern,
+  imagefilterof,
+  imagematches,
+  imagenames,
   isformkind,
   iswatchkind,
+  lapseframes,
+  lapseplanof,
   layoutreport,
   mapresponse,
+  mediaentries,
+  mediakinds,
+  mediareport,
   navstateresponse,
   netlogreport,
+  newrecording,
   normalizeendpoint,
   observationmodeof,
   observationresponse,
   outcomeresponse,
+  pairstates,
   parseproposal,
   passwordconsentgranted,
+  pdfoptionsof,
+  pdfpagesize,
+  pdfsegments,
+  pdftextlayout,
   profilegrantgranted,
   protocolversion,
   provenancereport,
   quarantinereport,
   randomid,
+  recordingoptionsof,
+  regionsteps,
   requestbody,
   resolutionverdict,
   safetyresponse,
+  scaledrect,
+  seamweights,
   selectorresponse,
   sessionmemory,
   signalsreport,
+  streamsummaries,
   submitreviewgranted,
   tabreportresponse,
+  thumbdirectiveof,
+  thumbgeometry,
   trailreport,
   transformgrammar,
   validatefieldmatch,