@owear/core 0.1.2 → 0.1.4

package/dist/theme.d.ts

@@ -0,0 +1,30 @@
+export interface ThemeInfo {
+    dark: boolean;
+    source: 'system' | 'light' | 'dark';
+    highContrast: boolean;
+    reducedTransparency: boolean;
+}
+/**
+ * Tema nativo del sistema (módulo `theme`). `watch()` emite `theme.changed`
+ * (recibible con `channel.on('theme.changed', …)` o en el renderer con
+ * `ow.on('theme.changed', …)`).
+ */
+export declare const theme: {
+    get(): Promise<ThemeInfo>;
+    isDark(): Promise<boolean>;
+    /** Fuerza la preferencia: 'system' | 'light' | 'dark'. También aplica el
+     *  esquema al contenido (Windows: WebView2 `PreferredColorScheme`). */
+    setSource(source: "system" | "light" | "dark"): Promise<ThemeInfo>;
+    watch(): Promise<void>;
+    unwatch(): Promise<void>;
+};
+/** Alias estilo Electron de `theme`. */
+export declare const nativeTheme: {
+    get(): Promise<ThemeInfo>;
+    isDark(): Promise<boolean>;
+    /** Fuerza la preferencia: 'system' | 'light' | 'dark'. También aplica el
+     *  esquema al contenido (Windows: WebView2 `PreferredColorScheme`). */
+    setSource(source: "system" | "light" | "dark"): Promise<ThemeInfo>;
+    watch(): Promise<void>;
+    unwatch(): Promise<void>;
+};

package/dist/theme.js

@@ -0,0 +1,34 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/theme.ts — nativeTheme (módulo `theme`).
+import { channel, invokeNative } from './channel.js';
+/**
+ * Tema nativo del sistema (módulo `theme`). `watch()` emite `theme.changed`
+ * (recibible con `channel.on('theme.changed', …)` o en el renderer con
+ * `ow.on('theme.changed', …)`).
+ */
+export const theme = {
+    get() {
+        return invokeNative('theme', 'get');
+    },
+    isDark() {
+        return invokeNative('theme', 'isDark');
+    },
+    /** Fuerza la preferencia: 'system' | 'light' | 'dark'. También aplica el
+     *  esquema al contenido (Windows: WebView2 `PreferredColorScheme`). */
+    async setSource(source) {
+        const info = await invokeNative('theme', 'setSource', source);
+        const scheme = source === 'dark' ? 2 : source === 'light' ? 1 : 0;
+        void channel.call('window.setColorScheme', { scheme }).catch(() => undefined);
+        return info;
+    },
+    watch() {
+        return invokeNative('theme', 'watch');
+    },
+    unwatch() {
+        return invokeNative('theme', 'unwatch');
+    },
+};
+/** Alias estilo Electron de `theme`. */
+export const nativeTheme = theme;

package/dist/tray.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from 'node:events';
+import { Menu } from './menu.js';
+import { NativeImage } from './nativeimage.js';
+/** Tray actual (solo uno). Lo lee el ruteo de eventos del SDK. */
+export declare let currentTray: Tray | null;
+export interface TrayEvent {
+    button: 'left' | 'right' | 'double';
+    windowId: number;
+}
+/**
+ * Icono de bandeja (intermedio Tauri/Electron). El menú contextual reutiliza
+ * `Menu`. Eventos: `click`, `right-click`, `double-click`.
+ *
+ *   const tray = new Tray(nativeImage.createFromPath('icon.png'))
+ *   tray.setContextMenu(Menu.buildFromTemplate([{ label: 'Mostrar', click: () => win.show() }]))
+ *   tray.on('click', () => win.show())
+ */
+export declare class Tray extends EventEmitter {
+    private _menu;
+    private _id;
+    constructor(image?: NativeImage | string);
+    get id(): string;
+    setImage(image: NativeImage | string): void;
+    setPressedImage(image: NativeImage | string): void;
+    setToolTip(tip: string): void;
+    setTitle(title: string): void;
+    setContextMenu(menu: Menu | null): void;
+    popupContextMenu(menu?: Menu): void;
+    destroy(): void;
+}

package/dist/tray.js

