@owear/core 0.1.0 → 0.1.3

package/dist/browserwindow.js

@@ -0,0 +1,226 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/browserwindow.ts — BrowserWindow (C9).
+import { EventEmitter } from 'node:events';
+import { channel } from './channel.js';
+import { readyPromise } from './app.js';
+import { WebContents, WIN_EVENT_NAMES, WC_EVENT_NAMES } from './webcontents.js';
+// ── BrowserWindow ───────────────────────────────────────────────────────────
+/** Registro de ventanas por id (para resolver clicks de menú). */
+export const windowsById = new Map();
+/** Ventana con foco (para `BrowserWindow.getFocusedWindow`). */
+let focusedWindowId = 0;
+export class BrowserWindow extends EventEmitter {
+    _id = null;
+    _options;
+    _wc = new WebContents(null);
+    _onWindowEvent;
+    _onDisconnected;
+    constructor(options = {}) {
+        super();
+        this._options = options;
+        if (!readyPromise) {
+            throw new Error('BrowserWindow creado antes de app.whenReady()');
+        }
+        this._onWindowEvent = (params) => {
+            if (params.windowId !== this._id)
+                return;
+            this.emit(params.name, params.payload);
+            const dashWin = WIN_EVENT_NAMES[params.name];
+            if (dashWin)
+                this.emit(dashWin, params.payload);
+            this._wc.emit(WC_EVENT_NAMES[params.name] ?? params.name, params.payload);
+            if (params.name === 'focus' && this._id != null)
+                focusedWindowId = this._id;
+            if (params.name === 'blur' && this._id != null && focusedWindowId === this._id)
+                focusedWindowId = 0;
+            if (params.name === 'closed') {
+                if (this._id != null)
+                    windowsById.delete(this._id);
+                this._unwireEvents();
+            }
+        };
+        this._onDisconnected = () => this.emit('disconnected');
+        readyPromise.then(() => this._create()).catch((e) => this.emit('error', e));
+    }
+    async _create() {
+        const params = { ...this._options };
+        const res = await channel.call('window.create', params);
+        this._id = res.windowId;
+        this._wc._setWindowId(res.windowId);
+        windowsById.set(res.windowId, this);
+        this._wireEvents();
+        this.emit('ready-to-show', this._id);
+    }
+    _wireEvents() {
+        channel.on('window.event', this._onWindowEvent);
+        channel.on('disconnected', this._onDisconnected);
+    }
+    _unwireEvents() {
+        channel.off('window.event', this._onWindowEvent);
+        channel.off('disconnected', this._onDisconnected);
+    }
+    get id() {
+        return this._id;
+    }
+    requireId() {
+        if (this._id == null)
+            throw new Error('ventana aún no creada');
+        return this._id;
+    }
+    // ── carga ──────────────────────────────────────────────────────────────
+    loadURL(url) {
+        return channel.call('window.loadURL', { windowId: this.requireId(), url });
+    }
+    /** Evalúa JS; devuelve el resultado JSON-serializado. */
+    eval(js) {
+        return channel.call('window.eval', { windowId: this.requireId(), js });
+    }
+    // ── ciclo de vida ──────────────────────────────────────────────────────
+    show() {
+        return channel.call('window.show', { windowId: this.requireId() });
+    }
+    hide() {
+        return channel.call('window.hide', { windowId: this.requireId() });
+    }
+    focus() {
+        return channel.call('window.focus', { windowId: this.requireId() });
+    }
+    close() {
+        return channel.call('window.close', { windowId: this.requireId() });
+    }
+    destroy() {
+        return channel.call('window.destroy', { windowId: this.requireId() });
+    }
+    minimize() {
+        return channel.call('window.minimize', { windowId: this.requireId() });
+    }
+    maximize() {
+        return channel.call('window.maximize', { windowId: this.requireId(), enabled: true });
+    }
+    unmaximize() {
+        return channel.call('window.maximize', { windowId: this.requireId(), enabled: false });
+    }
+    setFullScreen(enabled) {
+        return channel.call('window.setFullScreen', { windowId: this.requireId(), enabled });
+    }
+    /**
+     * 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, allow) {
+        return channel.call('window.respondCloseRequest', {
+            windowId: this.requireId(),
+            requestId,
+            allow,
+        });
+    }
+    // ── estado ─────────────────────────────────────────────────────────────
+    isMaximized() {
+        return channel.call('window.isMaximized', { windowId: this.requireId() });
+    }
+    isMinimized() {
+        return channel.call('window.isMinimized', { windowId: this.requireId() });
+    }
+    getBounds() {
+        return channel.call('window.getBounds', { windowId: this.requireId() });
+    }
+    setBounds(b) {
+        return channel.call('window.setBounds', { windowId: this.requireId(), ...b });
+    }
+    setTitle(title) {
+        return channel.call('window.setTitle', { windowId: this.requireId(), title });
+    }
+    /**
+     * 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) {
+        return channel.call('window.setTitleBarOverlay', {
+            windowId: this.requireId(),
+            titleBarOverlay: overlay,
+        });
+    }
+    // ── estado extendido (C9) ──────────────────────────────────────────────
+    isVisible() { return channel.call('window.isVisible', { windowId: this.requireId() }); }
+    isFocused() { return channel.call('window.isFocused', { windowId: this.requireId() }); }
+    isResizable() { return channel.call('window.isResizable', { windowId: this.requireId() }); }
+    isMovable() { return channel.call('window.isMovable', { windowId: this.requireId() }); }
+    isMinimizable() { return channel.call('window.isMinimizable', { windowId: this.requireId() }); }
+    isMaximizable() { return channel.call('window.isMaximizable', { windowId: this.requireId() }); }
+    isClosable() { return channel.call('window.isClosable', { windowId: this.requireId() }); }
+    isAlwaysOnTop() { return channel.call('window.isAlwaysOnTop', { windowId: this.requireId() }); }
+    isKiosk() { return channel.call('window.isKiosk', { windowId: this.requireId() }); }
+    isDestroyed() { return channel.call('window.isDestroyed', { windowId: this.requireId() }); }
+    isFullScreen() { return channel.call('window.isFullScreen', { windowId: this.requireId() }); }
+    setResizable(on = true) { return channel.call('window.setResizable', { windowId: this.requireId(), on }); }
+    setMovable(on = true) { return channel.call('window.setMovable', { windowId: this.requireId(), on }); }
+    setMinimizable(on = true) { return channel.call('window.setMinimizable', { windowId: this.requireId(), on }); }
+    setMaximizable(on = true) { return channel.call('window.setMaximizable', { windowId: this.requireId(), on }); }
+    setClosable(on = true) { return channel.call('window.setClosable', { windowId: this.requireId(), on }); }
+    setAlwaysOnTop(on = true, level = 0) { return channel.call('window.setAlwaysOnTop', { windowId: this.requireId(), on, level }); }
+    setSkipTaskbar(on = true) { return channel.call('window.setSkipTaskbar', { windowId: this.requireId(), on }); }
+    setHasShadow(on = true) { return channel.call('window.setHasShadow', { windowId: this.requireId(), on }); }
+    setKiosk(on = true) { return channel.call('window.setKiosk', { windowId: this.requireId(), on }); }
+    setIgnoreMouseEvents(ignore = true, options = {}) {
+        return channel.call('window.setIgnoreMouseEvents', { windowId: this.requireId(), ignore, forward: !!options.forward });
+    }
+    setProgressBar(value, options = {}) {
+        return channel.call('window.setProgressBar', { windowId: this.requireId(), value, mode: options.mode ?? 'normal' });
+    }
+    setBackgroundColor(color) {
+        return channel.call('window.setBackgroundColor', { windowId: this.requireId(), color });
+    }
+    moveTop() { return channel.call('window.moveTop', { windowId: this.requireId() }); }
+    setAspectRatio(ratio, extraSize) {
+        return channel.call('window.setAspectRatio', {
+            windowId: this.requireId(),
+            ratio,
+            extraW: extraSize?.width ?? 0,
+            extraH: extraSize?.height ?? 0,
+        });
+    }
+    getContentBounds() { return channel.call('window.getContentBounds', { windowId: this.requireId() }); }
+    setContentSize(width, height) {
+        return channel.call('window.setContentSize', { windowId: this.requireId(), width, height });
+    }
+    getContentSize() {
+        return channel.call('window.getContentSize', { windowId: this.requireId() });
+    }
+    getMinimumSize() {
+        return channel.call('window.getMinimumSize', { windowId: this.requireId() });
+    }
+    getMaximumSize() {
+        return channel.call('window.getMaximumSize', { windowId: this.requireId() });
+    }
+    setMinimumSize(width, height) {
+        return channel.call('window.setMinimumSize', { windowId: this.requireId(), width, height });
+    }
+    setMaximumSize(width, height) {
+        return channel.call('window.setMaximumSize', { windowId: this.requireId(), width, height });
+    }
+    // ── estáticos (C9) ─────────────────────────────────────────────────────
+    /** Ventanas creadas por esta app (orden de creación). Síncrono, como Electron. */
+    static getAllWindows() {
+        return [...windowsById.values()];
+    }
+    /** Ventana con foco, o `null`. Síncrono, como Electron. */
+    static getFocusedWindow() {
+        return focusedWindowId ? windowsById.get(focusedWindowId) ?? null : null;
+    }
+    static fromId(id) {
+        return windowsById.get(id) ?? null;
+    }
+    /**
+     * `webContents` de esta ventana (estilo Electron): `send`, `capturePage`,
+     * eventos (`did-finish-load`, `before-input-event`, …) y
+     * `setWindowOpenHandler`.
+     */
+    get webContents() {
+        return this._wc;
+    }
+}

