@owear/core 0.1.2 → 0.1.4

package/dist/node/worker.d.ts

@@ -0,0 +1,29 @@
+export interface WorkerHandle {
+    /** Envía un mensaje al worker (structured clone de Node). */
+    postMessage(message: unknown): void;
+    /** Escucha los mensajes del worker o su salida. */
+    on(event: 'message', listener: (message: unknown) => void): void;
+    on(event: 'exit', listener: (code: number) => void): void;
+    /** Termina el worker. */
+    kill(signal?: NodeJS.Signals): void;
+    /** PID del worker (undefined hasta que el SO lo asigna). */
+    readonly pid: number | undefined;
+}
+export interface ForkWorkerOptions {
+    args?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    /** execArgv para el hijo (por defecto, el del proceso actual). */
+    execArgv?: string[];
+}
+/**
+ * Resuelve el entry de un worker. Si es relativo sin `./`, se busca en
+ * `OW_APP_WORKERS` (lo define `ow dev`/`ow build`); si no, contra el cwd.
+ * Las rutas absolutas y las que empiezan por `.` se respetan tal cual.
+ */
+export declare function resolveWorkerEntry(entry: string): string;
+/**
+ * Lanza un worker Node con canal de mensajes. Devuelve un handle síncrono.
+ * Los errores de arranque se reportan por el evento `exit` del worker.
+ */
+export declare function forkWorker(entry: string, options?: ForkWorkerOptions): WorkerHandle;

package/dist/node/worker.js

@@ -0,0 +1,61 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// packages/core/src/node/worker.ts — worker Node con canal de mensajes.
+//
+// Reemplazo Owear de `utilityProcess.fork` de Electron. El proceso principal
+// de Owear YA es Node real, así que un worker es un hijo con canal IPC
+// (`child_process.fork`). Los workers portados desde Electron que usan
+// `process.parentPort` funcionan sin cambios: worker-runner.ts lo emula.
+//
+//   const w = app.forkWorker('tree-sitter-worker.js')
+//   w.on('message', (m) => …)
+//   w.postMessage({ … })
+import { fork } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+const runnerPath = join(dirname(fileURLToPath(import.meta.url)), 'worker-runner.js');
+/**
+ * Resuelve el entry de un worker. Si es relativo sin `./`, se busca en
+ * `OW_APP_WORKERS` (lo define `ow dev`/`ow build`); si no, contra el cwd.
+ * Las rutas absolutas y las que empiezan por `.` se respetan tal cual.
+ */
+export function resolveWorkerEntry(entry) {
+    if (isAbsolute(entry))
+        return entry;
+    if (entry.startsWith('.'))
+        return resolve(entry);
+    const dir = process.env.OW_APP_WORKERS;
+    return dir ? join(dir, entry) : resolve(entry);
+}
+/**
+ * Lanza un worker Node con canal de mensajes. Devuelve un handle síncrono.
+ * Los errores de arranque se reportan por el evento `exit` del worker.
+ */
+export function forkWorker(entry, options = {}) {
+    const resolved = resolveWorkerEntry(entry);
+    const child = fork(runnerPath, [resolved, ...(options.args ?? [])], {
+        cwd: options.cwd,
+        env: options.env,
+        execArgv: options.execArgv ?? process.execArgv,
+        stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
+    });
+    const handle = {
+        postMessage(message) {
+            child.send(message);
+        },
+        on(event, listener) {
+            if (event === 'message')
+                child.on('message', (m) => listener(m));
+            else
+                child.on('exit', (code) => listener((code ?? 0)));
+        },
+        kill(signal) {
+            child.kill(signal);
+        },
+        get pid() {
+            return child.pid;
+        },
+    };
+    return handle;
+}

