// @effect-diagnostics globalTimers:off -- Child-process deadlines run outside Effect fibers.// @effect-diagnostics nodeBuiltinImport:off -- This desktop-only helper owns a Node child process.import * as NodeChildProcess from "node:child_process"; import * as Electron from "electron"; import type { ActiveWindow } from "./ActiveWindow.ts"; const CAPTURE_TIMEOUT_MS = 15_000; export type RegionSnapShotRequest = { readonly region: Electron.Rectangle };export type RegionSnapShotResult =  | {      readonly type: "result";      readonly width: number;      readonly height: number;      readonly png: string;    }  | { readonly type: "error"; readonly message: string }; export type RegionSnapShotSource = {  readonly appIcon?: Electron.NativeImage;  readonly name: string;}; export type RegionSnapShotChild = {  readonly send: (request: RegionSnapShotRequest) => void;  readonly onMessage: (listener: (message: unknown) => void) => void;  readonly onExit: (listener: () => void) => void;  readonly kill: () => void;}; function forkRegionSnapShotChild(workerPath: string): RegionSnapShotChild {  const child = NodeChildProcess.fork(workerPath, [], {    env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" },    execArgv: [],    stdio: ["ignore", "ignore", "inherit", "ipc"],  });  return {    send: (request) => child.send(request),    onMessage: (listener) => child.on("message", listener),    onExit: (listener) => {      child.once("exit", listener);      child.once("error", listener);    },    kill: () => child.kill(),  };} export type RegionSnapShotProcess = {  readonly alive: boolean;  readonly capture: (    region: Electron.Rectangle,  ) => Promise<{ width: number; height: number; png: Buffer }>;  readonly close: () => void;}; /** * One capture child. `warm` it ahead of time so the native module is loaded * before the shortcut fires; each child serves a single capture and exits. */export function startRegionSnapShotProcess(  workerPath: string,  fork: (workerPath: string) => RegionSnapShotChild = forkRegionSnapShotChild,): RegionSnapShotProcess {  let child: RegionSnapShotChild;  try {    child = fork(workerPath);  } catch {    return {      alive: false,      capture: () => Promise.reject(new Error("Windows window capture is unavailable.")),      close: () => undefined,    };  }  const ready = Promise.withResolvers<void>();  const result = Promise.withResolvers<{ width: number; height: number; png: Buffer }>();  let settled = false;  const finish = (error?: Error, value?: { width: number; height: number; png: Buffer }) => {    if (settled) return;    settled = true;    ready.resolve();    if (value) result.resolve(value);    else result.reject(error ?? new Error("Windows window capture failed."));    child.kill();  };  child.onMessage((message) => {    if (message === "ready") {      ready.resolve();      return;    }    const response = message as RegionSnapShotResult;    if (response.type === "error") finish(new Error(response.message));    else if (response.type === "result") {      finish(undefined, {        width: response.width,        height: response.height,        png: Buffer.from(response.png, "base64"),      });    }  });  child.onExit(() => finish(new Error("Windows window capture helper exited.")));  void result.promise.catch(() => undefined);   return {    get alive() {      return !settled;    },    capture: async (region) => {      if (settled) throw new Error("Windows window capture helper already used.");      const timeout = setTimeout(        () => finish(new Error("Windows window capture timed out. Try again.")),        CAPTURE_TIMEOUT_MS,      );      timeout.unref();      try {        await ready.promise;        if (settled) return await result.promise;        child.send({ region });        return await result.promise;      } finally {        clearTimeout(timeout);      }    },    close: () => finish(new Error("Windows window capture cancelled.")),  };} export type RegionSnapShotPool = {  readonly warm: () => void;  readonly cool: () => void;  readonly capture: (    region: Electron.Rectangle,  ) => Promise<{ width: number; height: number; png: Buffer }>;  readonly close: () => void;}; export function makeRegionSnapShotPool(  workerPath: string,  start: (workerPath: string) => RegionSnapShotProcess = startRegionSnapShotProcess,): RegionSnapShotPool {  let standby: RegionSnapShotProcess | undefined;  let inFlight: RegionSnapShotProcess | undefined;  let closed = false;  const warm = () => {    if (closed || standby?.alive) return;    standby = start(workerPath);  };  const cool = () => {    standby?.close();    standby = undefined;  };  return {    warm,    cool,    capture: async (region) => {      if (closed) throw new Error("Windows window capture is unavailable.");      if (inFlight?.alive) {        throw new Error("Windows window capture is still in progress. Try again.");      }      const current = standby?.alive ? standby : start(workerPath);      standby = undefined;      inFlight = current;      try {        return await current.capture(region);      } finally {        if (inFlight === current) inFlight = undefined;        warm();      }    },    close: () => {      closed = true;      cool();      inFlight?.close();    },  };} export async function captureRegionWindowSnapshot(  pool: Pick<RegionSnapShotPool, "capture">,  active: ActiveWindow,  region: Electron.Rectangle,  maxSize: Electron.Size,): Promise<{ readonly source: RegionSnapShotSource; readonly png: Buffer }> {  const shot = await pool.capture(region);  const scale = Math.min(maxSize.width / shot.width, maxSize.height / shot.height, 1);  const png =    scale < 1      ? Electron.nativeImage          .createFromBuffer(shot.png)          .resize({            width: Math.max(1, Math.round(shot.width * scale)),            height: Math.max(1, Math.round(shot.height * scale)),            quality: "best",          })          .toPNG()      : shot.png;  return {    source: {      name: active.title.trim() || active.owner.name.trim() || "Window",    },    png,  };}