@@ -0,0 +1,69 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/tray.ts — Tray (C6).
+import { EventEmitter } from 'node:events';
+import { invokeNative } from './channel.js';
+import { app } from './app.js';
+import { nativeImage } from './nativeimage.js';
+/** Tray actual (solo uno). Lo lee el ruteo de eventos del SDK. */
+export let currentTray = null;
+function toPngBase64(image) {
+    const img = typeof image === 'string' ? nativeImage.createFromPath(image) : image;
+    return img.toPNG().toString('base64');
+}
+/**
+ * Icono de bandeja (intermedio Tauri/Electron). El menú contextual reutiliza
+ * `Menu`. Eventos: `click`, `right-click`, `double-click`.
+ *
+ *   const tray = new Tray(nativeImage.createFromPath('icon.png'))
+ *   tray.setContextMenu(Menu.buildFromTemplate([{ label: 'Mostrar', click: () => win.show() }]))
+ *   tray.on('click', () => win.show())
+ */
+export class Tray extends EventEmitter {
+    _menu = null;
+    _id;
+    constructor(image) {
+        super();
+        this._id = `tray-${Math.random().toString(36).slice(2, 8)}`;
+        currentTray = this;
+        app
+            .whenReady()
+            .then(async () => {
+            await invokeNative('tray', 'create', this._id).catch(() => undefined);
+            if (image)
+                this.setImage(image);
+        })
+            .catch(() => undefined);
+    }
+    get id() {
+        return this._id;
+    }
+    setImage(image) {
+        void invokeNative('tray', 'setImage', toPngBase64(image)).catch(() => undefined);
+    }
+    setPressedImage(image) {
+        void invokeNative('tray', 'setPressedImage', toPngBase64(image)).catch(() => undefined);
+    }
+    setToolTip(tip) {
+        void invokeNative('tray', 'setToolTip', tip).catch(() => undefined);
+    }
+    setTitle(title) {
+        void invokeNative('tray', 'setTitle', title).catch(() => undefined);
+    }
+    setContextMenu(menu) {
+        this._menu = menu;
+        void invokeNative('tray', 'setContextMenu', { items: menu ? menu._toJSON() : [] }).catch(() => undefined);
+    }
+    popupContextMenu(menu) {
+        const m = menu ?? this._menu;
+        if (m)
+            void invokeNative('tray', 'setContextMenu', { items: m._toJSON() }).catch(() => undefined);
+        void invokeNative('tray', 'popupContextMenu').catch(() => undefined);
+    }
+    destroy() {
+        if (currentTray === this)
+            currentTray = null;
+        void invokeNative('tray', 'destroy').catch(() => undefined);
+    }
+}

package/dist/updater/boot.d.ts

@@ -0,0 +1,20 @@
+export interface BootRecord {
+    version: string;
+    attempts: number;
+    updatedAt: string;
+}
+/** Ruta del registro de arranque dentro de `<userData>`. */
+export declare function bootRecordPath(userDataDir: string): string;
+/** Lee el registro; null si no existe o está corrupto. */
+export declare function readBoot(file: string): BootRecord | null;
+/** Escribe el registro (crea el directorio si hace falta). */
+export declare function writeBoot(file: string, rec: BootRecord): void;
+/**
+ * Calcula el estado del siguiente arranque:
+ * - misma versión que la anterior → `attempts + 1`; si llega al umbral, rollback.
+ * - versión distinta (o primer arranque) → `attempts = 1`, sin rollback.
+ */
+export declare function nextBoot(prev: BootRecord | null, version: string, threshold: number, now?: () => Date): {
+    record: BootRecord;
+    shouldRollback: boolean;
+};

package/dist/updater/boot.js