package/dist/port.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter } from 'node:events';
+export interface MessagePortMain {
+    /** Id global del endpoint (para transferirlo a un renderer). */
+    readonly portId: number;
+    /** Envía un mensaje al otro extremo. */
+    postMessage(message: unknown): void;
+    on(event: 'message', listener: (message: unknown) => void): this;
+    start(): void;
+    close(): void;
+}
+type PortSide = {
+    kind: 'main';
+} | {
+    kind: 'renderer';
+    windowId: number;
+};
+interface PortRecord {
+    id: number;
+    peer: number;
+    side: PortSide;
+    emitter: EventEmitter;
+}
+export declare const portRecords: Map<number, PortRecord>;
+export declare let nextPortId: number;
+/** Reserva un id de puerto nuevo (evita asignar el import fuera del módulo). */
+export declare function allocPortId(): number;
+export declare function makeMainPort(id: number): MessagePortMain;
+export {};

package/dist/port.js

@@ -0,0 +1,42 @@
+import { channel } from './channel.js';
+import { nodeHandlers } from './ipc/node.js';
+export const portRecords = new Map();
+export let nextPortId = 1;
+/** Reserva un id de puerto nuevo (evita asignar el import fuera del módulo). */
+export function allocPortId() {
+    return nextPortId++;
+}
+function deliverPort(fromId, data) {
+    const rec = portRecords.get(fromId);
+    if (!rec)
+        return;
+    const peer = portRecords.get(rec.peer);
+    if (!peer)
+        return;
+    if (peer.side.kind === 'main') {
+        peer.emitter.emit('message', data);
+    }
+    else {
+        void channel.call('node.emit', {
+            name: '__ow_port:msg',
+            payload: { id: peer.id, data },
+            windowId: peer.side.windowId,
+        });
+    }
+}
+export function makeMainPort(id) {
+    const rec = portRecords.get(id);
+    return Object.assign(rec.emitter, {
+        portId: id,
+        postMessage: (data) => deliverPort(id, data),
+        start: () => undefined,
+        close: () => portRecords.delete(id),
+    });
+}
+// Handler reservado: el renderer publica en un puerto con
+// `ow.invoke('node','call',{ fn:'__ow_port_post', args:[{ id, data }] })`.
+nodeHandlers.set('__ow_port_post', (msg) => {
+    if (msg && typeof msg.id === 'number')
+        deliverPort(msg.id, msg.data);
+    return null;
+});

package/dist/power.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from 'node:events';
+export type IdleState = 'active' | 'idle' | 'locked' | 'unknown';
+declare class PowerMonitor extends EventEmitter {
+    private _watching;
+    private _onBattery;
+    private _ensure;
+    /** Empieza a escuchar eventos de energía (auto al usar el módulo o un evento). */
+    watch(): Promise<void>;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    getIdleTime(): Promise<number>;
+    getIdleState(threshold: number): Promise<IdleState>;
+    isOnBatteryPower(): Promise<boolean>;
+    /** Último valor conocido (se actualiza con los eventos ac/battery). */
+    get onBatteryPower(): boolean;
+    /** @internal */
+    _setOnBattery(v: boolean): void;
+    getSystemIdleTime: () => Promise<number>;
+    getSystemIdleState: (threshold: number) => Promise<IdleState>;
+}
+/** Eventos de energía: `suspend`, `resume`, `ac`, `battery`, `shutdown`, `lock`, `unlock`. */
+export declare const powerMonitor: PowerMonitor;
+export type PowerSaveBlockerType = 'prevent-app-suspension' | 'prevent-display-sleep';
+/**
+ * Evita que el sistema entre en suspensión. `prevent-display-sleep` tiene
+ * precedencia sobre `prevent-app-suspension`.
+ */
+export declare const powerSaveBlocker: {
+    start(type?: PowerSaveBlockerType): number;
+    stop(id: number): boolean;
+    isStarted(id: number): boolean;
+};
+export {};

package/dist/power.js

