electron-snapora 1.0.1

package/dist/main/index.mjs

@@ -0,0 +1,1599 @@
+// node_modules/.pnpm/tsup@8.5.1_jiti@2.7.0_postc_3ddeda64d5f52f6813db2d2873a3e4a1/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/electron/main/screenshot-manager.ts
+import { randomUUID } from "crypto";
+import { ipcMain as electronIpcMain, webContents as webContents2 } from "electron";
+
+// src/electron/main/diagnostics.ts
+function emitScreenshotDiagnostic(listener, event) {
+  try {
+    listener?.(event);
+  } catch {
+  }
+}
+
+// src/electron/main/electron-capture-adapter.ts
+import { desktopCapturer, screen, systemPreferences } from "electron";
+
+// src/electron/protocol/limits.ts
+var DEFAULT_SCREENSHOT_RESOURCE_LIMITS = Object.freeze({
+  maxCapturePixels: 64 * 1024 * 1024,
+  maxCaptureDataUrlBytes: 192 * 1024 * 1024,
+  maxOutputBytes: 64 * 1024 * 1024
+});
+var HARD_SCREENSHOT_RESOURCE_LIMITS = Object.freeze({
+  maxCapturePixels: 128 * 1024 * 1024,
+  maxCaptureDataUrlBytes: 256 * 1024 * 1024,
+  maxOutputBytes: 256 * 1024 * 1024
+});
+function resolveScreenshotResourceLimits(options = {}) {
+  return {
+    maxCapturePixels: resolveLimit("maxCapturePixels", options.maxCapturePixels),
+    maxCaptureDataUrlBytes: resolveLimit(
+      "maxCaptureDataUrlBytes",
+      options.maxCaptureDataUrlBytes
+    ),
+    maxOutputBytes: resolveLimit("maxOutputBytes", options.maxOutputBytes)
+  };
+}
+function findCapturedFrameLimitViolation(frame, limits) {
+  const { width, height } = frame.pixelSize;
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0 || width * height > limits.maxCapturePixels) {
+    return `Captured frame exceeds the ${limits.maxCapturePixels} pixel limit.`;
+  }
+  if (frame.dataUrl.length > limits.maxCaptureDataUrlBytes) {
+    return `Captured frame exceeds the ${limits.maxCaptureDataUrlBytes} byte Data URL limit.`;
+  }
+  return void 0;
+}
+function resolveLimit(key, configuredValue) {
+  const value = configuredValue ?? DEFAULT_SCREENSHOT_RESOURCE_LIMITS[key];
+  if (!Number.isSafeInteger(value) || value <= 0 || value > HARD_SCREENSHOT_RESOURCE_LIMITS[key]) {
+    throw new TypeError(
+      `[electron-snapora] ${key} must be a positive safe integer no greater than ${HARD_SCREENSHOT_RESOURCE_LIMITS[key]}.`
+    );
+  }
+  return value;
+}
+
+// src/electron/main/errors.ts
+var ScreenshotError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "ScreenshotError";
+    this.code = code;
+  }
+};
+function toScreenshotFailure(error, fallbackCode = "CAPTURE_FAILED") {
+  if (error instanceof ScreenshotError) {
+    return {
+      status: "failed",
+      code: error.code,
+      message: error.message
+    };
+  }
+  return {
+    status: "failed",
+    code: fallbackCode,
+    message: error instanceof Error ? error.message : "Unknown screenshot error."
+  };
+}
+
+// src/electron/main/electron-capture-adapter.ts
+var ElectronCaptureAdapter = class {
+  #desktopCapturer;
+  #screen;
+  #platform;
+  #getScreenPermissionStatus;
+  #resourceLimits;
+  constructor(options = {}) {
+    this.#desktopCapturer = options.desktopCapturer ?? desktopCapturer;
+    this.#screen = options.screen ?? screen;
+    this.#platform = options.platform ?? process.platform;
+    this.#getScreenPermissionStatus = options.getScreenPermissionStatus ?? (() => systemPreferences.getMediaAccessStatus("screen"));
+    this.#resourceLimits = resolveScreenshotResourceLimits(options.resourceLimits);
+  }
+  resolveTargetDisplay(options = {}) {
+    this.#assertPermission();
+    return this.#toCaptureDisplay(this.#resolveDisplay(options.display ?? "cursor"));
+  }
+  async capture(options = {}, targetDisplay) {
+    this.#assertPermission();
+    const display = targetDisplay ? this.#resolveDisplay(targetDisplay.id) : this.#resolveDisplay(options.display ?? "cursor");
+    const pixelSize = {
+      width: Math.max(1, Math.round(display.bounds.width * display.scaleFactor)),
+      height: Math.max(1, Math.round(display.bounds.height * display.scaleFactor))
+    };
+    this.#assertRequestedPixelSize(pixelSize);
+    let sources;
+    try {
+      sources = await this.#desktopCapturer.getSources({
+        types: ["screen"],
+        thumbnailSize: pixelSize,
+        fetchWindowIcons: false
+      });
+    } catch (error) {
+      this.#assertPermission();
+      throw new ScreenshotError(
+        "CAPTURE_FAILED",
+        "Electron failed to capture the screen.",
+        {
+          cause: error
+        }
+      );
+    }
+    const source = sources.find(
+      (candidate) => candidate.display_id === String(display.id)
+    );
+    if (!source) {
+      this.#assertPermission();
+      throw new ScreenshotError(
+        "DISPLAY_NOT_FOUND",
+        `No desktop capture source matched display ${display.id}.`
+      );
+    }
+    if (source.thumbnail.isEmpty()) {
+      this.#assertPermission();
+      throw new ScreenshotError(
+        "CAPTURE_FAILED",
+        "Electron returned an empty screen image."
+      );
+    }
+    const actualPixelSize = source.thumbnail.getSize();
+    if (actualPixelSize.width <= 0 || actualPixelSize.height <= 0) {
+      throw new ScreenshotError(
+        "CAPTURE_FAILED",
+        "Electron returned an invalid screen image size."
+      );
+    }
+    const frame = {
+      display: this.#toCaptureDisplay(display),
+      dataUrl: source.thumbnail.toDataURL(),
+      pixelSize: actualPixelSize
+    };
+    const violation = findCapturedFrameLimitViolation(frame, this.#resourceLimits);
+    if (violation) {
+      throw new ScreenshotError("RESOURCE_LIMIT_EXCEEDED", violation);
+    }
+    return [frame];
+  }
+  #assertRequestedPixelSize(pixelSize) {
+    if (pixelSize.width * pixelSize.height > this.#resourceLimits.maxCapturePixels) {
+      throw new ScreenshotError(
+        "RESOURCE_LIMIT_EXCEEDED",
+        `Requested capture exceeds the ${this.#resourceLimits.maxCapturePixels} pixel limit.`
+      );
+    }
+  }
+  #assertPermission() {
+    if (this.#platform !== "darwin") {
+      return;
+    }
+    const status = this.#getScreenPermissionStatus();
+    if (status === "denied" || status === "restricted") {
+      throw new ScreenshotError(
+        "PERMISSION_DENIED",
+        "Screen recording permission is required to capture the display."
+      );
+    }
+  }
+  #resolveDisplay(requestedDisplay) {
+    if (requestedDisplay === "cursor") {
+      return this.#screen.getDisplayNearestPoint(this.#screen.getCursorScreenPoint());
+    }
+    if (requestedDisplay === "primary") {
+      return this.#screen.getPrimaryDisplay();
+    }
+    const display = this.#screen.getAllDisplays().find((candidate) => String(candidate.id) === requestedDisplay);
+    if (!display) {
+      throw new ScreenshotError(
+        "DISPLAY_NOT_FOUND",
+        `Display ${requestedDisplay} is not available.`
+      );
+    }
+    return display;
+  }
+  #toCaptureDisplay(display) {
+    return {
+      id: String(display.id),
+      bounds: { ...display.bounds },
+      scaleFactor: display.scaleFactor
+    };
+  }
+};
+
+// src/electron/main/electron-output-adapter.ts
+import { writeFile } from "fs/promises";
+import { BrowserWindow, clipboard, dialog, nativeImage, webContents } from "electron";
+var ElectronOutputAdapter = class {
+  #saveFile;
+  #copyImage;
+  #createSuggestedName;
+  constructor(options = {}) {
+    this.#saveFile = options.saveFile ?? savePngWithDialog;
+    this.#copyImage = options.copyImage ?? copyPngToClipboard;
+    this.#createSuggestedName = options.createSuggestedName ?? createSuggestedName;
+  }
+  async execute(payload, context) {
+    if (payload.action === "copy") {
+      this.#copyImage(payload.result.data);
+      return { status: "completed", action: "copy" };
+    }
+    const filePath = await this.#saveFile(
+      payload.result.data,
+      this.#createSuggestedName(),
+      context.senderWebContentsId
+    );
+    return filePath ? { status: "completed", action: "save", filePath } : { status: "cancelled" };
+  }
+};
+async function savePngWithDialog(data, suggestedName, senderWebContentsId) {
+  const sender = webContents.fromId(senderWebContentsId);
+  const owner = sender ? BrowserWindow.fromWebContents(sender) : null;
+  const options = {
+    title: "Save screenshot",
+    defaultPath: suggestedName,
+    filters: [{ name: "PNG image", extensions: ["png"] }],
+    properties: ["createDirectory", "showOverwriteConfirmation"]
+  };
+  const result = owner ? await dialog.showSaveDialog(owner, options) : await dialog.showSaveDialog(options);
+  if (result.canceled || !result.filePath) {
+    return void 0;
+  }
+  await writeFile(result.filePath, data);
+  return result.filePath;
+}
+function copyPngToClipboard(data) {
+  const image = nativeImage.createFromBuffer(Buffer.from(data));
+  if (image.isEmpty()) {
+    throw new Error("The exported PNG could not be decoded for the clipboard.");
+  }
+  clipboard.writeImage(image);
+}
+function createSuggestedName() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replace(/\.\d{3}Z$/, "");
+  return `screenshot-${timestamp}.png`;
+}
+
+// src/electron/main/overlay-window.ts
+import { BrowserWindow as BrowserWindow2 } from "electron";
+
+// src/electron/protocol/channels.ts
+var DEFAULT_HOST_CAPTURE_CHANNEL = "electron-snapora:host:capture";
+var DEFAULT_HOST_CANCEL_CHANNEL = "electron-snapora:host:cancel";
+var OVERLAY_CHANNELS = {
+  ready: "electron-snapora:overlay:ready",
+  prepared: "electron-snapora:overlay:prepared",
+  initialize: "electron-snapora:overlay:initialize",
+  feedback: "electron-snapora:overlay:feedback",
+  feedbackReady: "electron-snapora:overlay:feedback-ready",
+  confirm: "electron-snapora:overlay:confirm",
+  cancel: "electron-snapora:overlay:cancel",
+  error: "electron-snapora:overlay:error",
+  output: "electron-snapora:overlay:output"
+};
+
+// src/electron/main/resource-paths.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+var PackagedResourceError = class extends Error {
+  missingResources;
+  constructor(missingResources) {
+    const details = missingResources.map((resource) => `${resource.label}: ${resource.path}`).join("; ");
+    super(
+      `[electron-snapora] Packaged resource missing (${details}). Keep electron-snapora external in the Electron main-process bundle and include its complete dist directory in the application package.`
+    );
+    this.name = "PackagedResourceError";
+    this.missingResources = missingResources.map((resource) => ({ ...resource }));
+  }
+};
+function resolveOverlayResources(mainModuleDirectory = __dirname, resourceExists = existsSync) {
+  const overlayDirectory = resolve(mainModuleDirectory, "..", "overlay");
+  const resources = {
+    htmlPath: resolve(overlayDirectory, "index.html"),
+    preloadPath: resolve(overlayDirectory, "preload.cjs")
+  };
+  assertOverlayResources(resources, resourceExists);
+  return resources;
+}
+function resolveHostPreloadPath(mainModuleDirectory = __dirname, resourceExists = existsSync) {
+  const preloadPath = resolve(mainModuleDirectory, "..", "preload", "auto.cjs");
+  assertPackagedResources(
+    [{ label: "host preload", path: preloadPath }],
+    resourceExists
+  );
+  return preloadPath;
+}
+function assertOverlayResources(resources, resourceExists = existsSync) {
+  assertPackagedResources(
+    [
+      { label: "overlay HTML", path: resources.htmlPath },
+      { label: "overlay preload", path: resources.preloadPath }
+    ],
+    resourceExists
+  );
+}
+function assertPackagedResources(resources, resourceExists) {
+  const missing = resources.filter((resource) => !resourceExists(resource.path));
+  if (missing.length === 0) {
+    return;
+  }
+  throw new PackagedResourceError(missing);
+}
+
+// src/electron/main/overlay-window.ts
+var OverlayWindow = class {
+  #resources;
+  #window;
+  #createWindow;
+  #bounds;
+  #platform;
+  #supportsInvisiblePriming;
+  #primed = false;
+  #feedbackWindow;
+  #feedbackTimer;
+  constructor(options) {
+    this.#resources = options.resources ?? resolveOverlayResources(void 0, options.resourceExists);
+    assertOverlayResources(this.#resources, options.resourceExists);
+    this.#createWindow = options.createWindow ?? ((windowOptions) => new BrowserWindow2(windowOptions));
+    const { bounds } = options.display;
+    this.#bounds = bounds;
+    this.#platform = options.platform ?? process.platform;
+    this.#supportsInvisiblePriming = ["win32", "darwin"].includes(this.#platform);
+    this.#window = this.#createWindow({
+      x: bounds.x,
+      y: bounds.y,
+      width: bounds.width,
+      height: bounds.height,
+      useContentSize: true,
+      frame: false,
+      hasShadow: false,
+      resizable: false,
+      movable: false,
+      minimizable: false,
+      maximizable: false,
+      // macOS 简易全屏要求窗口具备全屏能力；无边框窗口没有可供用户切换的系统按钮。
+      fullscreenable: this.#platform === "darwin",
+      skipTaskbar: true,
+      alwaysOnTop: true,
+      transparent: false,
+      show: false,
+      opacity: this.#supportsInvisiblePriming ? 0 : 1,
+      paintWhenInitiallyHidden: true,
+      autoHideMenuBar: true,
+      backgroundColor: "#000000",
+      ...this.#platform === "win32" ? { roundedCorners: false, thickFrame: false } : {},
+      ...this.#platform === "darwin" ? {
+        enableLargerThanScreen: true,
+        hiddenInMissionControl: true,
+        simpleFullscreen: true
+      } : {},
+      webPreferences: {
+        preload: this.#resources.preloadPath,
+        nodeIntegration: false,
+        contextIsolation: true,
+        sandbox: true,
+        zoomFactor: 1
+      }
+    });
+    this.#configureMacWorkspaceVisibility(this.#window);
+  }
+  get webContentsId() {
+    return this.#window.webContents.id;
+  }
+  async load() {
+    await this.#window.loadFile(this.#resources.htmlPath);
+  }
+  sendInitialize(payload) {
+    this.#window.webContents.send(OVERLAY_CHANNELS.initialize, payload);
+  }
+  /** 先以全透明状态进入桌面合成器，隐藏 Windows/macOS 的窗口出场和大图首帧栅格化。 */
+  prime() {
+    if (!this.#window.isDestroyed() && this.#supportsInvisiblePriming) {
+      this.#raiseAboveOtherWindows();
+      this.#window.showInactive();
+      if (this.#platform !== "darwin") {
+        this.#window.setBounds(this.#bounds, false);
+      }
+      this.#window.moveTop();
+      this.#primed = true;
+    }
+  }
+  reveal() {
+    if (this.#window.isDestroyed()) {
+      return;
+    }
+    this.#raiseAboveOtherWindows();
+    if (this.#primed) {
+      this.#window.setOpacity(1);
+      this.#window.focus();
+    } else {
+      this.#window.show();
+    }
+    this.#window.moveTop();
+  }
+  /** 复制完成后销毁全屏截图层，改用独立的小窗口显示鼠标穿透提示。 */
+  showCopyFeedback(durationMs, options) {
+    if (!this.#window.isDestroyed()) {
+      this.#window.destroy();
+    }
+    this.#destroyFeedbackWindow();
+    const width = Math.min(360, this.#bounds.width);
+    const height = Math.min(72, this.#bounds.height);
+    const feedbackWindow = this.#createWindow({
+      x: this.#bounds.x + Math.round((this.#bounds.width - width) / 2),
+      y: this.#bounds.y + Math.min(24, Math.max(0, this.#bounds.height - height)),
+      width,
+      height,
+      useContentSize: true,
+      frame: false,
+      hasShadow: false,
+      resizable: false,
+      movable: false,
+      minimizable: false,
+      maximizable: false,
+      fullscreenable: false,
+      focusable: false,
+      skipTaskbar: true,
+      alwaysOnTop: true,
+      transparent: true,
+      show: false,
+      paintWhenInitiallyHidden: true,
+      autoHideMenuBar: true,
+      backgroundColor: "#00000000",
+      webPreferences: {
+        preload: this.#resources.preloadPath,
+        nodeIntegration: false,
+        contextIsolation: true,
+        sandbox: true,
+        zoomFactor: 1
+      }
+    });
+    this.#feedbackWindow = feedbackWindow;
+    this.#configureMacWorkspaceVisibility(feedbackWindow);
+    feedbackWindow.setIgnoreMouseEvents(true);
+    const handleIpcMessage = (_event, channel) => {
+      if (channel !== OVERLAY_CHANNELS.feedbackReady) {
+        return;
+      }
+      feedbackWindow.webContents.removeListener("ipc-message", handleIpcMessage);
+      if (feedbackWindow.isDestroyed() || this.#feedbackWindow !== feedbackWindow) {
+        return;
+      }
+      this.#clearFeedbackTimer();
+      this.#raiseAboveOtherWindows(feedbackWindow);
+      feedbackWindow.showInactive();
+      feedbackWindow.moveTop();
+      this.#feedbackTimer = setTimeout(
+        () => this.#destroyFeedbackWindow(feedbackWindow),
+        durationMs
+      );
+      this.#feedbackTimer.unref?.();
+    };
+    feedbackWindow.webContents.on("ipc-message", handleIpcMessage);
+    this.#feedbackTimer = setTimeout(
+      () => this.#destroyFeedbackWindow(feedbackWindow),
+      2e3
+    );
+    this.#feedbackTimer.unref?.();
+    void feedbackWindow.loadFile(this.#resources.htmlPath).then(() => {
+      if (!feedbackWindow.isDestroyed() && this.#feedbackWindow === feedbackWindow) {
+        feedbackWindow.webContents.send(OVERLAY_CHANNELS.feedback, {
+          kind: "copy",
+          durationMs,
+          options
+        });
+      }
+    }).catch(() => this.#destroyFeedbackWindow(feedbackWindow));
+  }
+  /** 截图层必须高于普通置顶窗口；Windows/macOS 使用系统支持的最高标准层级。 */
+  #raiseAboveOtherWindows(window = this.#window) {
+    if (this.#platform === "win32" || this.#platform === "darwin") {
+      window.setAlwaysOnTop(true, "screen-saver");
+      return;
+    }
+    window.setAlwaysOnTop(true);
+  }
+  /** 让截图层和复制提示在 macOS 全屏 Space 中也保持可见。 */
+  #configureMacWorkspaceVisibility(window) {
+    if (this.#platform === "darwin") {
+      window.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+    }
+  }
+  destroy() {
+    this.#destroyFeedbackWindow();
+    if (!this.#window.isDestroyed()) {
+      this.#window.destroy();
+    }
+  }
+  #clearFeedbackTimer() {
+    if (this.#feedbackTimer) {
+      clearTimeout(this.#feedbackTimer);
+      this.#feedbackTimer = void 0;
+    }
+  }
+  #destroyFeedbackWindow(window = this.#feedbackWindow) {
+    this.#clearFeedbackTimer();
+    if (window && !window.isDestroyed()) {
+      window.destroy();
+    }
+    if (this.#feedbackWindow === window) {
+      this.#feedbackWindow = void 0;
+    }
+  }
+  onClosed(listener) {
+    this.#window.on("closed", listener);
+    return () => {
+      if (!this.#window.isDestroyed()) {
+        this.#window.removeListener("closed", listener);
+      }
+    };
+  }
+  onRendererGone(listener) {
+    const handleGone = () => {
+      listener();
+    };
+    this.#window.webContents.on("render-process-gone", handleGone);
+    return () => {
+      if (!this.#window.isDestroyed()) {
+        this.#window.webContents.removeListener("render-process-gone", handleGone);
+      }
+    };
+  }
+};
+
+// src/electron/protocol/messages.ts
+var SCREENSHOT_PROTOCOL_VERSION = 1;
+
+// src/electron/protocol/validators.ts
+var SCREENSHOT_ERROR_CODES = /* @__PURE__ */ new Set([
+  "CAPTURE_BUSY",
+  "INVALID_REQUEST",
+  "RESOURCE_LIMIT_EXCEEDED",
+  "PERMISSION_DENIED",
+  "DISPLAY_NOT_FOUND",
+  "CAPTURE_FAILED",
+  "OVERLAY_LOAD_FAILED",
+  "EXPORT_FAILED",
+  "INVALID_RESULT",
+  "UNSUPPORTED_PLATFORM"
+]);
+var SCREENSHOT_TOOLS = /* @__PURE__ */ new Set([
+  "rectangle",
+  "ellipse",
+  "arrow",
+  "brush",
+  "text",
+  "mosaic"
+]);
+var SCREENSHOT_OPTION_KEYS = /* @__PURE__ */ new Set([
+  "display",
+  "tools",
+  "defaultTool",
+  "locale",
+  "messages",
+  "theme"
+]);
+var SCREENSHOT_THEME_COLOR_KEYS = [
+  "accentColor",
+  "accentForegroundColor",
+  "maskColor",
+  "toolbarBackground",
+  "toolbarForeground",
+  "toolbarBorderColor",
+  "toolbarHoverBackground",
+  "tooltipBackground",
+  "tooltipForeground",
+  "destructiveColor",
+  "warningColor",
+  "warningForegroundColor",
+  "selectionHandleColor"
+];
+var SCREENSHOT_THEME_KEYS = /* @__PURE__ */ new Set(["mode", ...SCREENSHOT_THEME_COLOR_KEYS]);
+var SCREENSHOT_MESSAGE_KEYS = [
+  "preparing",
+  "instruction",
+  "exporting",
+  "copied",
+  "saveCancelled",
+  "cancel",
+  "save",
+  "confirm",
+  "select",
+  "rectangle",
+  "ellipse",
+  "arrow",
+  "brush",
+  "text",
+  "mosaic",
+  "undo",
+  "redo",
+  "color",
+  "lineWidth",
+  "fontSize",
+  "annotationCanvas",
+  "selection",
+  "actions",
+  "annotationTools",
+  "history",
+  "annotationStyle",
+  "outputActions",
+  "annotationText"
+];
+var SCREENSHOT_MESSAGE_KEY_SET = new Set(SCREENSHOT_MESSAGE_KEYS);
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasOnlyKeys(value, allowedKeys) {
+  return Object.keys(value).every((key) => allowedKeys.has(key));
+}
+function isBoundedString(value, maximumLength) {
+  return typeof value === "string" && value.length > 0 && value.length <= maximumLength;
+}
+function parseScreenshotOptions(value) {
+  if (value === void 0) {
+    return { success: true, value: {} };
+  }
+  if (!isRecord(value) || !hasOnlyKeys(value, SCREENSHOT_OPTION_KEYS)) {
+    return {
+      success: false,
+      message: "Screenshot options must be a plain supported object."
+    };
+  }
+  const parsed = {};
+  if (value.display !== void 0) {
+    if (!isBoundedString(value.display, 128)) {
+      return {
+        success: false,
+        message: "Screenshot display must be a non-empty string."
+      };
+    }
+    parsed.display = value.display;
+  }
+  if (value.tools !== void 0) {
+    if (!Array.isArray(value.tools) || value.tools.length > SCREENSHOT_TOOLS.size || !value.tools.every(
+      (tool) => typeof tool === "string" && SCREENSHOT_TOOLS.has(tool)
+    )) {
+      return {
+        success: false,
+        message: "Screenshot tools contain an unsupported value."
+      };
+    }
+    parsed.tools = [...new Set(value.tools)];
+  }
+  if (value.defaultTool !== void 0) {
+    if (value.defaultTool !== "select" && (typeof value.defaultTool !== "string" || !SCREENSHOT_TOOLS.has(value.defaultTool))) {
+      return { success: false, message: "Screenshot defaultTool is unsupported." };
+    }
+    if (value.defaultTool !== "select" && parsed.tools && !parsed.tools.includes(value.defaultTool)) {
+      return {
+        success: false,
+        message: "Screenshot defaultTool must be enabled in tools."
+      };
+    }
+    parsed.defaultTool = value.defaultTool;
+  }
+  if (value.locale !== void 0) {
+    if (value.locale !== "zh-CN" && value.locale !== "en-US") {
+      return { success: false, message: "Screenshot locale is unsupported." };
+    }
+    parsed.locale = value.locale;
+  }
+  if (value.messages !== void 0) {
+    const messages = parseScreenshotMessages(value.messages);
+    if (!messages) {
+      return { success: false, message: "Screenshot messages are invalid." };
+    }
+    parsed.messages = messages;
+  }
+  if (value.theme !== void 0) {
+    const theme = parseScreenshotTheme(value.theme);
+    if (!theme) {
+      return { success: false, message: "Screenshot theme is invalid." };
+    }
+    parsed.theme = theme;
+  }
+  return { success: true, value: parsed };
+}
+function parseScreenshotTheme(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, SCREENSHOT_THEME_KEYS)) {
+    return void 0;
+  }
+  const theme = {};
+  if (value.mode !== void 0) {
+    if (value.mode !== "dark" && value.mode !== "light") {
+      return void 0;
+    }
+    theme.mode = value.mode;
+  }
+  for (const key of SCREENSHOT_THEME_COLOR_KEYS) {
+    const color = value[key];
+    if (color === void 0) {
+      continue;
+    }
+    if (!isBoundedString(color, 128)) {
+      return void 0;
+    }
+    theme[key] = color;
+  }
+  return theme;
+}
+function parseScreenshotMessages(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, SCREENSHOT_MESSAGE_KEY_SET)) {
+    return void 0;
+  }
+  const messages = {};
+  for (const key of SCREENSHOT_MESSAGE_KEYS) {
+    const message = value[key];
+    if (message === void 0) {
+      continue;
+    }
+    if (!isBoundedString(message, 256)) {
+      return void 0;
+    }
+    messages[key] = message;
+  }
+  return messages;
+}
+function hasProtocolVersion(value) {
+  return value.protocolVersion === SCREENSHOT_PROTOCOL_VERSION;
+}
+function hasExpectedJob(value, expectedJobId) {
+  return value.jobId === expectedJobId;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isBounds(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return isFiniteNumber(value.x) && isFiniteNumber(value.y) && isFiniteNumber(value.width) && isFiniteNumber(value.height) && value.width > 0 && value.height > 0;
+}
+function isImageResult(value, maxOutputBytes = HARD_SCREENSHOT_RESOURCE_LIMITS.maxOutputBytes) {
+  if (!isRecord(value) || value.status !== "completed") {
+    return false;
+  }
+  return value.data instanceof Uint8Array && value.data.byteLength > 0 && value.data.byteLength <= maxOutputBytes && value.mimeType === "image/png" && isBounds(value.bounds) && typeof value.displayId === "string" && value.displayId.length > 0;
+}
+function isOutputMetadata(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (value.action === "copy") {
+    return true;
+  }
+  return value.action === "save" && typeof value.filePath === "string" && value.filePath.length > 0;
+}
+function isCompletedResult(value, maxOutputBytes) {
+  return isImageResult(value, maxOutputBytes) && isOutputMetadata(value.output);
+}
+function isReadyPayload(value) {
+  return isRecord(value) && hasProtocolVersion(value);
+}
+function isPreparedPayload(value, expectedJobId) {
+  return isRecord(value) && hasProtocolVersion(value) && hasExpectedJob(value, expectedJobId);
+}
+function isCompletePayload(value, expectedJobId, maxOutputBytes) {
+  return isRecord(value) && hasProtocolVersion(value) && hasExpectedJob(value, expectedJobId) && isCompletedResult(value.result, maxOutputBytes);
+}
+function isCancelPayload(value, expectedJobId) {
+  return isRecord(value) && hasProtocolVersion(value) && hasExpectedJob(value, expectedJobId);
+}
+function isErrorPayload(value, expectedJobId) {
+  return isRecord(value) && hasProtocolVersion(value) && hasExpectedJob(value, expectedJobId) && typeof value.code === "string" && SCREENSHOT_ERROR_CODES.has(value.code) && typeof value.message === "string" && value.message.length > 0;
+}
+function isOutputPayload(value, maxOutputBytes) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return hasProtocolVersion(value) && typeof value.jobId === "string" && value.jobId.length > 0 && (value.action === "save" || value.action === "copy") && isImageResult(value.result, maxOutputBytes);
+}
+
+// src/electron/main/output-action-router.ts
+var ScreenshotOutputRouter = class {
+  #handlers = /* @__PURE__ */ new Map();
+  constructor(ipcMain) {
+    ipcMain.handle(OVERLAY_CHANNELS.output, this.#handleOutput);
+  }
+  register(senderWebContentsId, jobId, handler) {
+    this.#handlers.set(senderWebContentsId, { jobId, handler });
+    return () => {
+      const current = this.#handlers.get(senderWebContentsId);
+      if (current?.jobId === jobId) {
+        this.#handlers.delete(senderWebContentsId);
+      }
+    };
+  }
+  #handleOutput = async (event, payload) => {
+    if (!isOutputPayload(payload)) {
+      return {
+        status: "failed",
+        code: "INVALID_REQUEST",
+        message: "Invalid or oversized screenshot output request."
+      };
+    }
+    const active = this.#handlers.get(event.sender.id);
+    if (!active || active.jobId !== payload.jobId) {
+      return {
+        status: "failed",
+        code: "INVALID_REQUEST",
+        message: "Screenshot output task is not active."
+      };
+    }
+    try {
+      return await active.handler(payload, {
+        senderWebContentsId: event.sender.id
+      });
+    } catch (error) {
+      return {
+        status: "failed",
+        code: "EXPORT_FAILED",
+        message: error instanceof Error ? error.message : "Screenshot output failed."
+      };
+    }
+  };
+};
+var routers = /* @__PURE__ */ new WeakMap();
+function getScreenshotOutputRouter(ipcMain) {
+  const key = ipcMain;
+  const existing = routers.get(key);
+  if (existing) {
+    return existing;
+  }
+  const router = new ScreenshotOutputRouter(ipcMain);
+  routers.set(key, router);
+  return router;
+}
+
+// src/electron/main/screenshot-session.ts
+var ScreenshotSession = class {
+  #options;
+  #resourceLimits;
+  #state = "idle";
+  #overlay;
+  #frames = [];
+  #overlayLoaded = false;
+  #rendererReady = false;
+  #resolve;
+  #settled = false;
+  #readyTimer;
+  #windowCleanups = [];
+  #diagnosticStageStarts = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#options = options;
+    this.#resourceLimits = resolveScreenshotResourceLimits(options.resourceLimits);
+  }
+  get state() {
+    return this.#state;
+  }
+  /** 允许主进程在宿主窗口销毁或业务主动终止时结束任意活动阶段。 */
+  cancel() {
+    if (this.#settled || this.#state === "idle") {
+      return false;
+    }
+    this.#settle({ status: "cancelled" });
+    return true;
+  }
+  run() {
+    if (this.#state !== "idle") {
+      return Promise.resolve({
+        status: "failed",
+        code: "INVALID_RESULT",
+        message: "A screenshot session can only be run once."
+      });
+    }
+    return new Promise((resolve2) => {
+      this.#resolve = resolve2;
+      void this.#start();
+    });
+  }
+  async #start() {
+    this.#state = "capturing";
+    this.#startDiagnosticStage("capture");
+    let targetDisplay;
+    try {
+      targetDisplay = this.#options.captureAdapter.resolveTargetDisplay?.(
+        this.#options.captureOptions
+      );
+      if (targetDisplay) {
+        this.#openOverlay(targetDisplay);
+      }
+    } catch {
+    }
+    let frames;
+    try {
+      frames = targetDisplay ? await this.#options.captureAdapter.capture(
+        this.#options.captureOptions,
+        targetDisplay
+      ) : await this.#options.captureAdapter.capture(this.#options.captureOptions);
+      if (this.#settled) {
+        return;
+      }
+      if (!frames[0]) {
+        throw new ScreenshotError(
+          "CAPTURE_FAILED",
+          "Screen capture returned no frames."
+        );
+      }
+      if (targetDisplay && !isSameDisplayGeometry(targetDisplay, frames[0].display)) {
+        throw new ScreenshotError(
+          "DISPLAY_NOT_FOUND",
+          "The target display changed while the screenshot was starting. Please retry."
+        );
+      }
+      for (const frame of frames) {
+        const violation = findCapturedFrameLimitViolation(frame, this.#resourceLimits);
+        if (violation) {
+          throw new ScreenshotError("RESOURCE_LIMIT_EXCEEDED", violation);
+        }
+      }
+      this.#finishDiagnosticStage("capture", "complete", {
+        frameCount: frames.length,
+        capturePixels: frames.reduce(
+          (total, frame) => total + frame.pixelSize.width * frame.pixelSize.height,
+          0
+        )
+      });
+    } catch (error) {
+      const failure = toScreenshotFailure(error);
+      this.#finishDiagnosticStage("capture", "error", diagnosticError(error), failure);
+      this.#settle(failure);
+      return;
+    }
+    this.#frames = frames;
+    this.#state = "opening-overlay";
+    if (!this.#overlay) {
+      this.#openOverlay(frames[0].display);
+    }
+    this.#prepareOverlayWhenReady();
+  }
+  #openOverlay(display) {
+    if (this.#settled || this.#overlay) {
+      return;
+    }
+    this.#startDiagnosticStage("overlay-create");
+    try {
+      this.#overlay = this.#options.createOverlay(display);
+      this.#finishDiagnosticStage("overlay-create", "complete", {
+        displayId: display.id,
+        overlayWebContentsId: this.#overlay.webContentsId
+      });
+    } catch (error) {
+      const failure = toScreenshotFailure(error, "OVERLAY_LOAD_FAILED");
+      this.#finishDiagnosticStage(
+        "overlay-create",
+        "error",
+        diagnosticError(error),
+        failure
+      );
+      this.#settle(failure);
+      return;
+    }
+    this.#registerListeners();
+    this.#startReadyTimeout();
+    this.#startDiagnosticStage("overlay-load");
+    this.#startDiagnosticStage("overlay-ready");
+    void this.#loadOverlay();
+  }
+  async #loadOverlay() {
+    try {
+      await this.#overlay?.load();
+      if (this.#settled) {
+        return;
+      }
+      this.#overlayLoaded = true;
+      this.#finishDiagnosticStage("overlay-load", "complete");
+      this.#prepareOverlayWhenReady();
+    } catch (error) {
+      const failure = toScreenshotFailure(error, "OVERLAY_LOAD_FAILED");
+      this.#finishDiagnosticStage(
+        "overlay-load",
+        "error",
+        diagnosticError(error),
+        failure
+      );
+      this.#settle(failure);
+    }
+  }
+  #registerListeners() {
+    this.#options.ipcMain.on(OVERLAY_CHANNELS.ready, this.#handleReady);
+    this.#options.ipcMain.on(OVERLAY_CHANNELS.prepared, this.#handlePrepared);
+    this.#options.ipcMain.on(OVERLAY_CHANNELS.confirm, this.#handleConfirm);
+    this.#options.ipcMain.on(OVERLAY_CHANNELS.cancel, this.#handleCancel);
+    this.#options.ipcMain.on(OVERLAY_CHANNELS.error, this.#handleError);
+    if (this.#overlay) {
+      const outputCleanup = this.#options.registerOutputHandler?.(
+        this.#overlay.webContentsId,
+        this.#options.jobId
+      );
+      if (outputCleanup) {
+        this.#windowCleanups.push(outputCleanup);
+      }
+      this.#windowCleanups.push(
+        this.#overlay.onClosed(() => {
+          if (!this.#settled) {
+            this.#settle({ status: "cancelled" });
+          }
+        }),
+        this.#overlay.onRendererGone(() => {
+          if (!this.#settled) {
+            this.#settle({
+              status: "failed",
+              code: "OVERLAY_LOAD_FAILED",
+              message: "The screenshot overlay renderer exited unexpectedly."
+            });
+          }
+        })
+      );
+    }
+  }
+  #handleReady = (event, payload) => {
+    if (!this.#isExpectedSender(event)) {
+      return;
+    }
+    if (!isReadyPayload(payload)) {
+      this.#settleInvalidMessage("Invalid overlay ready message.");
+      return;
+    }
+    if (this.#state !== "capturing" && this.#state !== "opening-overlay" || !this.#overlay || this.#rendererReady) {
+      return;
+    }
+    this.#clearReadyTimeout();
+    this.#finishDiagnosticStage("overlay-ready", "complete");
+    this.#rendererReady = true;
+    this.#prepareOverlayWhenReady();
+  };
+  #prepareOverlayWhenReady() {
+    if (this.#settled || this.#state !== "opening-overlay" || !this.#overlay || !this.#overlayLoaded || !this.#rendererReady || !this.#frames[0]) {
+      return;
+    }
+    this.#state = "preparing-overlay";
+    this.#startDiagnosticStage("overlay-prepare");
+    this.#overlay.prime();
+    this.#overlay.sendInitialize({
+      protocolVersion: SCREENSHOT_PROTOCOL_VERSION,
+      jobId: this.#options.jobId,
+      options: this.#options.captureOptions,
+      frames: this.#frames
+    });
+    this.#frames = [];
+    this.#startReadyTimeout(
+      "The screenshot overlay did not prepare its captured frame in time."
+    );
+  }
+  #handlePrepared = (event, payload) => {
+    if (!this.#isExpectedSender(event)) {
+      return;
+    }
+    if (!isPreparedPayload(payload, this.#options.jobId)) {
+      this.#settleInvalidMessage("Invalid overlay prepared message.");
+      return;
+    }
+    if (this.#state !== "preparing-overlay" || !this.#overlay) {
+      return;
+    }
+    this.#clearReadyTimeout();
+    this.#finishDiagnosticStage("overlay-prepare", "complete");
+    this.#state = "editing";
+    this.#overlay.reveal();
+  };
+  #handleConfirm = (event, payload) => {
+    if (!this.#isExpectedSender(event) || this.#state !== "editing") {
+      return;
+    }
+    if (!isCompletePayload(
+      payload,
+      this.#options.jobId,
+      this.#resourceLimits.maxOutputBytes
+    )) {
+      this.#settleInvalidMessage("Invalid screenshot completion message.");
+      return;
+    }
+    this.#state = "exporting";
+    this.#settle(payload.result);
+  };
+  #handleCancel = (event, payload) => {
+    if (!this.#isExpectedSender(event) || this.#state !== "preparing-overlay" && this.#state !== "editing") {
+      return;
+    }
+    if (!isCancelPayload(payload, this.#options.jobId)) {
+      this.#settleInvalidMessage("Invalid screenshot cancellation message.");
+      return;
+    }
+    this.#settle({ status: "cancelled" });
+  };
+  #handleError = (event, payload) => {
+    if (!this.#isExpectedSender(event) || this.#state !== "preparing-overlay" && this.#state !== "editing") {
+      return;
+    }
+    if (!isErrorPayload(payload, this.#options.jobId)) {
+      this.#settleInvalidMessage("Invalid screenshot error message.");
+      return;
+    }
+    this.#settle({
+      status: "failed",
+      code: payload.code,
+      message: payload.message
+    });
+  };
+  #isExpectedSender(event) {
+    return this.#overlay !== void 0 && event.sender.id === this.#overlay.webContentsId;
+  }
+  #settleInvalidMessage(message) {
+    this.#settle({
+      status: "failed",
+      code: "INVALID_RESULT",
+      message
+    });
+  }
+  #startReadyTimeout(message = "The screenshot overlay did not become ready in time.") {
+    this.#clearReadyTimeout();
+    const timeoutMs = this.#options.overlayReadyTimeoutMs ?? 1e4;
+    this.#readyTimer = setTimeout(() => {
+      this.#settle({
+        status: "failed",
+        code: "OVERLAY_LOAD_FAILED",
+        message
+      });
+    }, timeoutMs);
+    this.#readyTimer.unref?.();
+  }
+  #clearReadyTimeout() {
+    if (this.#readyTimer) {
+      clearTimeout(this.#readyTimer);
+      this.#readyTimer = void 0;
+    }
+  }
+  #settle(result) {
+    if (this.#settled) {
+      return;
+    }
+    this.#settled = true;
+    const phase = result.status === "cancelled" ? "cancel" : result.status === "failed" ? "error" : "complete";
+    for (const stage of [...this.#diagnosticStageStarts.keys()]) {
+      this.#finishDiagnosticStage(stage, phase, void 0, result);
+    }
+    this.#state = result.status === "completed" ? "completed" : result.status === "cancelled" ? "cancelled" : "failed";
+    this.#clearReadyTimeout();
+    this.#removeListeners();
+    this.#frames = [];
+    if (result.status === "completed" && result.output.action === "copy" && this.#overlay?.showCopyFeedback) {
+      this.#overlay.showCopyFeedback(3e3, this.#options.captureOptions);
+    } else {
+      this.#overlay?.destroy();
+    }
+    this.#options.onSettled?.();
+    this.#resolve?.(result);
+    this.#resolve = void 0;
+  }
+  #startDiagnosticStage(stage, context) {
+    const timestamp = Date.now();
+    this.#diagnosticStageStarts.set(stage, timestamp);
+    emitScreenshotDiagnostic(this.#options.onDiagnostic, {
+      jobId: this.#options.jobId,
+      stage,
+      phase: "start",
+      timestamp,
+      ...context ? { context } : {}
+    });
+  }
+  #finishDiagnosticStage(stage, phase, context, result) {
+    const startedAt = this.#diagnosticStageStarts.get(stage);
+    if (startedAt === void 0) {
+      return;
+    }
+    this.#diagnosticStageStarts.delete(stage);
+    const timestamp = Date.now();
+    emitScreenshotDiagnostic(this.#options.onDiagnostic, {
+      jobId: this.#options.jobId,
+      stage,
+      phase,
+      timestamp,
+      durationMs: Math.max(0, timestamp - startedAt),
+      ...result?.status === "failed" ? { code: result.code, message: result.message } : {},
+      ...context ? { context } : {}
+    });
+  }
+  #removeListeners() {
+    this.#options.ipcMain.removeListener(OVERLAY_CHANNELS.ready, this.#handleReady);
+    this.#options.ipcMain.removeListener(
+      OVERLAY_CHANNELS.prepared,
+      this.#handlePrepared
+    );
+    this.#options.ipcMain.removeListener(OVERLAY_CHANNELS.confirm, this.#handleConfirm);
+    this.#options.ipcMain.removeListener(OVERLAY_CHANNELS.cancel, this.#handleCancel);
+    this.#options.ipcMain.removeListener(OVERLAY_CHANNELS.error, this.#handleError);
+    for (const cleanup of this.#windowCleanups.splice(0)) {
+      cleanup();
+    }
+  }
+};
+function diagnosticError(error) {
+  const context = {
+    errorName: error instanceof Error ? error.name : typeof error
+  };
+  if (error instanceof PackagedResourceError) {
+    context.missingResources = error.missingResources.map(
+      (resource) => `${resource.label}: ${resource.path}`
+    );
+  }
+  return context;
+}
+function isSameDisplayGeometry(expected, actual) {
+  return expected.id === actual.id && expected.scaleFactor === actual.scaleFactor && expected.bounds.x === actual.bounds.x && expected.bounds.y === actual.bounds.y && expected.bounds.width === actual.bounds.width && expected.bounds.height === actual.bounds.height;
+}
+
+// src/electron/main/screenshot-manager.ts
+var DEFAULT_MAX_QUEUED_CAPTURES = 8;
+function createDefaultRunner(managerOptions) {
+  const ipcMain = managerOptions.ipcMain ?? electronIpcMain;
+  const resourceLimits = resolveScreenshotResourceLimits(managerOptions.resourceLimits);
+  const captureAdapter = managerOptions.captureAdapter ?? new ElectronCaptureAdapter({ resourceLimits });
+  const outputAdapter = managerOptions.outputAdapter ?? new ElectronOutputAdapter();
+  const outputRouter = getScreenshotOutputRouter(ipcMain);
+  const createOverlayWindow = managerOptions.createOverlay ?? ((display) => new OverlayWindow({ ...managerOptions.overlayOptions, display }));
+  let previousOverlay;
+  return (jobId, captureOptions, context) => {
+    previousOverlay?.destroy();
+    previousOverlay = void 0;
+    const reportDiagnostic = (event) => {
+      emitScreenshotDiagnostic(managerOptions.onDiagnostic, {
+        ...event,
+        ...context.senderWebContentsId === void 0 ? {} : { senderWebContentsId: context.senderWebContentsId }
+      });
+    };
+    const session = new ScreenshotSession({
+      jobId,
+      captureOptions,
+      captureAdapter,
+      ipcMain,
+      createOverlay: (display) => {
+        const overlay = createOverlayWindow(display);
+        previousOverlay = overlay;
+        return overlay;
+      },
+      ...managerOptions.overlayReadyTimeoutMs === void 0 ? {} : { overlayReadyTimeoutMs: managerOptions.overlayReadyTimeoutMs },
+      resourceLimits,
+      onDiagnostic: reportDiagnostic,
+      registerOutputHandler: (senderWebContentsId, activeJobId) => outputRouter.register(
+        senderWebContentsId,
+        activeJobId,
+        async (payload, outputContext) => {
+          const startedAt = Date.now();
+          reportDiagnostic({
+            jobId: activeJobId,
+            stage: "output",
+            phase: "start",
+            timestamp: startedAt,
+            context: {
+              action: payload.action,
+              outputBytes: payload.result.data.byteLength
+            }
+          });
+          let response;
+          try {
+            response = payload.result.data.byteLength > resourceLimits.maxOutputBytes ? {
+              status: "failed",
+              code: "RESOURCE_LIMIT_EXCEEDED",
+              message: `Screenshot output exceeds the ${resourceLimits.maxOutputBytes} byte limit.`
+            } : await outputAdapter.execute(payload, outputContext);
+          } catch (error) {
+            const timestamp2 = Date.now();
+            reportDiagnostic({
+              jobId: activeJobId,
+              stage: "output",
+              phase: "error",
+              timestamp: timestamp2,
+              durationMs: Math.max(0, timestamp2 - startedAt),
+              code: "EXPORT_FAILED",
+              message: error instanceof Error ? error.message : "Screenshot output failed.",
+              context: { action: payload.action }
+            });
+            throw error;
+          }
+          const timestamp = Date.now();
+          reportDiagnostic({
+            jobId: activeJobId,
+            stage: "output",
+            phase: response.status === "failed" ? "error" : response.status === "cancelled" ? "cancel" : "complete",
+            timestamp,
+            durationMs: Math.max(0, timestamp - startedAt),
+            ...response.status === "failed" ? { code: response.code, message: response.message } : {},
+            context: { action: payload.action }
+          });
+          return response;
+        }
+      ),
+      onSettled: () => {
+        if (context.senderWebContentsId === void 0) {
+          return;
+        }
+        const sender = webContents2.fromId(context.senderWebContentsId);
+        if (sender && !sender.isDestroyed()) {
+          sender.focus();
+        }
+      }
+    });
+    return {
+      result: session.run(),
+      cancel: () => session.cancel()
+    };
+  };
+}
+var ScreenshotManager = class {
+  #runner;
+  #busyPolicy;
+  #maxQueuedCaptures;
+  #queue = [];
+  #onDiagnostic;
+  #activeJobId;
+  #activeSenderWebContentsId;
+  #cancelActive;
+  constructor(options = {}) {
+    if (options.busyPolicy !== void 0 && !["reject", "queue"].includes(options.busyPolicy)) {
+      throw new TypeError("busyPolicy must be either reject or queue.");
+    }
+    this.#busyPolicy = options.busyPolicy ?? "reject";
+    this.#maxQueuedCaptures = options.maxQueuedCaptures ?? DEFAULT_MAX_QUEUED_CAPTURES;
+    if (!Number.isSafeInteger(this.#maxQueuedCaptures) || this.#maxQueuedCaptures < 1 || this.#maxQueuedCaptures > 100) {
+      throw new TypeError("maxQueuedCaptures must be an integer between 1 and 100.");
+    }
+    this.#runner = options.runner ?? createDefaultRunner(options);
+    this.#onDiagnostic = options.onDiagnostic;
+  }
+  get activeJobId() {
+    return this.#activeJobId;
+  }
+  get queuedCaptureCount() {
+    return this.#queue.length;
+  }
+  /** 不传 sender ID 时供主进程直接取消；传入时只允许取消该页面创建的任务。 */
+  cancel(senderWebContentsId) {
+    let cancelled = false;
+    if (this.#activeJobId && (senderWebContentsId === void 0 || this.#activeSenderWebContentsId === senderWebContentsId)) {
+      cancelled = this.#cancelActive?.() ?? false;
+    }
+    if (senderWebContentsId !== void 0) {
+      for (let index = this.#queue.length - 1; index >= 0; index -= 1) {
+        const queued = this.#queue[index];
+        if (queued?.context.senderWebContentsId !== senderWebContentsId) {
+          continue;
+        }
+        this.#queue.splice(index, 1);
+        this.#finishDiagnosticStage(
+          queued.jobId,
+          "queue",
+          "cancel",
+          queued.queuedAt,
+          queued.context,
+          void 0,
+          { queueDepth: this.#queue.length }
+        );
+        queued.resolve({ status: "cancelled" });
+        cancelled = true;
+      }
+    }
+    return cancelled;
+  }
+  capture(options = {}, context = {}) {
+    if (this.#activeJobId) {
+      return this.#handleBusyCapture(options, context);
+    }
+    return this.#executeCapture(options, context);
+  }
+  #handleBusyCapture(options, context) {
+    const senderWebContentsId = context.senderWebContentsId;
+    const sameSenderAlreadyPending = senderWebContentsId !== void 0 && (this.#activeSenderWebContentsId === senderWebContentsId || this.#queue.some(
+      (queued) => queued.context.senderWebContentsId === senderWebContentsId
+    ));
+    if (this.#busyPolicy === "reject" || sameSenderAlreadyPending || this.#queue.length >= this.#maxQueuedCaptures) {
+      const result = {
+        status: "failed",
+        code: "CAPTURE_BUSY",
+        message: sameSenderAlreadyPending ? "This window already has a screenshot task pending." : "A screenshot task is already running."
+      };
+      const timestamp = Date.now();
+      this.#emitDiagnostic({
+        jobId: randomUUID(),
+        stage: "queue",
+        phase: "error",
+        timestamp,
+        durationMs: 0,
+        ...senderWebContentsId === void 0 ? {} : { senderWebContentsId },
+        code: result.code,
+        message: result.message,
+        context: {
+          queueDepth: this.#queue.length,
+          reason: sameSenderAlreadyPending ? "sender-mutex" : this.#busyPolicy === "reject" ? "policy" : "queue-capacity"
+        }
+      });
+      return Promise.resolve(result);
+    }
+    return new Promise((resolve2) => {
+      const jobId = randomUUID();
+      const queuedAt = Date.now();
+      this.#queue.push({ jobId, queuedAt, options, context, resolve: resolve2 });
+      this.#emitDiagnostic({
+        jobId,
+        stage: "queue",
+        phase: "start",
+        timestamp: queuedAt,
+        ...senderWebContentsId === void 0 ? {} : { senderWebContentsId },
+        context: { queueDepth: this.#queue.length }
+      });
+    });
+  }
+  async #executeCapture(options, context, jobId = randomUUID()) {
+    const startedAt = Date.now();
+    this.#activeJobId = jobId;
+    this.#activeSenderWebContentsId = context.senderWebContentsId;
+    this.#emitDiagnostic({
+      jobId,
+      stage: "session",
+      phase: "start",
+      timestamp: startedAt,
+      ...context.senderWebContentsId === void 0 ? {} : { senderWebContentsId: context.senderWebContentsId }
+    });
+    let result;
+    try {
+      const execution = this.#runner(jobId, options, context);
+      if (isScreenshotExecution(execution)) {
+        this.#cancelActive = execution.cancel;
+        result = await execution.result;
+      } else {
+        result = await execution;
+      }
+    } catch (error) {
+      result = toScreenshotFailure(error);
+    }
+    this.#finishDiagnosticStage(
+      jobId,
+      "session",
+      diagnosticPhaseForResult(result),
+      startedAt,
+      context,
+      result,
+      { status: result.status }
+    );
+    if (this.#activeJobId === jobId) {
+      this.#activeJobId = void 0;
+      this.#activeSenderWebContentsId = void 0;
+      this.#cancelActive = void 0;
+      this.#startNextQueuedCapture();
+    }
+    return result;
+  }
+  #startNextQueuedCapture() {
+    const next = this.#queue.shift();
+    if (!next) {
+      return;
+    }
+    this.#finishDiagnosticStage(
+      next.jobId,
+      "queue",
+      "complete",
+      next.queuedAt,
+      next.context,
+      void 0,
+      { queueDepth: this.#queue.length }
+    );
+    void this.#executeCapture(next.options, next.context, next.jobId).then(
+      next.resolve
+    );
+  }
+  #finishDiagnosticStage(jobId, stage, phase, startedAt, context, result, diagnosticContext) {
+    const timestamp = Date.now();
+    this.#emitDiagnostic({
+      jobId,
+      stage,
+      phase,
+      timestamp,
+      durationMs: Math.max(0, timestamp - startedAt),
+      ...context.senderWebContentsId === void 0 ? {} : { senderWebContentsId: context.senderWebContentsId },
+      ...result?.status === "failed" ? { code: result.code, message: result.message } : {},
+      ...diagnosticContext ? { context: diagnosticContext } : {}
+    });
+  }
+  #emitDiagnostic(event) {
+    emitScreenshotDiagnostic(this.#onDiagnostic, event);
+  }
+};
+function isScreenshotExecution(value) {
+  return "result" in value && typeof value.cancel === "function";
+}
+function diagnosticPhaseForResult(result) {
+  return result.status === "failed" ? "error" : result.status === "cancelled" ? "cancel" : "complete";
+}
+
+// src/electron/main/register-host-ipc.ts
+function setupElectronSnapora(options) {
+  const { managerOptions, ...ipcOptions } = options;
+  const manager = new ScreenshotManager(managerOptions);
+  return {
+    manager,
+    preloadPath: resolveHostPreloadPath(),
+    unregister: registerScreenshotIpc({ ...ipcOptions, manager })
+  };
+}
+function registerScreenshotIpc(options) {
+  const channel = options.channel ?? DEFAULT_HOST_CAPTURE_CHANNEL;
+  const cancelChannel = options.cancelChannel ?? (options.channel ? `${options.channel}:cancel` : DEFAULT_HOST_CANCEL_CHANNEL);
+  options.ipcMain.handle(channel, async (event, captureOptions) => {
+    if (!isAuthorizedSender(event, options.validateSender)) {
+      return invalidRequest("The screenshot request sender is not authorized.");
+    }
+    const parsed = parseScreenshotOptions(captureOptions);
+    if (!parsed.success) {
+      return invalidRequest(parsed.message);
+    }
+    const senderWebContentsId = event.sender.id;
+    const cancelWhenDestroyed = () => {
+      options.manager.cancel(senderWebContentsId);
+    };
+    event.sender.once("destroyed", cancelWhenDestroyed);
+    try {
+      return await options.manager.capture(parsed.value, { senderWebContentsId });
+    } finally {
+      event.sender.removeListener("destroyed", cancelWhenDestroyed);
+    }
+  });
+  options.ipcMain.handle(cancelChannel, async (event) => {
+    if (!isAuthorizedSender(event, options.validateSender)) {
+      return false;
+    }
+    return options.manager.cancel(event.sender.id);
+  });
+  return () => {
+    options.ipcMain.removeHandler(channel);
+    options.ipcMain.removeHandler(cancelChannel);
+  };
+}
+function isAuthorizedSender(event, validateSender) {
+  if (!event.senderFrame || event.senderFrame !== event.sender.mainFrame) {
+    return false;
+  }
+  if (validateSender) {
+    try {
+      return validateSender(event);
+    } catch {
+      return false;
+    }
+  }
+  try {
+    return new URL(event.senderFrame.url).protocol === "file:";
+  } catch {
+    return false;
+  }
+}
+function invalidRequest(message) {
+  return { status: "failed", code: "INVALID_REQUEST", message };
+}
+export {
+  DEFAULT_HOST_CANCEL_CHANNEL,
+  DEFAULT_HOST_CAPTURE_CHANNEL,
+  DEFAULT_SCREENSHOT_RESOURCE_LIMITS,
+  ElectronCaptureAdapter,
+  ElectronOutputAdapter,
+  HARD_SCREENSHOT_RESOURCE_LIMITS,
+  OVERLAY_CHANNELS,
+  OverlayWindow,
+  PackagedResourceError,
+  SCREENSHOT_PROTOCOL_VERSION,
+  ScreenshotError,
+  ScreenshotManager,
+  ScreenshotSession,
+  assertOverlayResources,
+  registerScreenshotIpc,
+  resolveHostPreloadPath,
+  resolveOverlayResources,
+  resolveScreenshotResourceLimits,
+  setupElectronSnapora
+};
+//# sourceMappingURL=index.mjs.map