@@ -0,0 +1,49 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/updater/boot.ts — registro de arranque para el **rollback**.
+//
+// Tras aplicar un update el binario nuevo arranca con una copia de seguridad
+// (`<exe>.owprev`). Si el arranque se repite sin que la app marque "sano"
+// (crash loop), el updater revierte al binario anterior.
+//
+// El contador vive en `<userData>/update-boot.json`:
+//   { "version": "1.4.0", "attempts": 2, "updatedAt": "…" }
+// Cada arranque incrementa `attempts`; cuando la app confirma salud
+// (`commit`), se pone a 0. Si `attempts` alcanza el umbral → rollback.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/** Ruta del registro de arranque dentro de `<userData>`. */
+export function bootRecordPath(userDataDir) {
+    return path.join(userDataDir, 'update-boot.json');
+}
+/** Lee el registro; null si no existe o está corrupto. */
+export function readBoot(file) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (typeof raw?.version !== 'string' || typeof raw?.attempts !== 'number')
+            return null;
+        return { version: raw.version, attempts: raw.attempts, updatedAt: String(raw.updatedAt ?? '') };
+    }
+    catch {
+        return null;
+    }
+}
+/** Escribe el registro (crea el directorio si hace falta). */
+export function writeBoot(file, rec) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(rec) + '\n');
+}
+/**
+ * Calcula el estado del siguiente arranque:
+ * - misma versión que la anterior → `attempts + 1`; si llega al umbral, rollback.
+ * - versión distinta (o primer arranque) → `attempts = 1`, sin rollback.
+ */
+export function nextBoot(prev, version, threshold, now = () => new Date()) {
+    const sameVersion = !!prev && prev.version === version;
+    const attempts = sameVersion ? prev.attempts + 1 : 1;
+    return {
+        record: { version, attempts, updatedAt: now().toISOString() },
+        shouldRollback: sameVersion && attempts >= threshold,
+    };
+}

package/dist/updater/delta.d.ts

@@ -0,0 +1,30 @@
+/** sha256 (hex) de cada bloque de `data` (tamaño `blockSize`). */
+export declare function blockHashes(data: Buffer, blockSize: number): string[];
+/** Bloque de bytes [start, end] (end INCLUSIVE), como un HTTP Range. */
+export interface ByteRange {
+    start: number;
+    end: number;
+}
+export interface DeltaPlan {
+    blockSize: number;
+    total: number;
+    reused: number;
+    changed: number;
+    ranges: ByteRange[];
+    /** Bytes a descargar si se aplica el delta. */
+    downloadBytes: number;
+    /** Bytes del artefacto completo. */
+    totalBytes: number;
+    /** Ratio de cambio (0..1). */
+    ratio: number;
+}
+/**
+ * Plan de delta: compara los hashes locales con los remotos y agrupa los
+ * bloques cambiados en rangos contiguos. `remoteSize` acota el último bloque.
+ */
+export declare function planDelta(localHashes: string[], remoteHashes: string[], blockSize: number, remoteSize: number): DeltaPlan;
+/**
+ * Ensambla el artefacto nuevo reutilizando los bloques locales y pidiendo los
+ * cambiados con `fetchRange` (que debe devolver exactamente ese rango).
+ */
+export declare function assemble(local: Buffer, remoteHashes: string[], plan: DeltaPlan, remoteSize: number, fetchRange: (r: ByteRange) => Promise<Buffer>): Promise<Buffer>;

package/dist/updater/delta.js