@@ -0,0 +1,99 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/power.ts — powerMonitor / powerSaveBlocker.
+import { EventEmitter } from 'node:events';
+import { invokeNative } from './channel.js';
+import { app } from './index.js';
+class PowerMonitor extends EventEmitter {
+    _watching = false;
+    _onBattery = false;
+    async _ensure() {
+        if (this._watching)
+            return;
+        this._watching = true;
+        try {
+            await app.whenReady();
+            await invokeNative('power', 'monitorStart');
+            this._onBattery = await invokeNative('power', 'isOnBattery');
+        }
+        catch {
+            /* sin kernel: módulo no disponible */
+        }
+    }
+    /** Empieza a escuchar eventos de energía (auto al usar el módulo o un evento). */
+    watch() {
+        return this._ensure();
+    }
+    on(event, listener) {
+        void this._ensure();
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        void this._ensure();
+        return super.once(event, listener);
+    }
+    getIdleTime() {
+        return invokeNative('power', 'idleTime');
+    }
+    getIdleState(threshold) {
+        return invokeNative('power', 'idleState', threshold);
+    }
+    isOnBatteryPower() {
+        return invokeNative('power', 'isOnBattery').then((v) => {
+            this._onBattery = v;
+            return v;
+        });
+    }
+    /** Último valor conocido (se actualiza con los eventos ac/battery). */
+    get onBatteryPower() {
+        return this._onBattery;
+    }
+    /** @internal */
+    _setOnBattery(v) {
+        this._onBattery = v;
+    }
+    getSystemIdleTime = this.getIdleTime.bind(this);
+    getSystemIdleState = this.getIdleState.bind(this);
+}
+/** Eventos de energía: `suspend`, `resume`, `ac`, `battery`, `shutdown`, `lock`, `unlock`. */
+export const powerMonitor = new PowerMonitor();
+const activeBlockers = new Map();
+let nextBlockerId = 1;
+/**
+ * Evita que el sistema entre en suspensión. `prevent-display-sleep` tiene
+ * precedencia sobre `prevent-app-suspension`.
+ */
+export const powerSaveBlocker = {
+    start(type = 'prevent-display-sleep') {
+        const id = nextBlockerId++;
+        activeBlockers.set(id, { type, native: null });
+        void (async () => {
+            try {
+                await app.whenReady();
+                const native = await invokeNative('power', 'inhibitStart', type);
+                const b = activeBlockers.get(id);
+                if (b)
+                    b.native = native;
+                else
+                    await invokeNative('power', 'inhibitStop', native);
+            }
+            catch {
+                /* sin kernel: el bloqueador queda solo en el registro JS */
+            }
+        })();
+        return id;
+    },
+    stop(id) {
+        const b = activeBlockers.get(id);
+        if (!b)
+            return false;
+        activeBlockers.delete(id);
+        if (b.native != null)
+            void invokeNative('power', 'inhibitStop', b.native).catch(() => undefined);
+        return true;
+    },
+    isStarted(id) {
+        return activeBlockers.has(id);
+    },
+};

package/dist/protocol.d.ts

@@ -0,0 +1,14 @@
+export interface ProtocolRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    /** Cuerpo de la request en base64 (formato del bridge). */
+    body: string;
+}
+export type ProtocolHandlerResult = Response | {
+    status?: number;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array;
+} | string | null | undefined;
+export type ProtocolHandler = (req: ProtocolRequest) => ProtocolHandlerResult | Promise<ProtocolHandlerResult>;
+export declare const protocolHandlers: Map<string, ProtocolHandler>;

package/dist/protocol.js

@@ -0,0 +1,46 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/protocol.ts — esquemas personalizados (protocol).
+import { channel } from './channel.js';
+export const protocolHandlers = new Map();
+async function normalizeProtocolResponse(res) {
+    if (res == null)
+        return { status: 404, headers: {}, body: '' };
+    if (typeof res === 'string')
+        return { status: 200, headers: { 'content-type': 'text/html' }, body: toB64(res) };
+    if (typeof Response !== 'undefined' && res instanceof Response) {
+        const headers = {};
+        res.headers.forEach((v, k) => {
+            headers[k] = v;
+        });
+        const body = Buffer.from(await res.arrayBuffer()).toString('base64');
+        return { status: res.status, headers, body };
+    }
+    const r = res;
+    let body = '';
+    if (r.body instanceof Uint8Array)
+        body = Buffer.from(r.body).toString('base64');
+    else if (typeof r.body === 'string')
+        body = toB64(r.body);
+    return { status: r.status ?? 200, headers: r.headers ?? {}, body };
+}
+function toB64(text) {
+    return Buffer.from(text, 'utf-8').toString('base64');
+}
+channel.on('protocol.request', (params) => {
+    const { reqId, scheme, url, method, headers, body } = params ?? {};
+    const handler = protocolHandlers.get(scheme);
+    Promise.resolve()
+        .then(() => handler
+        ? handler({ url, method, headers: headers ?? {}, body: body ?? '' })
+        : null)
+        .then((res) => normalizeProtocolResponse(res ?? null))
+        .then((out) => channel.call('protocol.respond', {
+        reqId,
+        status: out.status,
+        headers: out.headers,
+        body: out.body,
+    }))
+        .catch(() => channel.call('protocol.respond', { reqId, status: 500, headers: {}, body: '' }));
+});

