@owear/core 0.1.0 → 0.1.3

package/dist/app.d.ts

@@ -0,0 +1,122 @@
+import { type ForkWorkerOptions, type WorkerHandle } from './node/worker.js';
+import type { MessagePortMain } from './port.js';
+import type { ProtocolHandler } from './protocol.js';
+import type { NodeHandler, ContextNodeHandler } from './ipc/node.js';
+/** Resuelto por app.whenReady(). Compartido con BrowserWindow. */
+export declare let readyPromise: Promise<void> | null;
+export declare const app: {
+    /** Conecta con el kernel. Resuelve cuando el canal de control está listo. */
+    whenReady(): Promise<void>;
+    quit(exitCode?: number): Promise<void>;
+    info(): Promise<{
+        pid: number;
+        version: string;
+        socket: string;
+    }>;
+    /** Ruta estándar del sistema (home, userData, temp, logs, downloads, exe…). */
+    getPath(name: string): string;
+    setPath(name: string, value: string): void;
+    getName(): string;
+    setName(name: string): void;
+    /** Versión de la app (package.json); si no, la del kernel. */
+    getVersion(): string;
+    isPackaged(): boolean;
+    getAppPath(): string;
+    /**
+     * Opciones de línea de comandos del WebView. `appendSwitch` se aplica al
+     * crear la ventana (Windows: AdditionalBrowserArguments; Linux: best-effort).
+     */
+    commandLine: {
+        _switches: Map<string, string | undefined>;
+        appendSwitch(key: string, value?: string): void;
+        appendArgument(arg: string): void;
+        getSwitchValue(key: string): string;
+        hasSwitch(key: string): boolean;
+    };
+    on(event: "before-quit" | "will-quit" | "window-all-closed" | "second-instance" | "activate" | "child-process-gone" | string, listener: (...args: any[]) => void): void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    once(event: string, listener: (...args: any[]) => void): void;
+    /**
+     * Localiza (o descarga) un runtime Node. Prioridad: OW_NODE_BIN → Node del
+     * sistema → caché de Owear → descarga oficial. `source` indica de dónde
+     * salió ("env" | "system" | "cache" | "downloaded").
+     */
+    ensureNodeRuntime(range?: string): Promise<{
+        path: string;
+        version: string;
+        source: string;
+    }>;
+    /** Acceso crudo al canal (para módulos custom del SDK). */
+    __channel: import("./channel.js").ControlChannel;
+    /**
+     * Registra un handler invocable desde el renderer con
+     * `ow.invoke('node', 'call', { fn, args })`. Devuelve un unsubscribe.
+     * Es la vía para exponer Node a la UI (extension host, libs Node-only).
+     */
+    handle(fn: string, handler: NodeHandler): () => void;
+    /**
+     * Como `handle`, pero el handler recibe la ventana de origen:
+     *   app.handleContext('x', (ctx, payload) => ctx.windowId)
+     * `ctx.windowId` es 0 si la llamada no vino de una ventana concreta.
+     */
+    handleContext(fn: string, handler: ContextNodeHandler): () => void;
+    /**
+     * Empuja un evento a los renderers, recibible con `ow.on(name, cb)`.
+     * `windowId` opcional para dirigirlo a una ventana concreta.
+     */
+    send(name: string, payload?: unknown, windowId?: number): Promise<void>;
+    /**
+     * Lanza un worker Node con canal de mensajes (reemplazo de
+     * `utilityProcess.fork`). El entry puede ser absoluto, relativo a
+     * `app.workersDir()`, o con `./` relativo al cwd.
+     *
+     *   const w = app.forkWorker('tree-sitter-worker.js')
+     *   w.postMessage({ op: 'tokenize', text })
+     *   w.on('message', (m) => …)
+     */
+    forkWorker(entry: string, options?: ForkWorkerOptions): WorkerHandle;
+    /** Directorio de workers compilados (`OW_APP_WORKERS`), si `ow dev`/`ow build` lo definió. */
+    workersDir(): string | undefined;
+    /**
+     * Crea un canal bidireccional de dos puertos. Ambos nacen en el main;
+     * transfiere uno a un renderer con `app.sendPort(windowId, name, port)`.
+     * El renderer lo recibe con `ow.on(name, ({ port }) => ow.port(port))`.
+     */
+    createChannel(): {
+        port1: MessagePortMain;
+        port2: MessagePortMain;
+    };
+    /**
+     * Transfiere un puerto a una ventana. El renderer lo recibe como
+     * `ow.on(name, ({ port }) => { const p = ow.port(port); … })`.
+     */
+    sendPort(windowId: number, name: string, port: MessagePortMain): Promise<void>;
+    /**
+     * Registra un esquema personalizado (protocol API, estilo intermedio):
+     *   app.protocol('scrakk-ext', { privileged: { secure: true, cors: true },
+     *     handler: async (req) => new Response('<h1>hola</h1>', { headers: {...} }) })
+     *   app.protocol('assets', { serve: '/ruta/al/dir' })  // el kernel sirve el dir
+     * El handler corre en el main (Node); puede devolver un `Response`, un objeto
+     * `{ status, headers, body }`, un string o `null`.
+     */
+    protocol(name: string, options?: {
+        privileged?: {
+            secure?: boolean;
+            cors?: boolean;
+            stream?: boolean;
+            standard?: boolean;
+            fetch?: boolean;
+        };
+        serve?: string;
+        handler?: ProtocolHandler;
+    }): Promise<void>;
+};
+/**
+ * Invoca una función de un módulo nativo del kernel desde el proceso
+ * principal (fs, process, net, clipboard…). Es el equivalente de `ow.invoke()`
+ * del renderer, pero sin depender de una ventana: es la pieza que permite
+ * portar APIs de Electron al main process.
+ *
+ *   const txt = await invokeNative<string>('fs', 'readText', '/etc/hostname')
+ */
+export { invokeNative } from './channel.js';