@@ -0,0 +1,96 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/updater/delta.ts — delta por bloques (estilo blockmap).
+//
+// El artefacto (p. ej. el binario único) se parte en bloques de tamaño fijo y
+// se publica un blockmap con el sha256 de cada bloque. En el cliente se
+// comparan los bloques locales con los remotos y **solo se descargan los que
+// cambian** (HTTP Range), reutilizando el resto del fichero actual.
+import { createHash } from 'node:crypto';
+/** sha256 (hex) de cada bloque de `data` (tamaño `blockSize`). */
+export function blockHashes(data, blockSize) {
+    const out = [];
+    if (data.length === 0) {
+        out.push(createHash('sha256').update(Buffer.alloc(0)).digest('hex'));
+        return out;
+    }
+    for (let off = 0; off < data.length; off += blockSize) {
+        out.push(createHash('sha256')
+            .update(data.subarray(off, Math.min(off + blockSize, data.length)))
+            .digest('hex'));
+    }
+    return out;
+}
+/**
+ * Plan de delta: compara los hashes locales con los remotos y agrupa los
+ * bloques cambiados en rangos contiguos. `remoteSize` acota el último bloque.
+ */
+export function planDelta(localHashes, remoteHashes, blockSize, remoteSize) {
+    const total = remoteHashes.length;
+    const ranges = [];
+    let cur = null;
+    let changed = 0;
+    const blockEnd = (i) => Math.min((i + 1) * blockSize, remoteSize) - 1;
+    for (let i = 0; i < total; i++) {
+        const same = i < localHashes.length && localHashes[i] === remoteHashes[i];
+        if (same) {
+            if (cur) {
+                ranges.push(cur);
+                cur = null;
+            }
+            continue;
+        }
+        changed++;
+        const start = i * blockSize;
+        if (cur && start === cur.end + 1)
+            cur.end = blockEnd(i);
+        else {
+            if (cur)
+                ranges.push(cur);
+            cur = { start, end: blockEnd(i) };
+        }
+    }
+    if (cur)
+        ranges.push(cur);
+    const downloadBytes = ranges.reduce((n, r) => n + (r.end - r.start + 1), 0);
+    return {
+        blockSize,
+        total,
+        reused: total - changed,
+        changed,
+        ranges,
+        downloadBytes,
+        totalBytes: remoteSize,
+        ratio: total ? changed / total : 1,
+    };
+}
+/**
+ * Ensambla el artefacto nuevo reutilizando los bloques locales y pidiendo los
+ * cambiados con `fetchRange` (que debe devolver exactamente ese rango).
+ */
+export async function assemble(local, remoteHashes, plan, remoteSize, fetchRange) {
+    const out = Buffer.alloc(remoteSize);
+    // bloque = reutilizado salvo que caiga dentro de un rango de descarga
+    let ri = 0;
+    for (let i = 0; i < remoteHashes.length; i++) {
+        const start = i * plan.blockSize;
+        const end = Math.min(start + plan.blockSize, remoteSize);
+        while (ri < plan.ranges.length && plan.ranges[ri].end < start)
+            ri++;
+        const inRange = ri < plan.ranges.length && plan.ranges[ri].start <= start;
+        if (!inRange) {
+            // reutiliza del local (si existe y coincide); si no, se pedirá abajo
+            if (start < local.length)
+                local.copy(out, start, start, Math.min(end, local.length));
+        }
+    }
+    // descarga de los rangos cambiados
+    for (const r of plan.ranges) {
+        const buf = await fetchRange(r);
+        if (buf.length !== r.end - r.start + 1)
+            throw new Error(`rango ${r.start}-${r.end}: recibidos ${buf.length} bytes`);
+        buf.copy(out, r.start);
+    }
+    return out;
+}

package/dist/updater/yaml.d.ts

@@ -0,0 +1,6 @@
+export type YamlValue = string | number | boolean | null | YamlMap | YamlValue[];
+export interface YamlMap {
+    [k: string]: YamlValue;
+}
+/** Parsea un manifiesto YAML a un objeto JS. */
+export declare function parseYaml(text: string): YamlValue;

package/dist/updater/yaml.js