package/dist/safestorage.d.ts

@@ -0,0 +1,16 @@
+export interface SafeStorageResult {
+    /** El dato cifrado (o el texto tal cual si no hay backend). */
+    data: string;
+    /** true si se cifró de verdad (DPAPI en Windows, AES-GCM en Linux). */
+    encrypted: boolean;
+}
+/**
+ * Almacenamiento cifrado por el SO (módulo `safestorage`).
+ * Windows: DPAPI · Linux: AES-256-GCM con clave local (0600).
+ * `decrypt` acepta tanto blobs cifrados como texto plano.
+ */
+export declare const safeStorage: {
+    isAvailable(): Promise<boolean>;
+    encrypt(text: string): Promise<SafeStorageResult>;
+    decrypt(data: string): Promise<string>;
+};

package/dist/safestorage.js

@@ -0,0 +1,21 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/safestorage.ts — almacenamiento cifrado por el SO.
+import { invokeNative } from './channel.js';
+/**
+ * Almacenamiento cifrado por el SO (módulo `safestorage`).
+ * Windows: DPAPI · Linux: AES-256-GCM con clave local (0600).
+ * `decrypt` acepta tanto blobs cifrados como texto plano.
+ */
+export const safeStorage = {
+    isAvailable() {
+        return invokeNative('safestorage', 'isAvailable');
+    },
+    encrypt(text) {
+        return invokeNative('safestorage', 'encrypt', text);
+    },
+    decrypt(data) {
+        return invokeNative('safestorage', 'decrypt', data);
+    },
+};

package/dist/screen.d.ts

@@ -0,0 +1,92 @@
+import { EventEmitter } from 'node:events';
+export interface DisplayBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface DisplaySize {
+    width: number;
+    height: number;
+}
+export interface Display {
+    id: number;
+    primary: boolean;
+    /** Etiqueta legible (modelo/monitor); puede venir vacía. */
+    label: string;
+    /** En píxeles NATIVOS de pantalla (coincide con las coords del kernel). */
+    bounds: DisplayBounds;
+    size: DisplaySize;
+    workArea: DisplayBounds;
+    workAreaSize: DisplaySize;
+    scaleFactor: number;
+    rotation: number;
+    internal: boolean;
+    detected: boolean;
+    displayFrequency: number;
+    colorDepth: number;
+    depthPerComponent: number;
+    colorSpace: string;
+    monochrome: boolean;
+    touchSupport: 'available' | 'unavailable' | 'unknown';
+    accelerometerSupport: 'available' | 'unavailable' | 'unknown';
+    nativeOrigin: {
+        x: number;
+        y: number;
+    };
+}
+export type DisplayMetric = 'bounds' | 'workArea' | 'scaleFactor' | 'rotation';
+declare class Screen extends EventEmitter {
+    private _watching;
+    private _ensure;
+    /** Conecta el watcher nativo (se llama solo al usar el módulo o un evento). */
+    watch(): Promise<void>;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    getAllDisplays(): Promise<Display[]>;
+    getPrimaryDisplay(): Promise<Display | null>;
+    getCursorScreenPoint(): Promise<{
+        x: number;
+        y: number;
+    }>;
+    /** Display más cercano a un punto (calculado en el SDK sobre los bounds). */
+    getDisplayNearestPoint(point: {
+        x: number;
+        y: number;
+    }): Promise<Display | null>;
+    /** Display que más se solapa con un rect (o el más cercano a su centro). */
+    getDisplayMatching(rect: DisplayBounds): Promise<Display | null>;
+    private _displayAt;
+    /**
+     * Punto físico de pantalla → DIP, relativo al display que lo contiene
+     * (aproximación por escala del display; coincide exactamente con escala 1).
+     */
+    screenToDipPoint(point: {
+        x: number;
+        y: number;
+    }): Promise<{
+        x: number;
+        y: number;
+    }>;
+    dipToScreenPoint(point: {
+        x: number;
+        y: number;
+    }): Promise<{
+        x: number;
+        y: number;
+    }>;
+    getDisplays: () => Promise<Display[]>;
+    getPrimary: () => Promise<Display | null>;
+    getCursor: () => Promise<{
+        x: number;
+        y: number;
+    }>;
+    nearestDisplay: (point: {
+        x: number;
+        y: number;
+    }) => Promise<Display | null>;
+    displayMatching: (rect: DisplayBounds) => Promise<Display | null>;
+}
+/** Pantallas del sistema + eventos de cambio (multi-monitor). */
+export declare const screen: Screen;
+export {};