package/dist/app.js

@@ -0,0 +1,276 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/app.ts — ciclo de vida, rutas, identidad y commandLine.
+import { EventEmitter } from 'node:events';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { channel, socketPathFromEnv } from './channel.js';
+import { forkWorker } from './node/worker.js';
+import { nodeHandlers, nodeContextHandlers } from './ipc/node.js';
+import { portRecords, makeMainPort, allocPortId } from './port.js';
+import { protocolHandlers } from './protocol.js';
+/** Resuelto por app.whenReady(). Compartido con BrowserWindow. */
+export let readyPromise = null;
+// ── app: rutas, identidad, commandLine y eventos de ciclo de vida ──────────
+const appEmitter = new EventEmitter();
+let appNameOverride = null;
+let appInfoCache = null;
+const pathOverrides = new Map();
+channel.on('app.event', (params) => {
+    appEmitter.emit(params?.name, params?.payload);
+});
+function readPackageJson() {
+    const dirs = [
+        process.cwd(),
+        process.env.OW_APP_MAIN ? path.dirname(process.env.OW_APP_MAIN) : '',
+        process.env.OW_ASSETS_DIR ?? '',
+    ];
+    for (const dir of dirs) {
+        if (!dir)
+            continue;
+        try {
+            return JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        }
+        catch {
+            /* siguiente */
+        }
+    }
+    return {};
+}
+const appPkg = readPackageJson();
+function appId() {
+    return process.env.OW_APP_ID || process.env.OW_APP_NAME || appPkg.name || 'app';
+}
+/** Rutas síncronas estilo Electron (mismas convenciones que el módulo `path`). */
+function computePath(name) {
+    const home = os.homedir();
+    const win = process.platform === 'win32';
+    const appData = win
+        ? process.env.APPDATA ?? path.join(home, 'AppData', 'Roaming')
+        : process.env.XDG_DATA_HOME ?? path.join(home, '.local', 'share');
+    const localData = win
+        ? process.env.LOCALAPPDATA ?? path.join(home, 'AppData', 'Local')
+        : process.env.XDG_DATA_HOME ?? path.join(home, '.local', 'share');
+    switch (name) {
+        case 'home':
+            return home;
+        case 'appData':
+            return appData;
+        case 'userData':
+            return win ? path.join(localData, appId()) : path.join(process.env.XDG_CONFIG_HOME ?? path.join(home, '.config'), appId());
+        case 'sessionData':
+            return appInfoCache?.appPath ? path.join(appInfoCache.appPath, 'session') : path.join(localData, appId(), 'session');
+        case 'cache':
+            return win ? path.join(localData, 'owear', 'cache') : process.env.XDG_CACHE_HOME ?? path.join(home, '.cache');
+        case 'temp':
+            return os.tmpdir();
+        case 'logs':
+            return path.join(computePath('userData'), 'logs');
+        case 'downloads':
+            return win ? path.join(home, 'Downloads') : (process.env.XDG_DOWNLOAD_DIR ?? path.join(home, 'Downloads'));
+        case 'documents':
+            return path.join(home, 'Documents');
+        case 'desktop':
+            return path.join(home, 'Desktop');
+        case 'pictures':
+            return path.join(home, 'Pictures');
+        case 'music':
+            return path.join(home, 'Music');
+        case 'videos':
+            return path.join(home, 'Videos');
+        case 'exe':
+            return appInfoCache?.exePath ?? path.dirname(process.execPath);
+        case 'appPath':
+            return appInfoCache?.appPath ?? process.cwd();
+        default:
+            return '';
+    }
+}
+export const app = {
+    /** Conecta con el kernel. Resuelve cuando el canal de control está listo. */
+    whenReady() {
+        if (!readyPromise) {
+            readyPromise = channel.connect(socketPathFromEnv()).then(async () => {
+                try {
+                    appInfoCache = await channel.call('app.info');
+                }
+                catch {
+                    /* sin kernel: rutas locales */
+                }
+            });
+        }
+        return readyPromise;
+    },
+    quit(exitCode = 0) {
+        return channel.call('app.quit', { exitCode }).catch(() => undefined);
+    },
+    info() {
+        return channel.call('app.info');
+    },
+    // ── rutas / identidad (estilo Electron) ────────────────────────────────
+    /** Ruta estándar del sistema (home, userData, temp, logs, downloads, exe…). */
+    getPath(name) {
+        return pathOverrides.get(name) ?? computePath(name);
+    },
+    setPath(name, value) {
+        pathOverrides.set(name, value);
+    },
+    getName() {
+        return appNameOverride ?? appInfoCache?.name ?? process.env.OW_APP_NAME ?? appPkg.name ?? 'Owear App';
+    },
+    setName(name) {
+        appNameOverride = name;
+        void channel.call('app.setName', { name }).catch(() => undefined);
+    },
+    /** Versión de la app (package.json); si no, la del kernel. */
+    getVersion() {
+        return appPkg.version ?? appInfoCache?.version ?? '0.0.0';
+    },
+    isPackaged() {
+        return !!appInfoCache?.packaged;
+    },
+    getAppPath() {
+        return appInfoCache?.appPath ?? process.cwd();
+    },
+    /**
+     * Opciones de línea de comandos del WebView. `appendSwitch` se aplica al
+     * crear la ventana (Windows: AdditionalBrowserArguments; Linux: best-effort).
+     */
+    commandLine: {
+        _switches: new Map(),
+        appendSwitch(key, value) {
+            this._switches.set(key, value);
+            void channel.call('app.commandLine.appendSwitch', { key, value }).catch(() => undefined);
+        },
+        appendArgument(arg) {
+            void channel.call('app.commandLine.appendArgument', { arg }).catch(() => undefined);
+        },
+        getSwitchValue(key) {
+            return this._switches.get(key) ?? '';
+        },
+        hasSwitch(key) {
+            return this._switches.has(key);
+        },
+    },
+    // ── eventos de ciclo de vida (EventEmitter) ────────────────────────────
+    on(event, listener) {
+        appEmitter.on(event, listener);
+    },
+    off(event, listener) {
+        appEmitter.off(event, listener);
+    },
+    once(event, listener) {
+        appEmitter.once(event, listener);
+    },
+    /**
+     * Localiza (o descarga) un runtime Node. Prioridad: OW_NODE_BIN → Node del
+     * sistema → caché de Owear → descarga oficial. `source` indica de dónde
+     * salió ("env" | "system" | "cache" | "downloaded").
+     */
+    ensureNodeRuntime(range = 'latest') {
+        return channel.call('node.ensure', { range });
+    },
+    /** Acceso crudo al canal (para módulos custom del SDK). */
+    __channel: channel,
+    /**
+     * Registra un handler invocable desde el renderer con
+     * `ow.invoke('node', 'call', { fn, args })`. Devuelve un unsubscribe.
+     * Es la vía para exponer Node a la UI (extension host, libs Node-only).
+     */
+    handle(fn, handler) {
+        nodeHandlers.set(fn, handler);
+        return () => {
+            if (nodeHandlers.get(fn) === handler)
+                nodeHandlers.delete(fn);
+        };
+    },
+    /**
+     * Como `handle`, pero el handler recibe la ventana de origen:
+     *   app.handleContext('x', (ctx, payload) => ctx.windowId)
+     * `ctx.windowId` es 0 si la llamada no vino de una ventana concreta.
+     */
+    handleContext(fn, handler) {
+        nodeContextHandlers.set(fn, handler);
+        return () => {
+            if (nodeContextHandlers.get(fn) === handler)
+                nodeContextHandlers.delete(fn);
+        };
+    },
+    /**
+     * Empuja un evento a los renderers, recibible con `ow.on(name, cb)`.
+     * `windowId` opcional para dirigirlo a una ventana concreta.
+     */
+    send(name, payload, windowId) {
+        return channel.call('node.emit', { name, payload, windowId });
+    },
+    /**
+     * Lanza un worker Node con canal de mensajes (reemplazo de
+     * `utilityProcess.fork`). El entry puede ser absoluto, relativo a
+     * `app.workersDir()`, o con `./` relativo al cwd.
+     *
+     *   const w = app.forkWorker('tree-sitter-worker.js')
+     *   w.postMessage({ op: 'tokenize', text })
+     *   w.on('message', (m) => …)
+     */
+    forkWorker(entry, options) {
+        return forkWorker(entry, options);
+    },
+    /** Directorio de workers compilados (`OW_APP_WORKERS`), si `ow dev`/`ow build` lo definió. */
+    workersDir() {
+        return process.env.OW_APP_WORKERS;
+    },
+    /**
+     * Crea un canal bidireccional de dos puertos. Ambos nacen en el main;
+     * transfiere uno a un renderer con `app.sendPort(windowId, name, port)`.
+     * El renderer lo recibe con `ow.on(name, ({ port }) => ow.port(port))`.
+     */
+    createChannel() {
+        const a = allocPortId();
+        const b = allocPortId();
+        portRecords.set(a, { id: a, peer: b, side: { kind: 'main' }, emitter: new EventEmitter() });
+        portRecords.set(b, { id: b, peer: a, side: { kind: 'main' }, emitter: new EventEmitter() });
+        return { port1: makeMainPort(a), port2: makeMainPort(b) };
+    },
+    /**
+     * Transfiere un puerto a una ventana. El renderer lo recibe como
+     * `ow.on(name, ({ port }) => { const p = ow.port(port); … })`.
+     */
+    sendPort(windowId, name, port) {
+        const rec = portRecords.get(port.portId);
+        if (rec)
+            rec.side = { kind: 'renderer', windowId };
+        return channel.call('node.emit', {
+            name,
+            payload: { port: port.portId },
+            windowId,
+        });
+    },
+    /**
+     * Registra un esquema personalizado (protocol API, estilo intermedio):
+     *   app.protocol('scrakk-ext', { privileged: { secure: true, cors: true },
+     *     handler: async (req) => new Response('<h1>hola</h1>', { headers: {...} }) })
+     *   app.protocol('assets', { serve: '/ruta/al/dir' })  // el kernel sirve el dir
+     * El handler corre en el main (Node); puede devolver un `Response`, un objeto
+     * `{ status, headers, body }`, un string o `null`.
+     */
+    protocol(name, options = {}) {
+        protocolHandlers.set(name, options.handler);
+        return channel.call('protocol.register', {
+            scheme: name,
+            privileged: options.privileged,
+            dir: options.serve,
+            handler: typeof options.handler === 'function',
+        });
+    },
+};
+/**
+ * Invoca una función de un módulo nativo del kernel desde el proceso
+ * principal (fs, process, net, clipboard…). Es el equivalente de `ow.invoke()`
+ * del renderer, pero sin depender de una ventana: es la pieza que permite
+ * portar APIs de Electron al main process.
+ *
+ *   const txt = await invokeNative<string>('fs', 'readText', '/etc/hostname')
+ */
+export { invokeNative } from './channel.js';