@@ -0,0 +1,160 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/updater/yaml.ts — parser YAML mínimo (subconjunto) para los
+// manifiestos de auto-update. Soporta:
+//   - mapas (`key: value`), anidados por indentación
+//   - listas (`- item`) de escalares o mapas
+//   - escalares (texto, comillas simples/dobles, números, true/false/null)
+//   - bloque literal (`key: |` y `key: >`) con líneas indentadas
+// No soporta: anchors/aliases, flow style, multi-documento, tags. Suficiente
+// para `latest.yml` / `<channel>.yml` (estilo electron-builder).
+function stripComment(s) {
+    // Solo elimina comentarios fuera de comillas.
+    let inS = false;
+    let inD = false;
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c === "'" && !inD)
+            inS = !inS;
+        else if (c === '"' && !inS)
+            inD = !inD;
+        else if (c === '#' && !inS && !inD && (i === 0 || s[i - 1] === ' '))
+            return s.slice(0, i);
+    }
+    return s;
+}
+function tokenize(text) {
+    const out = [];
+    for (const raw of text.replace(/\r\n?/g, '\n').split('\n')) {
+        const noComment = stripComment(raw);
+        if (noComment.trim() === '' || /^---\s*$/.test(noComment.trim()) || /^\.\.\.\s*$/.test(noComment.trim()))
+            continue;
+        const indent = noComment.match(/^ */)[0].length;
+        out.push({ indent, text: noComment.slice(indent) });
+    }
+    return out;
+}
+function parseScalar(s) {
+    const t = s.trim();
+    if (t === '' || t === '~' || t === 'null')
+        return null;
+    if (t === 'true')
+        return true;
+    if (t === 'false')
+        return false;
+    if (/^'.*'$/.test(t))
+        return t.slice(1, -1).replace(/''/g, "'");
+    if (/^".*"$/.test(t)) {
+        try {
+            return JSON.parse(t);
+        }
+        catch {
+            return t.slice(1, -1);
+        }
+    }
+    if (/^-?\d+$/.test(t))
+        return parseInt(t, 10);
+    if (/^-?\d*\.\d+$/.test(t))
+        return parseFloat(t);
+    return t;
+}
+/** Divide "key: value" por el primer ':' seguido de espacio o fin. */
+function splitKey(text) {
+    let inS = false;
+    let inD = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === "'" && !inD)
+            inS = !inS;
+        else if (c === '"' && !inS)
+            inD = !inD;
+        else if (c === ':' && !inS && !inD && (i + 1 === text.length || text[i + 1] === ' '))
+            return { key: text.slice(0, i).trim(), rest: text.slice(i + 1).trim() };
+    }
+    return null;
+}
+function parseBlock(lines, start, indent) {
+    if (start >= lines.length)
+        return { value: null, next: start };
+    const first = lines[start];
+    // Lista
+    if (first.text.startsWith('- ') || first.text === '-') {
+        const arr = [];
+        let i = start;
+        while (i < lines.length && lines[i].indent === indent && (lines[i].text.startsWith('- ') || lines[i].text === '-')) {
+            const item = lines[i].text === '-' ? '' : lines[i].text.slice(2);
+            if (item === '') {
+                const sub = parseBlock(lines, i + 1, lines[i + 1]?.indent ?? indent + 2);
+                arr.push(sub.value);
+                i = sub.next;
+            }
+            else {
+                const kv = splitKey(item);
+                if (kv) {
+                    // mapa en línea (primer campo) + campos siguientes más indentados
+                    const obj = {};
+                    obj[kv.key] = kv.rest === '' ? null : parseScalar(kv.rest);
+                    const sub = parseBlock(lines, i + 1, lines[i + 1]?.indent ?? indent + 2);
+                    if (sub.value && typeof sub.value === 'object' && !Array.isArray(sub.value)) {
+                        Object.assign(obj, sub.value);
+                        i = sub.next;
+                    }
+                    else {
+                        i++;
+                    }
+                    arr.push(obj);
+                }
+                else {
+                    arr.push(parseScalar(item));
+                    i++;
+                }
+            }
+        }
+        return { value: arr, next: i };
+    }
+    // Mapa
+    const obj = {};
+    let i = start;
+    while (i < lines.length && lines[i].indent === indent) {
+        const kv = splitKey(lines[i].text);
+        if (!kv)
+            break;
+        if (kv.rest === '|' || kv.rest === '>') {
+            const blockIndent = lines[i + 1]?.indent ?? indent + 2;
+            const parts = [];
+            i++;
+            while (i < lines.length && lines[i].indent >= blockIndent) {
+                parts.push(lines[i].text);
+                i++;
+            }
+            obj[kv.key] = kv.rest === '>' ? parts.join(' ') : parts.join('\n');
+            continue;
+        }
+        if (kv.rest === '') {
+            // valor anidado (mapa/lista) o null
+            const nextLine = lines[i + 1];
+            if (nextLine && nextLine.indent > indent) {
+                const sub = parseBlock(lines, i + 1, nextLine.indent);
+                obj[kv.key] = sub.value;
+                i = sub.next;
+            }
+            else {
+                obj[kv.key] = null;
+                i++;
+            }
+        }
+        else {
+            obj[kv.key] = parseScalar(kv.rest);
+            i++;
+        }
+    }
+    return { value: obj, next: i };
+}
+/** Parsea un manifiesto YAML a un objeto JS. */
+export function parseYaml(text) {
+    const lines = tokenize(text);
+    if (!lines.length)
+        return null;
+    return parseBlock(lines, 0, lines[0].indent).value;
+}

package/dist/updater.d.ts

