@zenbu-labs/pixel 0.0.0 → 0.0.13

package/dist/web/browser-session.d.ts

@@ -0,0 +1,13 @@
+import type { Session, WebContents } from "electron";
+export interface DownloadProgress {
+    name: string;
+    savePath: string;
+    received: number;
+    total: number;
+    state: "progressing" | "done" | "failed";
+}
+export declare function routeThroughProxy(target: Session, rules: string): Promise<void>;
+export declare function allowClipboardRead(contents: WebContents): void;
+export declare function onDownloadFor(contents: WebContents, handler: (progress: DownloadProgress) => void): void;
+export declare function configureBrowserSession(target: Session): void;
+export declare function persistentPartition(partition: string): string;

package/dist/web/browser-session.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeThroughProxy = routeThroughProxy;
+exports.allowClipboardRead = allowClipboardRead;
+exports.onDownloadFor = onDownloadFor;
+exports.configureBrowserSession = configureBrowserSession;
+exports.persistentPartition = persistentPartition;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_stream_1 = require("node:stream");
+const node_url_1 = require("node:url");
+const electron_1 = require("electron");
+const GRANTED = new Set([
+    "fullscreen",
+    "pointerLock",
+    "clipboard-sanitized-write",
+    "midi",
+]);
+const configured = new WeakSet();
+const proxied = new WeakSet();
+let webrtcGuard = false;
+function routeThroughProxy(target, rules) {
+    proxied.add(target);
+    if (!webrtcGuard) {
+        webrtcGuard = true;
+        electron_1.app.on("web-contents-created", (_event, contents) => {
+            if (proxied.has(contents.session))
+                contents.setWebRTCIPHandlingPolicy("disable_non_proxied_udp");
+        });
+    }
+    return target.setProxy({ proxyRules: rules, proxyBypassRules: "<-loopback>" });
+}
+const clipboardReaders = new WeakSet();
+const SELECT_PICKER_PRELOAD = `const { webFrame } = require("electron");
+webFrame.insertCSS("select, ::picker(select) { appearance: base-select !important }", {
+  cssOrigin: "user",
+});
+`;
+let selectPreloadFile = null;
+function selectPreloadPath() {
+    if (!selectPreloadFile) {
+        selectPreloadFile = node_path_1.default.join(electron_1.app.getPath("userData"), "pixel-select-preload.js");
+        node_fs_1.default.writeFileSync(selectPreloadFile, SELECT_PICKER_PRELOAD);
+    }
+    return selectPreloadFile;
+}
+function allowClipboardRead(contents) {
+    clipboardReaders.add(contents);
+}
+function granted(contents, permission) {
+    if (GRANTED.has(permission))
+        return true;
+    return (permission === "clipboard-read" && contents !== null && clipboardReaders.has(contents));
+}
+const downloadHandlers = new Map();
+function onDownloadFor(contents, handler) {
+    downloadHandlers.set(contents.id, handler);
+    contents.once("destroyed", () => downloadHandlers.delete(contents.id));
+}
+function configureBrowserSession(target) {
+    if (configured.has(target))
+        return;
+    configured.add(target);
+    target.registerPreloadScript({ type: "frame", filePath: selectPreloadPath() });
+    target.setPermissionRequestHandler((contents, permission, callback) => {
+        callback(granted(contents, permission));
+    });
+    target.setPermissionCheckHandler((contents, permission) => granted(contents, permission));
+    target.webRequest.onBeforeRequest({ urls: ["file://*", "file://*/*"] }, (details, callback) => {
+        callback({ cancel: details.resourceType === "xhr" });
+    });
+    target.protocol.handle("file", async (request) => {
+        const directory = requestedDirectory(request.url);
+        if (directory)
+            return directoryListing(directory);
+        const range = request.headers.get("range");
+        const ranged = range ? rangeResponse(request.url, range) : null;
+        return ranged ?? electron_1.net.fetch(request, { bypassCustomProtocolHandlers: true });
+    });
+    target.on("will-download", (_event, item, contents) => {
+        const onDownload = downloadHandlers.get(contents.id);
+        if (!onDownload)
+            return;
+        const savePath = downloadPath(item.getFilename());
+        item.setSavePath(savePath);
+        const report = (state) => onDownload({
+            name: node_path_1.default.basename(savePath),
+            savePath,
+            received: item.getReceivedBytes(),
+            total: item.getTotalBytes(),
+            state,
+        });
+        item.on("updated", (_updated, state) => report(state === "interrupted" ? "failed" : "progressing"));
+        item.once("done", (_done, state) => report(state === "completed" ? "done" : "failed"));
+        report("progressing");
+    });
+}
+function persistentPartition(partition) {
+    return partition.startsWith("persist:") ? partition : `persist:${partition}`;
+}
+function rangeResponse(url, range) {
+    const match = /^bytes=(\d*)-(\d*)$/.exec(range.trim());
+    if (!match || (!match[1] && !match[2]))
+        return null;
+    let file;
+    let size;
+    try {
+        file = (0, node_url_1.fileURLToPath)(new URL(url).href.split(/[?#]/)[0]);
+        const stat = node_fs_1.default.statSync(file);
+        if (!stat.isFile())
+            return null;
+        size = stat.size;
+    }
+    catch {
+        return null;
+    }
+    const start = match[1] ? Number(match[1]) : Math.max(0, size - Number(match[2]));
+    const end = match[1] && match[2] ? Math.min(Number(match[2]), size - 1) : size - 1;
+    if (start >= size || start > end) {
+        return new Response(null, {
+            status: 416,
+            headers: { "content-range": `bytes */${size}` },
+        });
+    }
+    const body = node_stream_1.Readable.toWeb(node_fs_1.default.createReadStream(file, { start, end }));
+    return new Response(body, {
+        status: 206,
+        headers: {
+            "accept-ranges": "bytes",
+            "content-range": `bytes ${start}-${end}/${size}`,
+            "content-length": String(end - start + 1),
+        },
+    });
+}
+function requestedDirectory(url) {
+    try {
+        const file = (0, node_url_1.fileURLToPath)(new URL(url).href.split(/[?#]/)[0]);
+        return node_fs_1.default.statSync(file).isDirectory() ? file : null;
+    }
+    catch {
+        return null;
+    }
+}
+function directoryListing(directory) {
+    const entries = node_fs_1.default
+        .readdirSync(directory, { withFileTypes: true })
+        .map((entry) => ({ name: entry.name, directory: isDirectory(directory, entry) }))
+        .sort((a, b) => a.directory === b.directory ? a.name.localeCompare(b.name) : a.directory ? -1 : 1);
+    const parent = node_path_1.default.dirname(directory);
+    const rows = entries.map((entry) => {
+        const href = (0, node_url_1.pathToFileURL)(node_path_1.default.join(directory, entry.name)).toString();
+        return `<li><a href="${escapeHtml(href)}">${escapeHtml(entry.name)}${entry.directory ? "/" : ""}</a></li>`;
+    });
+    const up = parent === directory ? "" : `<li><a href="${(0, node_url_1.pathToFileURL)(parent)}">../</a></li>`;
+    const html = `<!doctype html><meta charset="utf-8"><title>Index of ${escapeHtml(directory)}</title>
+<style>:root{color-scheme:light dark}body{font:14px ui-monospace,Menlo,monospace;margin:2rem}h1{font-size:1rem;font-weight:600;margin:0 0 1rem}ul{list-style:none;padding:0}li{padding:2px 0}a{text-decoration:none}a:hover{text-decoration:underline}</style>
+<h1>Index of ${escapeHtml(directory)}</h1><ul>${up}${rows.join("")}</ul>`;
+    return new Response(html, { headers: { "content-type": "text/html; charset=utf-8" } });
+}
+function isDirectory(parent, entry) {
+    if (!entry.isSymbolicLink())
+        return entry.isDirectory();
+    try {
+        return node_fs_1.default.statSync(node_path_1.default.join(parent, entry.name)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function escapeHtml(value) {
+    return value.replace(/[&<>"]/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[char]);
+}
+function downloadPath(filename) {
+    const dir = electron_1.app.getPath("downloads");
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+    const ext = node_path_1.default.extname(filename);
+    const base = node_path_1.default.basename(filename, ext);
+    for (let i = 0;; i++) {
+        const candidate = node_path_1.default.join(dir, i === 0 ? filename : `${base} (${i})${ext}`);
+        if (!node_fs_1.default.existsSync(candidate))
+            return candidate;
+    }
+}

package/dist/web/cursor.d.ts

@@ -0,0 +1 @@
+export declare function cursorShapeFor(type: string): string;

package/dist/web/cursor.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cursorShapeFor = cursorShapeFor;
+const CSS_CURSORS = new Set([
+    "default", "crosshair", "text", "wait", "help", "progress",
+    "cell", "vertical-text", "context-menu", "alias", "copy", "move",
+    "no-drop", "not-allowed", "grab", "grabbing", "zoom-in", "zoom-out",
+    "e-resize", "n-resize", "ne-resize", "nw-resize", "s-resize", "se-resize",
+    "sw-resize", "w-resize", "ns-resize", "ew-resize", "nesw-resize",
+    "nwse-resize", "col-resize", "row-resize",
+]);
+function cursorShapeFor(type) {
+    // chromium's "pointer" is the plain arrow; its css pointer is "hand"
+    if (type === "hand")
+        return "pointer";
+    if (CSS_CURSORS.has(type))
+        return type;
+    if (type === "nodrop")
+        return "no-drop";
+    if (type.endsWith("-panning"))
+        return "all-scroll";
+    // pointer, custom, none, null, …
+    return "default";
+}

package/dist/web/devtools.d.ts

@@ -0,0 +1,39 @@
+import type { WebContents } from "electron";
+import type { Surface } from "../react";
+import type { DevtoolsDock } from "./types";
+import { PageInput } from "./input";
+import type { SurfaceLayout } from "./types";
+export type DevtoolsAction = "close" | "dock-bottom" | "dock-right";
+export declare class DevtoolsWindow {
+    readonly input: PageInput;
+    private readonly pageContents;
+    private readonly surface;
+    private readonly window;
+    private readonly onAction;
+    private layout;
+    private dock;
+    private visible;
+    private focused;
+    private wholeSurfaceNext;
+    private readonly bitmaps;
+    private cdpAttached;
+    private destroyed;
+    private pendingPanel;
+    cursorShape: string;
+    onCursorChange: ((shape: string) => void) | null;
+    private readonly onDisplayChange;
+    constructor(pageContents: WebContents, surface: Surface, layout: SurfaceLayout, dock: DevtoolsDock, background: string, renderScale: number, onAction: (action: DevtoolsAction) => void, onClosed: () => void);
+    resize(layout: SurfaceLayout, options?: {
+        keepFrame?: boolean;
+    }): void;
+    showPanel(panel: string): void;
+    private execShowPanel;
+    setDock(dock: DevtoolsDock): void;
+    setVisible(visible: boolean): void;
+    focus(): void;
+    blur(): void;
+    close(): void;
+    private installControls;
+    private attachCdp;
+    private cdp;
+}

package/dist/web/devtools.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevtoolsWindow = void 0;
+const electron_1 = require("electron");
+const cursor_1 = require("./cursor");
+const frame_rate_1 = require("./frame-rate");
+const input_1 = require("./input");
+const offscreen_1 = require("./offscreen");
+const paint_1 = require("./paint");
+const types_1 = require("./types");
+class DevtoolsWindow {
+    input;
+    pageContents;
+    surface;
+    window;
+    onAction;
+    layout;
+    dock;
+    visible = true;
+    focused = false;
+    wholeSurfaceNext = true;
+    bitmaps;
+    cdpAttached = false;
+    destroyed = false;
+    pendingPanel = null;
+    cursorShape = "default";
+    onCursorChange = null;
+    onDisplayChange = () => {
+        if (this.destroyed)
+            return;
+        this.window.webContents.setFrameRate(this.visible ? (0, frame_rate_1.frameRate)() : 4);
+    };
+    constructor(pageContents, surface, layout, dock, background, renderScale, onAction, onClosed) {
+        this.pageContents = pageContents;
+        this.surface = surface;
+        this.bitmaps = new paint_1.BitmapPresenter(surface);
+        this.layout = layout;
+        this.dock = dock;
+        this.onAction = onAction;
+        this.window = new electron_1.BrowserWindow({
+            ...(0, types_1.cssSize)(layout.width, layout.height, layout.scale),
+            useContentSize: true,
+            backgroundColor: background,
+            show: false,
+            frame: false,
+            paintWhenInitiallyHidden: true,
+            acceptFirstMouse: true,
+            skipTaskbar: true,
+            fullscreenable: false,
+            resizable: false,
+            webPreferences: {
+                offscreen: (0, offscreen_1.offscreenPreferences)(renderScale),
+                sandbox: true,
+                nodeIntegration: false,
+                contextIsolation: true,
+                disableDialogs: true,
+                backgroundThrottling: false,
+            },
+        });
+        this.input = new input_1.PageInput({
+            contents: () => this.window.webContents,
+            scale: () => this.layout.scale,
+            focus: () => this.focus(),
+            cdp: (method, params) => this.cdp(method, params),
+        });
+        this.window.webContents.setFrameRate((0, frame_rate_1.frameRate)());
+        electron_1.screen.on("display-added", this.onDisplayChange);
+        electron_1.screen.on("display-removed", this.onDisplayChange);
+        electron_1.screen.on("display-metrics-changed", this.onDisplayChange);
+        this.window.webContents.on("paint", (event, dirtyRect, image) => {
+            const shmFrame = event.softwareFrame;
+            if (!this.visible) {
+                event.texture?.release();
+                shmFrame?.release();
+                return;
+            }
+            const presented = event.texture || shmFrame
+                ? (0, paint_1.presentPaint)(this.surface, event.texture, shmFrame, image, dirtyRect, this.wholeSurfaceNext)
+                : this.bitmaps.push(image, dirtyRect, this.wholeSurfaceNext);
+            if (presented) {
+                this.wholeSurfaceNext = false;
+            }
+        });
+        this.window.webContents.on("cursor-changed", (_event, type) => {
+            const shape = (0, cursor_1.cursorShapeFor)(type);
+            if (shape === this.cursorShape)
+                return;
+            this.cursorShape = shape;
+            this.onCursorChange?.(shape);
+        });
+        this.window.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
+        this.window.webContents.on("dom-ready", () => {
+            void this.installControls().catch(() => { });
+            if (this.pendingPanel) {
+                const panel = this.pendingPanel;
+                this.pendingPanel = null;
+                this.execShowPanel(panel);
+            }
+        });
+        this.window.on("closed", () => {
+            this.destroyed = true;
+            this.surface.clear();
+            onClosed();
+        });
+        pageContents.setDevToolsWebContents(this.window.webContents);
+        pageContents.openDevTools({ mode: "detach" }); // not really detached since we are compositing it into one "window"
+    }
+    resize(layout, options) {
+        if (this.destroyed)
+            return;
+        if (this.layout.width === layout.width &&
+            this.layout.height === layout.height &&
+            this.layout.scale === layout.scale) {
+            this.layout = layout;
+            return;
+        }
+        this.layout = layout;
+        if (!options?.keepFrame)
+            this.surface.clear();
+        const size = (0, types_1.cssSize)(layout.width, layout.height, layout.scale);
+        this.window.setContentSize(size.width, size.height, false);
+    }
+    showPanel(panel) {
+        if (this.destroyed)
+            return;
+        const contents = this.window.webContents;
+        if (!contents.getURL().startsWith("devtools://") || contents.isLoading()) {
+            this.pendingPanel = panel;
+            return;
+        }
+        this.execShowPanel(panel);
+    }
+    execShowPanel(panel) {
+        const target = JSON.stringify(panel);
+        void this.window.webContents
+            .executeJavaScript(`(function() {
+          try { localStorage.setItem("panel-selectedTab", JSON.stringify(${target})); } catch (e) {}
+          var tries = 0;
+          var timer = setInterval(function() {
+            if (window.InspectorFrontendAPI && InspectorFrontendAPI.showPanel) {
+              InspectorFrontendAPI.showPanel(${target});
+            }
+            if (++tries >= 8) clearInterval(timer);
+          }, 400);
+        })()`, true)
+            .catch(() => { });
+    }
+    setDock(dock) {
+        if (this.destroyed || this.dock === dock)
+            return;
+        this.dock = dock;
+        void this.window.webContents
+            .executeJavaScript(`window.__pixelDevtoolsSetDock && window.__pixelDevtoolsSetDock(${JSON.stringify(dock)})`, true)
+            .catch(() => { });
+    }
+    setVisible(visible) {
+        if (this.visible === visible || this.destroyed)
+            return;
+        this.visible = visible;
+        if (visible) {
+            // one surface across every tab's inspector, so its pixels belong to whichever one drew last
+            this.wholeSurfaceNext = true;
+            this.window.webContents.setFrameRate((0, frame_rate_1.frameRate)());
+            this.window.webContents.invalidate();
+        }
+        else {
+            this.window.webContents.setFrameRate(4);
+        }
+    }
+    focus() {
+        if (this.focused || this.destroyed)
+            return;
+        this.focused = true;
+        this.window.focus();
+        this.window.webContents.focus();
+        void this.cdp("Emulation.setFocusEmulationEnabled", { enabled: true }).catch(() => { });
+    }
+    blur() {
+        if (!this.focused || this.destroyed)
+            return;
+        this.focused = false;
+        this.input.releaseKeys();
+        this.window.blurWebView();
+        void this.cdp("Emulation.setFocusEmulationEnabled", { enabled: false }).catch(() => { });
+    }
+    close() {
+        if (this.destroyed)
+            return;
+        electron_1.screen.off("display-added", this.onDisplayChange);
+        electron_1.screen.off("display-removed", this.onDisplayChange);
+        electron_1.screen.off("display-metrics-changed", this.onDisplayChange);
+        if (!this.pageContents.isDestroyed())
+            this.pageContents.closeDevTools();
+        this.window.destroy();
+    }
+    async installControls() {
+        await this.attachCdp();
+        await this.window.webContents.executeJavaScript(controlsScript(this.dock), true);
+    }
+    async attachCdp() {
+        if (this.cdpAttached || this.destroyed)
+            return;
+        this.window.webContents.debugger.attach("1.3");
+        this.cdpAttached = true;
+        this.window.webContents.debugger.on("message", (_event, method, params) => {
+            if (method !== "Runtime.bindingCalled")
+                return;
+            const call = params;
+            if (call.name !== "__pixelDevtools")
+                return;
+            if (call.payload === "close" || call.payload === "dock-bottom" || call.payload === "dock-right") {
+                this.onAction(call.payload);
+            }
+        });
+        await this.cdp("Runtime.enable");
+        await this.cdp("Runtime.addBinding", { name: "__pixelDevtools" });
+    }
+    async cdp(method, params) {
+        if (this.destroyed)
+            return undefined;
+        await this.attachCdp();
+        return this.window.webContents.debugger.sendCommand(method, params);
+    }
+}
+exports.DevtoolsWindow = DevtoolsWindow;
+function controlsScript(dock) {
+    return `(function(dock) {
+    if (window.__pixelDevtoolsSetDock) { window.__pixelDevtoolsSetDock(dock); return; }
+    var ICONS = {
+      "dock-bottom": '<svg width="14" height="14" viewBox="0 0 16 16" fill="none"><rect x="1.5" y="2.5" width="13" height="11" rx="1.5" stroke="currentColor"/><rect x="3.5" y="8.5" width="9" height="3" fill="currentColor"/></svg>',
+      "dock-right": '<svg width="14" height="14" viewBox="0 0 16 16" fill="none"><rect x="1.5" y="2.5" width="13" height="11" rx="1.5" stroke="currentColor"/><rect x="8.5" y="4.5" width="4" height="7" fill="currentColor"/></svg>',
+      "close": '<svg width="14" height="14" viewBox="0 0 16 16" fill="none"><path d="M4 4l8 8M12 4l-8 8" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/></svg>'
+    };
+    var findToolbar = function() {
+      // the drawer's tabbed pane can precede the main one in document order;
+      // mounting there puts the buttons in the drawer strip instead of the
+      // top tab bar
+      var panes = document.querySelectorAll(".main-tabbed-pane");
+      if (!panes.length) panes = document.querySelectorAll(".tabbed-pane");
+      for (var i = 0; i < panes.length; i++) {
+        var root = panes[i].shadowRoot;
+        var bar = root && root.querySelector(".tabbed-pane-right-toolbar");
+        if (bar) return { bar: bar, header: root.querySelector(".tabbed-pane-header") };
+      }
+      return null;
+    };
+    var buttons = {};
+    var makeButton = function(action) {
+      var b = document.createElement("button");
+      b.title = action === "close" ? "Close DevTools"
+        : action === "dock-bottom" ? "Dock to bottom" : "Dock to right";
+      b.style.cssText = "all:unset;box-sizing:border-box;width:24px;height:24px;" +
+        "display:flex;align-items:center;justify-content:center;border-radius:4px;" +
+        "color:var(--sys-color-on-surface-subtle, #5f6368);";
+      b.innerHTML = ICONS[action];
+      b.onmouseenter = function() { b.style.background = "var(--sys-color-state-hover-on-subtle, rgba(125,125,125,.15))"; };
+      b.onmouseleave = function() { b.style.background = "transparent"; };
+      b.onclick = function() { window.__pixelDevtools(action); };
+      buttons[action] = b;
+      return b;
+    };
+    var makeHost = function(id, floatCss) {
+      var host = document.createElement("div");
+      host.id = id;
+      host.style.cssText = "display:flex;align-items:center;gap:2px;flex-shrink:0;margin:0 4px;" + floatCss;
+      return host;
+    };
+    var mount = function(found) {
+      var dockHost = makeHost("__pixel-devtools-dock", found ? "" : "position:fixed;top:4px;right:132px;z-index:100000;");
+      dockHost.appendChild(makeButton("dock-bottom"));
+      dockHost.appendChild(makeButton("dock-right"));
+      // the close button goes at the end of the header row (the ⚠/gear/⋮
+      // icons are siblings of the right toolbar), right-most like the native
+      // devtools close
+      var closeHost = makeHost("__pixel-devtools-close", found ? "" : "position:fixed;top:4px;right:4px;z-index:100000;");
+      closeHost.appendChild(makeButton("close"));
+      window.__pixelDevtoolsSetDock = function(d) {
+        var active = "var(--sys-color-primary-bright, #1a73e8)";
+        var idle = "var(--sys-color-on-surface-subtle, #5f6368)";
+        buttons["dock-bottom"].style.color = d === "bottom" ? active : idle;
+        buttons["dock-right"].style.color = d === "right" ? active : idle;
+      };
+      window.__pixelDevtoolsSetDock(dock);
+      if (found) {
+        found.bar.insertBefore(dockHost, found.bar.firstChild);
+        (found.header || found.bar).appendChild(closeHost);
+      } else {
+        document.documentElement.appendChild(dockHost);
+        document.documentElement.appendChild(closeHost);
+      }
+    };
+    var tries = 0;
+    var timer = setInterval(function() {
+      tries++;
+      var found = findToolbar();
+      if (found) { clearInterval(timer); mount(found); }
+      else if (tries > 20) { clearInterval(timer); mount(null); }
+    }, 250);
+  })(${JSON.stringify(dock)})`;
+}

package/dist/web/favicon.d.ts

@@ -0,0 +1,7 @@
+import type { Session } from "electron";
+export declare class FaviconCache {
+    private readonly dir;
+    constructor(dir?: string);
+    resolve(urls: string[], ses: Session): Promise<string | null>;
+    private fetchDecodable;
+}

package/dist/web/favicon.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FaviconCache = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const electron_1 = require("electron");
+const RASTER_URL = /\.(png|jpe?g|webp|gif)(\?|$)/i;
+function isIco(data) {
+    return data.length > 4 && data[0] === 0 && data[1] === 0 && data[2] === 1 && data[3] === 0;
+}
+class FaviconCache {
+    dir;
+    constructor(dir = node_path_1.default.join(electron_1.app.getPath("userData"), "favicons")) {
+        this.dir = dir;
+    }
+    async resolve(urls, ses) {
+        if (urls.length === 0)
+            return null;
+        const candidates = [...urls].sort((a, b) => Number(RASTER_URL.test(b)) - Number(RASTER_URL.test(a)));
+        try {
+            const fallback = new URL("/favicon.ico", urls[0]).toString();
+            if (!candidates.includes(fallback))
+                candidates.push(fallback);
+        }
+        catch { }
+        const stem = node_path_1.default.join(this.dir, node_crypto_1.default
+            .createHash("sha1")
+            .update(`${ses.storagePath ?? ""}\0${candidates.join("\n")}`)
+            .digest("hex")
+            .slice(0, 16));
+        const cached = [`${stem}.png`, `${stem}.ico`].find((file) => node_fs_1.default.existsSync(file));
+        if (cached)
+            return cached;
+        for (const url of candidates) {
+            const file = await this.fetchDecodable(url, ses, stem);
+            if (file)
+                return file;
+        }
+        return null;
+    }
+    async fetchDecodable(url, ses, stem) {
+        try {
+            const response = await ses.fetch(url);
+            if (!response.ok)
+                return null;
+            const data = Buffer.from(await response.arrayBuffer());
+            if (data.length === 0)
+                return null;
+            const decoded = electron_1.nativeImage.createFromBuffer(data);
+            if (!decoded.isEmpty()) {
+                const file = `${stem}.png`;
+                node_fs_1.default.mkdirSync(this.dir, { recursive: true });
+                await node_fs_1.default.promises.writeFile(file, decoded.resize({ width: 32, height: 32 }).toPNG());
+                return file;
+            }
+            if (isIco(data)) {
+                const file = `${stem}.ico`;
+                node_fs_1.default.mkdirSync(this.dir, { recursive: true });
+                await node_fs_1.default.promises.writeFile(file, data);
+                return file;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.FaviconCache = FaviconCache;

package/dist/web/frame-rate.d.ts

@@ -0,0 +1 @@
+export declare function frameRate(): number;

package/dist/web/frame-rate.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frameRate = frameRate;
+const electron_1 = require("electron");
+function frameRate() {
+    const configured = Number(process.env.PIXEL_FPS);
+    if (Number.isFinite(configured) && configured > 0) {
+        return Math.max(1, Math.min(240, Math.round(configured)));
+    }
+    const fastest = Math.max(0, ...electron_1.screen.getAllDisplays().map((display) => display.displayFrequency));
+    return fastest > 0 ? Math.min(240, Math.round(fastest)) : 60;
+}