package/dist/bridge.d.ts

@@ -0,0 +1,79 @@
+export type BridgePlatform = 'linux' | 'win' | 'mac' | (string & {});
+/** Identidad de la app que se instala. */
+export interface BridgeApp {
+    /** Id estable/pkg-name (reverse-DNS recomendado): com.acme.miapp. */
+    id: string;
+    name: string;
+    version: string;
+    publisher?: string;
+    /** Icono relativo al payload (png/svg/ico). */
+    icon?: string;
+}
+/** Formato de salida del payload que el instalador coloca. */
+export type BridgeFormat = 'binary' | 'deb' | 'appimage' | 'exe' | 'msi';
+/** Layout del payload: `minimal` = 1 binario; `layout` = árbol organizado. */
+export type BridgeLayout = 'minimal' | 'layout';
+export type BridgePreset = 'electron-like' | 'tauri-like' | 'flat' | 'custom';
+/** Cómo resolver el runtime Node de la app instalada. */
+export interface BridgeNode {
+    mode?: 'system' | 'download' | 'embed';
+}
+/** Qué se compila/embebe y en qué orden (grupos lógicos). */
+export type BridgeGroup = 'kernel' | 'node' | 'modules:stock' | 'modules:app' | 'app:main' | 'app:workers' | 'app:assets' | 'resources';
+/** Protección por grupo dentro del binario/payload. */
+export interface BridgeProtect {
+    integrity?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    signed?: boolean;
+}
+/** Configuración por plataforma. */
+export interface BridgeTarget {
+    format?: BridgeFormat[];
+    layout?: BridgeLayout;
+    /** Preset de estructura para `layout` (o 'custom'). */
+    preset?: BridgePreset;
+    /** Directorio de instalación por defecto (per-user recomendado). */
+    dir?: string;
+    shortcuts?: Array<'desktop' | 'menu' | 'startup' | 'startMenu'>;
+    /** Scope de instalación por defecto. */
+    scope?: 'user' | 'system';
+}
+/**
+ * Pasos que el instalador ejecuta. Son NOMBRES de hooks implementados en el
+ * instalador (su `app/main.ts`), no funciones: el bridge debe ser serializable.
+ */
+export interface BridgeHooks {
+    preInstall?: string;
+    postInstall?: string;
+    preUninstall?: string;
+    postUninstall?: string;
+}
+/** Contrato completo app ↔ installer. */
+export interface OwearBridge {
+    /** Versión del formato del bridge (para compatibilidad). */
+    bridgeVersion?: number;
+    app: BridgeApp;
+    targets: Partial<Record<BridgePlatform, BridgeTarget>>;
+    /** Orden de grupos al empaquetar/colocar (sobreescribe el preset). */
+    order?: BridgeGroup[];
+    /** Protección por grupo (integridad/flags). */
+    protect?: Partial<Record<BridgeGroup, BridgeProtect>>;
+    node?: BridgeNode;
+    hooks?: BridgeHooks;
+}
+/**
+ * Define el bridge con tipado y validación.
+ *
+ *   // owear.bridge.ts
+ *   import { defineBridge } from '@owear/core'
+ *   export default defineBridge({
+ *     app: { id: 'com.acme.miapp', name: 'MiApp', version: '1.0.0' },
+ *     targets: {
+ *       linux: { layout: 'minimal', format: ['binary'], shortcuts: ['desktop'] },
+ *       win:   { layout: 'layout',  format: ['exe'],     shortcuts: ['startMenu'] },
+ *     },
+ *     order: ['kernel','modules:stock','app:main','app:assets'],
+ *   })
+ */
+export declare function defineBridge(b: OwearBridge): OwearBridge;