@@ -0,0 +1,119 @@
+import { EventEmitter } from 'node:events';
+import { type BootRecord } from './updater/boot.js';
+export interface FeedOptions {
+    provider?: 'generic' | 'github';
+    /** Base del feed (generic) o `owner/repo` (github). */
+    url: string;
+    channel?: string;
+    /** Clave pública Ed25519 (PEM o base64 SPKI). */
+    publicKey?: string;
+}
+export interface UpdateFile {
+    url: string;
+    sha256?: string;
+    sha512?: string;
+    size?: number;
+}
+export interface UpdateInfo {
+    version: string;
+    notes?: string;
+    releaseDate?: string;
+    mandatory?: boolean;
+    sha256?: string;
+    sha512?: string;
+    size?: number;
+    blockSize?: number;
+    blockmap?: string;
+    /** Firma Ed25519 de la metadata: `"<version>:<sha256>"`. */
+    signature?: string;
+    /** Firma Ed25519 del artefacto completo (defensa en profundidad). */
+    binarySig?: string;
+    file: UpdateFile;
+}
+export interface ProgressInfo {
+    total: number;
+    transferred: number;
+    percent: number;
+    bytesPerSecond: number;
+}
+export interface UpdateCheckResult {
+    updateInfo: UpdateInfo;
+}
+export interface InstallOptions {
+    /** Guarda una copia del binario actual para poder revertir (rollback). */
+    backup?: boolean;
+}
+export interface BootGuardOptions {
+    /** Arranques sin confirmar antes de revertir. */
+    threshold?: number;
+    /** ms de vida "sana" tras los que se confirma el update. */
+    healthDelayMs?: number;
+}
+declare function semverGt(a: string, b: string): boolean;
+declare function isPrerelease(v: string): boolean;
+declare class AutoUpdater extends EventEmitter {
+    currentVersion: string;
+    channel: string;
+    allowPrerelease: boolean;
+    autoDownload: boolean;
+    autoInstallOnAppQuit: boolean;
+    /** Nº de reintentos por petición (con backoff exponencial). */
+    maxRetries: number;
+    /** Espera base entre reintentos (ms); se duplica cada intento. */
+    retryDelay: number;
+    /** Timeout por petición (ms). */
+    requestTimeout: number;
+    private feed;
+    private info;
+    private newFile;
+    private healthTimer;
+    setFeedURL(opts: FeedOptions): void;
+    private manifestUrl;
+    private publicKey;
+    /** Verifica la firma Ed25519 del manifiesto (sobre `"<version>:<sha256>"`). */
+    private verifyManifest;
+    private backoff;
+    /**
+     * `fetch` con timeout y reintentos (backoff exponencial) para errores de red
+     * y estados transitorios. Devuelve la respuesta (incluidos 4xx no
+     * reintentables, para que el llamante dé un error concreto).
+     */
+    private request;
+    checkForUpdates(): Promise<UpdateCheckResult | null>;
+    private fetchRange;
+    /** Delta por bloques: blockmap + reutilización local + rangos. */
+    private downloadDelta;
+    /**
+     * Descarga completa con **reanudación**: si la conexión cae a mitad, reintenta
+     * con `Range: bytes=<recibido>-` y continúa en vez de empezar de cero.
+     */
+    private downloadFull;
+    /** Descarga el update (delta si hay blockmap; si no, completa con resume). */
+    downloadUpdate(): Promise<string[]>;
+    /**
+     * Aplica el update (reemplazo atómico + relaunch) vía el módulo nativo.
+     *
+     * El kernel se reemplaza a sí mismo y se re-ejecuta (`execv`) dentro de esta
+     * llamada, así que **no habrá respuesta**: la conexión cae. Lo tratamos como
+     * éxito (el proceso nuevo arranca con el binario actualizado).
+     */
+    quitAndInstall(opts?: InstallOptions): Promise<void>;
+    /**
+     * Revierte al binario anterior (`<exe>.owprev`) y relanza. Solo tiene efecto
+     * si hay una copia de seguridad pendiente (p. ej. tras un update con backup).
+     */
+    rollback(): Promise<void>;
+    /** Confirma el update (borra la copia de seguridad) → desarma el rollback. */
+    commitUpdate(): Promise<void>;
+    /**
+     * Arma el **guard de arranque** tras un update: si el binario nuevo se
+     * reinicia sin llegar a "sano" (crash loop) más de `threshold` veces,
+     * revierte. Si arranca bien `healthDelayMs`, confirma (borra el backup).
+     *
+     *   app.whenReady().then(() => autoUpdater.armBootGuard())
+     */
+    armBootGuard(opts?: BootGuardOptions): Promise<'idle' | 'armed' | 'rolled-back'>;
+}
+export declare const autoUpdater: AutoUpdater;
+export { semverGt, isPrerelease };
+export type { BootRecord };