package/dist/screen.js

@@ -0,0 +1,121 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/screen.ts — pantallas (multi-monitor) y eventos.
+import { EventEmitter } from 'node:events';
+import { invokeNative } from './channel.js';
+import { app } from './index.js';
+function distanceToRect(p, r) {
+    const dx = Math.max(r.x - p.x, 0, p.x - (r.x + r.width));
+    const dy = Math.max(r.y - p.y, 0, p.y - (r.y + r.height));
+    return dx * dx + dy * dy;
+}
+function intersectionArea(a, b) {
+    const w = Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x);
+    const h = Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y);
+    return w > 0 && h > 0 ? w * h : 0;
+}
+class Screen extends EventEmitter {
+    _watching = false;
+    async _ensure() {
+        if (this._watching)
+            return;
+        this._watching = true;
+        try {
+            await app.whenReady();
+            await invokeNative('screen', 'watch');
+        }
+        catch {
+            /* sin kernel: módulo no disponible */
+        }
+    }
+    /** Conecta el watcher nativo (se llama solo al usar el módulo o un evento). */
+    watch() {
+        return this._ensure();
+    }
+    on(event, listener) {
+        void this._ensure();
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        void this._ensure();
+        return super.once(event, listener);
+    }
+    async getAllDisplays() {
+        await this._ensure();
+        return invokeNative('screen', 'getAllDisplays');
+    }
+    async getPrimaryDisplay() {
+        await this._ensure();
+        return invokeNative('screen', 'getPrimaryDisplay');
+    }
+    async getCursorScreenPoint() {
+        return invokeNative('screen', 'getCursorScreenPoint');
+    }
+    /** Display más cercano a un punto (calculado en el SDK sobre los bounds). */
+    async getDisplayNearestPoint(point) {
+        const all = await this.getAllDisplays();
+        let best = null;
+        let bestD = Infinity;
+        for (const d of all) {
+            const dist = distanceToRect(point, d.bounds);
+            if (dist < bestD) {
+                bestD = dist;
+                best = d;
+            }
+        }
+        return best;
+    }
+    /** Display que más se solapa con un rect (o el más cercano a su centro). */
+    async getDisplayMatching(rect) {
+        const all = await this.getAllDisplays();
+        let best = null;
+        let bestA = 0;
+        for (const d of all) {
+            const area = intersectionArea(rect, d.bounds);
+            if (area > bestA) {
+                bestA = area;
+                best = d;
+            }
+        }
+        if (best)
+            return best;
+        const center = { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
+        return this.getDisplayNearestPoint(center);
+    }
+    async _displayAt(point) {
+        return this.getDisplayNearestPoint(point);
+    }
+    /**
+     * Punto físico de pantalla → DIP, relativo al display que lo contiene
+     * (aproximación por escala del display; coincide exactamente con escala 1).
+     */
+    async screenToDipPoint(point) {
+        const d = await this._displayAt(point);
+        const s = d?.scaleFactor ?? 1;
+        if (!d || s <= 1)
+            return point;
+        return {
+            x: d.bounds.x + Math.round((point.x - d.bounds.x) / s),
+            y: d.bounds.y + Math.round((point.y - d.bounds.y) / s),
+        };
+    }
+    async dipToScreenPoint(point) {
+        const d = await this._displayAt(point);
+        const s = d?.scaleFactor ?? 1;
+        if (!d || s <= 1)
+            return point;
+        return {
+            x: d.bounds.x + Math.round((point.x - d.bounds.x) * s),
+            y: d.bounds.y + Math.round((point.y - d.bounds.y) * s),
+        };
+    }
+    // ── alias estilo Electron (portabilidad) ─────────────────────────────────
+    getDisplays = this.getAllDisplays.bind(this);
+    getPrimary = this.getPrimaryDisplay.bind(this);
+    getCursor = this.getCursorScreenPoint.bind(this);
+    nearestDisplay = this.getDisplayNearestPoint.bind(this);
+    displayMatching = this.getDisplayMatching.bind(this);
+}
+/** Pantallas del sistema + eventos de cambio (multi-monitor). */
+export const screen = new Screen();

package/dist/session.d.ts

@@ -0,0 +1,24 @@
+export interface PermissionRequest {
+    id: number;
+    /** geolocation | notifications | media | microphone | camera | clipboardRead | … */
+    permission: string;
+    origin: string;
+}
+export type PermissionHandler = (req: PermissionRequest) => boolean | Promise<boolean>;
+/**
+ * Permisos del WebView (geolocalización, notificaciones, cámara, micrófono…).
+ * El handler decide allow/deny; si no hay handler registrado, se deniega.
+ *   session.onPermissionRequest(({ permission, origin }) => permission === 'notifications')
+ */
+export declare const session: {
+    /**
+     * Referencia a una partición de sesión. Pásala al crear la ventana:
+     *   const s = session.fromPartition('persist:cuenta-2')
+     *   new BrowserWindow({ session: s.partition, url })
+     * Aísla cookies/storage/cache por perfil (WebKit: data dir; WebView2: perfil).
+     */
+    fromPartition(partition: string): {
+        partition: string;
+    };
+    onPermissionRequest(handler: PermissionHandler): () => void;
+};

package/dist/session.js

@@ -0,0 +1,42 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/session.ts — permisos del WebView y particiones.
+import { channel } from './channel.js';
+import { app } from './index.js';
+const permissionHandlers = [];
+channel.on('session.permissionRequest', (params) => {
+    const { id, permission, origin } = params ?? {};
+    Promise.all(permissionHandlers.map((h) => Promise.resolve(h({ id, permission, origin }))))
+        .then((results) => channel.call('session.respondPermission', { id, allow: results.some(Boolean) }))
+        .catch(() => channel.call('session.respondPermission', { id, allow: false }));
+});
+/**
+ * Permisos del WebView (geolocalización, notificaciones, cámara, micrófono…).
+ * El handler decide allow/deny; si no hay handler registrado, se deniega.
+ *   session.onPermissionRequest(({ permission, origin }) => permission === 'notifications')
+ */
+export const session = {
+    /**
+     * Referencia a una partición de sesión. Pásala al crear la ventana:
+     *   const s = session.fromPartition('persist:cuenta-2')
+     *   new BrowserWindow({ session: s.partition, url })
+     * Aísla cookies/storage/cache por perfil (WebKit: data dir; WebView2: perfil).
+     */
+    fromPartition(partition) {
+        return { partition };
+    },
+    onPermissionRequest(handler) {
+        permissionHandlers.push(handler);
+        // El handler se registra ya; avisar al kernel en cuanto haya canal.
+        app
+            .whenReady()
+            .then(() => channel.call('session.setPermissionHandler', { enabled: true }))
+            .catch(() => undefined);
+        return () => {
+            const i = permissionHandlers.indexOf(handler);
+            if (i >= 0)
+                permissionHandlers.splice(i, 1);
+        };
+    },
+};