package/dist/channel.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from 'node:events';
+export declare class ControlChannel extends EventEmitter {
+    private socket;
+    private buffer;
+    private nextId;
+    private pending;
+    connect(socketPath: string): Promise<void>;
+    private rejectAllPending;
+    private handleLine;
+    call<T = any>(cmd: string, params?: Record<string, unknown>): Promise<T>;
+}
+/** Canal singleton con el kernel. */
+export declare const channel: ControlChannel;
+/** Ruta del control socket (env o último de XDG_RUNTIME_DIR). */
+export declare function socketPathFromEnv(): string;
+/**
+ * Invoca un módulo nativo (.owm) desde el proceso principal. Equivalente a
+ * `ow.invoke()` del renderer, pero sin depender de una ventana.
+ *
+ *   const txt = await invokeNative<string>('fs', 'readText', '/etc/hostname')
+ */
+export declare function invokeNative<T = unknown>(module: string, method: string, ...args: unknown[]): Promise<T>;

package/dist/channel.js

@@ -0,0 +1,114 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/channel.ts — canal de control (NDJSON) con el kernel.
+//
+// Piedra angular del SDK: sin dependencias de otras partes del paquete (evita
+// ciclos). El resto de features importan `channel` / `invokeNative` de aquí.
+import * as net from 'node:net';
+import { EventEmitter } from 'node:events';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export class ControlChannel extends EventEmitter {
+    socket = null;
+    buffer = '';
+    nextId = 1;
+    pending = new Map();
+    connect(socketPath) {
+        return new Promise((resolve, reject) => {
+            const sock = net.connect(socketPath);
+            sock.once('connect', () => {
+                this.socket = sock;
+                resolve();
+            });
+            sock.once('error', (err) => {
+                this.socket = null;
+                this.rejectAllPending(err);
+                reject(err);
+            });
+            sock.on('data', (chunk) => {
+                this.buffer += chunk.toString('utf8');
+                let idx;
+                while ((idx = this.buffer.indexOf('\n')) >= 0) {
+                    const line = this.buffer.slice(0, idx);
+                    this.buffer = this.buffer.slice(idx + 1);
+                    if (line.trim())
+                        this.handleLine(line);
+                }
+            });
+            sock.on('close', () => {
+                this.socket = null;
+                this.rejectAllPending(new Error('conexión cerrada'));
+                this.emit('disconnected');
+            });
+        });
+    }
+    rejectAllPending(err) {
+        for (const { reject } of this.pending.values()) {
+            reject(err);
+        }
+        this.pending.clear();
+    }
+    handleLine(line) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (msg.event) {
+            this.emit(msg.event, msg.params);
+            return;
+        }
+        const p = this.pending.get(msg.id);
+        if (!p)
+            return;
+        this.pending.delete(msg.id);
+        if (msg.ok)
+            p.resolve(msg.result);
+        else
+            p.reject(new Error(msg.error ?? 'error de control'));
+    }
+    call(cmd, params = {}) {
+        if (!this.socket)
+            return Promise.reject(new Error('control socket desconectado'));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.socket.write(JSON.stringify({ id, cmd, params }) + '\n');
+        });
+    }
+}
+/** Canal singleton con el kernel. */
+export const channel = new ControlChannel();
+/** Ruta del control socket (env o último de XDG_RUNTIME_DIR). */
+export function socketPathFromEnv() {
+    if (process.env.OW_CONTROL_SOCKET)
+        return process.env.OW_CONTROL_SOCKET;
+    // fallback: último socket vivo en XDG_RUNTIME_DIR (útil para depurar)
+    const dir = process.env.XDG_RUNTIME_DIR;
+    if (dir) {
+        try {
+            const socks = fs
+                .readdirSync(dir)
+                .filter((f) => f.startsWith('owear-') && f.endsWith('.sock'))
+                .sort();
+            if (socks.length)
+                return path.join(dir, socks[socks.length - 1]);
+        }
+        catch {
+            /* noop */
+        }
+    }
+    throw new Error('Owear: OW_CONTROL_SOCKET no definida. Lanza la app con `ow dev` o `ow build && owear`.');
+}
+/**
+ * Invoca un módulo nativo (.owm) desde el proceso principal. Equivalente a
+ * `ow.invoke()` del renderer, pero sin depender de una ventana.
+ *
+ *   const txt = await invokeNative<string>('fs', 'readText', '/etc/hostname')
+ */
+export function invokeNative(module, method, ...args) {
+    return channel.call('module.invoke', { module, method, args });
+}