package/dist/bridge.js

@@ -0,0 +1,55 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/bridge.ts — contrato (bridge) app ↔ installer ↔ uninstaller.
+//
+// El bridge es un fichero `owear.bridge.ts` (o `.js`) SIEMPRE presente en la
+// app. `ow build installer` lo compila y lo embebe en el binario instalador
+// como `bridge.json`, de modo que el instalador conoce la app sin adivinarla.
+//
+// El bridge es DATO puro (serializable a JSON): no metas funciones aquí. Los
+// pasos que quieras ejecutar (hooks) se declaran por nombre y los implementa el
+// propio instalador en su `app/main.ts`.
+/** Comprueba que el bridge es utilizable (falla pronto, en build). */
+function validateBridge(b) {
+    const err = (m) => {
+        throw new Error(`[owear.bridge] ${m}`);
+    };
+    if (!b || typeof b !== 'object')
+        err('el bridge debe ser un objeto (export default)');
+    if (!b.app?.id)
+        err('app.id requerido');
+    if (!b.app?.version)
+        err('app.version requerido');
+    if (!b.targets || typeof b.targets !== 'object')
+        err('targets requerido');
+    for (const [plat, t] of Object.entries(b.targets)) {
+        if (t?.layout && t.layout !== 'minimal' && t.layout !== 'layout')
+            err(`targets.${plat}.layout inválido: ${t.layout}`);
+    }
+    // Serializabilidad: el bridge se embebe como JSON (nada de funciones).
+    try {
+        JSON.stringify(b);
+    }
+    catch {
+        err('el bridge no es serializable (¿metiste una función?)');
+    }
+}
+/**
+ * Define el bridge con tipado y validación.
+ *
+ *   // owear.bridge.ts
+ *   import { defineBridge } from '@owear/core'
+ *   export default defineBridge({
+ *     app: { id: 'com.acme.miapp', name: 'MiApp', version: '1.0.0' },
+ *     targets: {
+ *       linux: { layout: 'minimal', format: ['binary'], shortcuts: ['desktop'] },
+ *       win:   { layout: 'layout',  format: ['exe'],     shortcuts: ['startMenu'] },
+ *     },
+ *     order: ['kernel','modules:stock','app:main','app:assets'],
+ *   })
+ */
+export function defineBridge(b) {
+    validateBridge(b);
+    return { bridgeVersion: 1, ...b };
+}