package/dist/dialog.d.ts

@@ -0,0 +1,47 @@
+export interface FileFilter {
+    name: string;
+    extensions: string[];
+}
+export interface OpenDialogOptions {
+    title?: string;
+    defaultPath?: string;
+    buttonLabel?: string;
+    filters?: FileFilter[];
+    properties?: Array<'openFile' | 'openDirectory' | 'multiSelections' | 'showHiddenFiles' | 'createDirectory'>;
+}
+export interface SaveDialogOptions {
+    title?: string;
+    defaultPath?: string;
+    buttonLabel?: string;
+    filters?: FileFilter[];
+}
+export interface MessageBoxOptions {
+    type?: 'none' | 'info' | 'error' | 'question' | 'warning';
+    title?: string;
+    message: string;
+    detail?: string;
+    buttons?: string[];
+    defaultId?: number;
+    cancelId?: number;
+    checkboxLabel?: string;
+}
+/**
+ * Diálogos nativos (módulo `dialog`).
+ *   const { canceled, filePaths } = await dialog.showOpenDialog({ properties: ['openFile','multiSelections'] })
+ *   const { filePath } = await dialog.showSaveDialog({ defaultPath: '/tmp/x.txt' })
+ *   const { response } = await dialog.showMessageBox({ message: '¿Seguir?', buttons: ['Sí','No'] })
+ */
+export declare const dialog: {
+    showOpenDialog(options?: OpenDialogOptions): Promise<{
+        canceled: boolean;
+        filePaths: string[];
+    }>;
+    showSaveDialog(options?: SaveDialogOptions): Promise<{
+        canceled: boolean;
+        filePath: string;
+    }>;
+    showMessageBox(options: MessageBoxOptions): Promise<{
+        response: number;
+        checkboxChecked: boolean;
+    }>;
+};