package/dist/browserwindow.d.ts

@@ -0,0 +1,113 @@
+import { EventEmitter } from 'node:events';
+import type { WindowOptions, Bounds } from './index.js';
+import { WebContents } from './webcontents.js';
+/** Registro de ventanas por id (para resolver clicks de menú). */
+export declare const windowsById: Map<number, BrowserWindow>;
+export declare class BrowserWindow extends EventEmitter {
+    private _id;
+    private _options;
+    private _wc;
+    private _onWindowEvent;
+    private _onDisconnected;
+    constructor(options?: WindowOptions);
+    private _create;
+    private _wireEvents;
+    private _unwireEvents;
+    get id(): number | null;
+    private requireId;
+    loadURL(url: string): Promise<void>;
+    /** Evalúa JS; devuelve el resultado JSON-serializado. */
+    eval<T = unknown>(js: string): Promise<T>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    focus(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    minimize(): Promise<void>;
+    maximize(): Promise<void>;
+    unmaximize(): Promise<void>;
+    setFullScreen(enabled: boolean): Promise<void>;
+    /**
+     * Responde a un `closeRequested` (F3.4).
+     * `allow=false` cancela el cierre; `true` destruye la ventana.
+     * Si nadie responde en `OW_CLOSE_TIMEOUT_MS` (default 1000 ms), el kernel
+     * cierra igualmente.
+     */
+    closeRespond(requestId: number, allow: boolean): Promise<void>;
+    isMaximized(): Promise<boolean>;
+    isMinimized(): Promise<boolean>;
+    getBounds(): Promise<Bounds>;
+    setBounds(b: Partial<Bounds>): Promise<void>;
+    setTitle(title: string): Promise<void>;
+    /**
+     * Activa/desactiva o reconfigura los botones nativos de ventana
+     * (min/max/close) dentro de la titlebar custom (Linux: GTK `titlebutton`).
+     * `true` los activa con los valores por defecto.
+     */
+    setTitleBarOverlay(overlay: boolean | {
+        enabled?: boolean;
+        color?: string;
+        symbolColor?: string;
+        buttonColor?: string;
+        height?: number;
+    }): Promise<void>;
+    isVisible(): Promise<boolean>;
+    isFocused(): Promise<boolean>;
+    isResizable(): Promise<boolean>;
+    isMovable(): Promise<boolean>;
+    isMinimizable(): Promise<boolean>;
+    isMaximizable(): Promise<boolean>;
+    isClosable(): Promise<boolean>;
+    isAlwaysOnTop(): Promise<boolean>;
+    isKiosk(): Promise<boolean>;
+    isDestroyed(): Promise<boolean>;
+    isFullScreen(): Promise<boolean>;
+    setResizable(on?: boolean): Promise<void>;
+    setMovable(on?: boolean): Promise<void>;
+    setMinimizable(on?: boolean): Promise<void>;
+    setMaximizable(on?: boolean): Promise<void>;
+    setClosable(on?: boolean): Promise<void>;
+    setAlwaysOnTop(on?: boolean, level?: number): Promise<void>;
+    setSkipTaskbar(on?: boolean): Promise<void>;
+    setHasShadow(on?: boolean): Promise<void>;
+    setKiosk(on?: boolean): Promise<void>;
+    setIgnoreMouseEvents(ignore?: boolean, options?: {
+        forward?: boolean;
+    }): Promise<void>;
+    setProgressBar(value: number, options?: {
+        mode?: 'none' | 'normal' | 'indeterminate' | 'paused' | 'error';
+    }): Promise<void>;
+    setBackgroundColor(color: string): Promise<void>;
+    moveTop(): Promise<void>;
+    setAspectRatio(ratio: number, extraSize?: {
+        width: number;
+        height: number;
+    }): Promise<void>;
+    getContentBounds(): Promise<Bounds>;
+    setContentSize(width: number, height: number): Promise<void>;
+    getContentSize(): Promise<{
+        width: number;
+        height: number;
+    }>;
+    getMinimumSize(): Promise<{
+        width: number;
+        height: number;
+    }>;
+    getMaximumSize(): Promise<{
+        width: number;
+        height: number;
+    }>;
+    setMinimumSize(width: number, height: number): Promise<void>;
+    setMaximumSize(width: number, height: number): Promise<void>;
+    /** Ventanas creadas por esta app (orden de creación). Síncrono, como Electron. */
+    static getAllWindows(): BrowserWindow[];
+    /** Ventana con foco, o `null`. Síncrono, como Electron. */
+    static getFocusedWindow(): BrowserWindow | null;
+    static fromId(id: number): BrowserWindow | null;
+    /**
+     * `webContents` de esta ventana (estilo Electron): `send`, `capturePage`,
+     * eventos (`did-finish-load`, `before-input-event`, …) y
+     * `setWindowOpenHandler`.
+     */
+    get webContents(): WebContents;
+}