package/dist/dialog.js

@@ -0,0 +1,22 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/dialog.ts — diálogos nativos (módulo `dialog`).
+import { invokeNative } from './channel.js';
+/**
+ * Diálogos nativos (módulo `dialog`).
+ *   const { canceled, filePaths } = await dialog.showOpenDialog({ properties: ['openFile','multiSelections'] })
+ *   const { filePath } = await dialog.showSaveDialog({ defaultPath: '/tmp/x.txt' })
+ *   const { response } = await dialog.showMessageBox({ message: '¿Seguir?', buttons: ['Sí','No'] })
+ */
+export const dialog = {
+    showOpenDialog(options = {}) {
+        return invokeNative('dialog', 'showOpenDialog', options);
+    },
+    showSaveDialog(options = {}) {
+        return invokeNative('dialog', 'showSaveDialog', options);
+    },
+    showMessageBox(options) {
+        return invokeNative('dialog', 'showMessageBox', options);
+    },
+};

package/dist/index.d.ts

@@ -1,19 +1,47 @@
-import { EventEmitter } from 'node:events';
+export { NativeImage, nativeImage } from './nativeimage.js';
+export type { Size as NativeImageSize, Rectangle, ResizeOptions } from './nativeimage.js';
 export interface WindowOptions {
     title?: string;
     width?: number;
     height?: number;
     x?: number;
     y?: number;
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
     resizable?: boolean;
+    movable?: boolean;
+    minimizable?: boolean;
+    maximizable?: boolean;
+    closable?: boolean;
+    fullscreenable?: boolean;
     frameless?: boolean;
+    transparent?: boolean;
+    backgroundColor?: string;
+    show?: boolean;
+    skipTaskbar?: boolean;
+    alwaysOnTop?: boolean;
+    hasShadow?: boolean;
+    aspectRatio?: number;
+    /** Ventana padre (id de otra ventana) y si es modal respecto a ella. */
+    parent?: number;
+    modal?: boolean;
     titleBarStyle?: 'default' | 'hidden' | 'custom';
-    titleBarOverlay?: {
+    titleBarOverlay?: boolean | {
+        enabled?: boolean;
         color?: string;
         symbolColor?: string;
+        buttonColor?: string;
         height?: number;
     };
     url?: string;
+    /**
+     * Partición de sesión: aísla cookies/localStorage/IndexedDB/cache por perfil.
+     * Vacío = perfil por defecto de la app. Ej: "persist:cuenta-2".
+     * Crea la partición con `session.fromPartition(name)`.
+     */
+    session?: string;
 }
 export interface Bounds {
     x: number;
@@ -21,6 +49,16 @@ export interface Bounds {
     width: number;
     height: number;
 }
+/**
+ * Vista mínima de `webContents` (paridad con Electron) para el envío dirigido
+ * main → renderer. `send` llega al renderer como `ow.on(name, cb)`.
+ */
+export interface WebContentsHandle {
+    /** Id de la ventana/webContents (-1 si aún no se creó). */
+    readonly id: number;
+    /** Envía un evento SOLO a esta ventana. */
+    send(name: string, payload?: unknown): Promise<void>;
+}
 export type WindowEventMap = {
     resize: Bounds;
     move: Bounds;
@@ -35,99 +73,42 @@ export type WindowEventMap = {
     };
     closed: void;
 };
-declare class ControlChannel extends EventEmitter {
-    private socket;
-    private buffer;
-    private nextId;
-    private pending;
-    connect(socketPath: string): Promise<void>;
-    private rejectAllPending;
-    private handleLine;
-    call<T = any>(cmd: string, params?: Record<string, unknown>): Promise<T>;
-}
-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;
-    }>;
-    /**
-     * 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: ControlChannel;
-};
-/**
- * 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 declare function invokeNative<T = unknown>(module: string, method: string, ...args: unknown[]): Promise<T>;
-/** Metadatos de un módulo nativo cargado en el kernel. */
-export interface NativeModuleInfo {
-    name: string;
-    version: string;
-    /** Ruta del .owm o "builtin:<nombre>" para los enlazados al kernel. */
-    origin: string;
-    builtin: boolean;
-    /** Número de funciones (compat). */
-    functions: number;
-    /** Nombres de las funciones. */
-    functionNames: string[];
-}
-/** Módulos nativos cargados, con versión, origen y funciones. */
-export declare function listNativeModules(): Promise<NativeModuleInfo[]>;
-/** Metadatos de un módulo nativo concreto. Rechaza si no existe. */
-export declare function nativeModuleInfo(name: string): Promise<NativeModuleInfo>;
-export declare class BrowserWindow extends EventEmitter {
-    private _id;
-    private _options;
-    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>;
-}
+export { invokeNative } from './channel.js';
+export { listNativeModules, nativeModuleInfo } from './modules.js';
+export type { NativeModuleInfo } from './modules.js';
+export { theme, nativeTheme } from './theme.js';
+export type { ThemeInfo } from './theme.js';
+export { screen } from './screen.js';
+export type { DisplayBounds, DisplaySize, Display, DisplayMetric } from './screen.js';
+export { powerMonitor, powerSaveBlocker } from './power.js';
+export type { IdleState, PowerSaveBlockerType } from './power.js';
+export { safeStorage } from './safestorage.js';
+export type { SafeStorageResult } from './safestorage.js';
+export { session } from './session.js';
+export type { PermissionRequest, PermissionHandler } from './session.js';
+export { webRequest } from './webrequest.js';
+export type { WebRequestDetails, WebRequestResult, WebRequestHandler } from './webrequest.js';
+export { dialog } from './dialog.js';
+export type { FileFilter, OpenDialogOptions, SaveDialogOptions, MessageBoxOptions } from './dialog.js';
+export { WebContents } from './webcontents.js';
+export { BrowserWindow } from './browserwindow.js';
+export { MenuItem, Menu } from './menu.js';
+export { Tray } from './tray.js';
+export type { TrayEvent } from './tray.js';
+export { nodeHandlers, nodeContextHandlers } from './ipc/node.js';
+export type { NodeHandler, ContextNodeHandler } from './ipc/node.js';
+export { protocolHandlers } from './protocol.js';
+export type { ProtocolRequest, ProtocolHandlerResult, ProtocolHandler } from './protocol.js';
+export { portRecords, makeMainPort, allocPortId } from './port.js';
+export type { MessagePortMain } from './port.js';
+export { app } from './app.js';
+export { readyPromise } from './app.js';
+export { installer } from './installer.js';
+export type { InstallerMode, PayloadEntry, InstallerInfo, PlanOptions, InstallOptions, InstallResult, UninstallResult, VerifyResult, StateResult, ShortcutOptions, LaunchOptions, } from './installer.js';
+export { defineBridge } from './bridge.js';
+export type { OwearBridge, BridgeApp, BridgeTarget, BridgePlatform, BridgeFormat, BridgeLayout, BridgePreset, BridgeGroup, BridgeProtect, BridgeNode, BridgeHooks, } from './bridge.js';
+export { forkWorker, resolveWorkerEntry } from './node/worker.js';
+export type { ForkWorkerOptions, WorkerHandle } from './node/worker.js';
 /** Tipos de `window.ow` disponible dentro del WebView (inyectado por el kernel). */
 export interface OwBridge {
     invoke<T = unknown>(module: string, fn: string, ...args: unknown[]): Promise<T>;
@@ -141,4 +122,3 @@ declare global {
     const ow: OwBridge;
 }
 export declare const platform: NodeJS.Platform;
-export {};