@owear/core 0.1.3 → 0.1.5

package/dist/app.d.ts

@@ -8,6 +8,12 @@ export declare const app: {
     /** Conecta con el kernel. Resuelve cuando el canal de control está listo. */
     whenReady(): Promise<void>;
     quit(exitCode?: number): Promise<void>;
+    /**
+     * Define el icono por defecto de la app (ruta a PNG/JPEG). Se aplica a las
+     * ventanas creadas a partir de entonces y a `new BrowserWindow()` sin `icon`.
+     * (Equivale a `BrowserWindow({ icon })` global.)
+     */
+    setIcon(path: string): void;
     info(): Promise<{
         pid: number;
         version: string;

package/dist/app.js

@@ -9,6 +9,7 @@ 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 { setWindowIcon } from './appicon.js';
 import { portRecords, makeMainPort, allocPortId } from './port.js';
 import { protocolHandlers } from './protocol.js';
 /** Resuelto por app.whenReady(). Compartido con BrowserWindow. */
@@ -106,6 +107,14 @@ export const app = {
     quit(exitCode = 0) {
         return channel.call('app.quit', { exitCode }).catch(() => undefined);
     },
+    /**
+     * Define el icono por defecto de la app (ruta a PNG/JPEG). Se aplica a las
+     * ventanas creadas a partir de entonces y a `new BrowserWindow()` sin `icon`.
+     * (Equivale a `BrowserWindow({ icon })` global.)
+     */
+    setIcon(path) {
+        setWindowIcon(path);
+    },
     info() {
         return channel.call('app.info');
     },

package/dist/appicon.d.ts

@@ -0,0 +1,4 @@
+/** Fija el icono por defecto (ruta a PNG/JPEG). */
+export declare function setWindowIcon(path?: string): void;
+/** Icono por defecto actual (o undefined). */
+export declare function windowIcon(): string | undefined;

package/dist/appicon.js

@@ -0,0 +1,16 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/appicon.ts — icono por defecto de la app (compartido).
+//
+// Módulo sin dependencias para evitar ciclos: `app.setIcon(path)` lo fija y
+// `BrowserWindow` lo aplica a cada ventana creada a partir de entonces.
+let iconPath;
+/** Fija el icono por defecto (ruta a PNG/JPEG). */
+export function setWindowIcon(path) {
+    iconPath = path;
+}
+/** Icono por defecto actual (o undefined). */
+export function windowIcon() {
+    return iconPath;
+}

package/dist/browserwindow.d.ts

@@ -11,6 +11,8 @@ export declare class BrowserWindow extends EventEmitter {
     private _onDisconnected;
     constructor(options?: WindowOptions);
     private _create;
+    /** Fija el icono de ESTA ventana (ruta a PNG/JPEG). */
+    setIcon(path: string): Promise<void>;
     private _wireEvents;
     private _unwireEvents;
     get id(): number | null;

package/dist/browserwindow.js

@@ -3,7 +3,8 @@
 //
 // @owear/core/src/browserwindow.ts — BrowserWindow (C9).
 import { EventEmitter } from 'node:events';
-import { channel } from './channel.js';
+import { channel, invokeNative } from './channel.js';
+import { windowIcon } from './appicon.js';
 import { readyPromise } from './app.js';
 import { WebContents, WIN_EVENT_NAMES, WC_EVENT_NAMES } from './webcontents.js';
 // ── BrowserWindow ───────────────────────────────────────────────────────────
@@ -45,14 +46,24 @@ export class BrowserWindow extends EventEmitter {
         readyPromise.then(() => this._create()).catch((e) => this.emit('error', e));
     }
     async _create() {
-        const params = { ...this._options };
-        const res = await channel.call('window.create', params);
+        const { icon, ...rest } = this._options;
+        const res = await channel.call('window.create', { ...rest });
         this._id = res.windowId;
         this._wc._setWindowId(res.windowId);
         windowsById.set(res.windowId, this);
         this._wireEvents();
+        // Icono: el de la opción o el global (app.setIcon). PNG/JPEG.
+        const ic = icon ?? windowIcon();
+        if (ic)
+            await this.setIcon(ic).catch(() => undefined);
         this.emit('ready-to-show', this._id);
     }
+    /** Fija el icono de ESTA ventana (ruta a PNG/JPEG). */
+    async setIcon(path) {
+        const { readFileSync } = await import('node:fs');
+        const pngB64 = readFileSync(path).toString('base64');
+        await invokeNative('window', 'setIcon', this.requireId(), pngB64);
+    }
     _wireEvents() {
         channel.on('window.event', this._onWindowEvent);
         channel.on('disconnected', this._onDisconnected);

package/dist/index.d.ts

@@ -42,6 +42,11 @@ export interface WindowOptions {
      * Crea la partición con `session.fromPartition(name)`.
      */
     session?: string;
+    /**
+     * Icono de la ventana (ruta a un PNG/JPEG). Para un icono por defecto de toda
+     * la app usa `app.setIcon(path)`.
+     */
+    icon?: string;
 }
 export interface Bounds {
     x: number;
@@ -105,6 +110,8 @@ 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 { autoUpdater } from './updater.js';
+export type { FeedOptions, UpdateInfo, UpdateFile, ProgressInfo, UpdateCheckResult, } from './updater.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';

package/dist/index.js

@@ -35,6 +35,8 @@ export { app } from './app.js';
 export { readyPromise } from './app.js';
 // ── instalador (D1): bridge + API del modo instalador/desinstalador ──────────
 export { installer } from './installer.js';
+// ── auto-update ─────────────────────────────────────────────────────────────
+export { autoUpdater } from './updater.js';
 export { defineBridge } from './bridge.js';
 // ── workers Node (utilityProcess.fork) ──────────────────────────────────────
 export { forkWorker, resolveWorkerEntry } from './node/worker.js';

package/dist/installer.d.ts

@@ -53,10 +53,15 @@ export interface StateResult {
     version?: string;
     mode?: string;
     app?: string;
+    /** Directorio de instalación (si se conoce / está registrado). */
+    dir?: string;
 }
 export interface ShortcutOptions {
     execPath: string;
     iconPath?: string;
+    /** Anulan los del manifiesto (por defecto: appId/appName del installer.json). */
+    appId?: string;
+    appName?: string;
     desktop?: boolean;
     menu?: boolean;
     startup?: boolean;
@@ -76,6 +81,13 @@ export declare const installer: {
     info(): Promise<InstallerInfo>;
     /** Bridge embebido (contrato app ↔ installer). */
     bridge<T = unknown>(): Promise<T | null>;
+    /** Directorio de instalación por defecto (absoluto, por usuario). */
+    defaultDir(): Promise<string>;
+    /** Selector NATIVO de carpeta (no depende de módulos .owm). null si cancela. */
+    chooseDir(opts?: {
+        title?: string;
+        defaultPath?: string;
+    }): Promise<string | null>;
     /** Lista los ficheros del payload embebido. */
     payloadList(): Promise<PayloadEntry[]>;
     /** Lee un fichero del payload (base64). */
@@ -97,10 +109,12 @@ export declare const installer: {
     verify(opts: {
         dir: string;
     }): Promise<VerifyResult>;
-    /** Estado de instalación en `dir`. */
-    state(opts: {
-        dir: string;
+    /** Estado de instalación en `dir` (o el registrado si se omite). */
+    state(opts?: {
+        dir?: string;
     }): Promise<StateResult>;
+    /** Lista las apps instaladas (registro de Owear). */
+    list(): Promise<Array<Record<string, unknown>>>;
     /** Crea accesos directos / integración de escritorio. */
     shortcuts(opts: ShortcutOptions): Promise<boolean>;
     /** Lanza un ejecutable en segundo plano (p. ej. la app instalada). */

package/dist/installer.js

@@ -29,6 +29,14 @@ export const installer = {
     bridge() {
         return invokeNative('installer', 'bridge');
     },
+    /** Directorio de instalación por defecto (absoluto, por usuario). */
+    defaultDir() {
+        return invokeNative('installer', 'defaultDir');
+    },
+    /** Selector NATIVO de carpeta (no depende de módulos .owm). null si cancela. */
+    chooseDir(opts = {}) {
+        return invokeNative('installer', 'chooseDir', opts);
+    },
     /** Lista los ficheros del payload embebido. */
     payloadList() {
         return invokeNative('installer', 'payloadList');
@@ -53,10 +61,14 @@ export const installer = {
     verify(opts) {
         return invokeNative('installer', 'verify', opts);
     },
-    /** Estado de instalación en `dir`. */
-    state(opts) {
+    /** Estado de instalación en `dir` (o el registrado si se omite). */
+    state(opts = {}) {
         return invokeNative('installer', 'state', opts);
     },
+    /** Lista las apps instaladas (registro de Owear). */
+    list() {
+        return invokeNative('installer', 'list');
+    },
     /** Crea accesos directos / integración de escritorio. */
     shortcuts(opts) {
         return invokeNative('installer', 'shortcuts', opts);

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 };

package/dist/updater.js

@@ -0,0 +1,429 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// @owear/core/src/updater.ts — autoUpdater (proceso principal).
+//
+// Estilo electron-updater pero para Owear:
+//   autoUpdater.checkForUpdates() · downloadUpdate() · quitAndInstall()
+//   autoUpdater.rollback() · commitUpdate() · armBootGuard()
+//   eventos: checking-for-update · update-available · update-not-available ·
+//            error · download-progress · update-downloaded
+//
+// Manifiesto YAML por canal (`<channel>.yml`, p. ej. latest.yml):
+//   version: 1.4.0
+//   releaseDate: '2026-09-29T…'
+//   notes: |
+//     …
+//   path: MiApp-1.4.0.bin
+//   sha256: <hex>            # integridad del artefacto
+//   sha512: <hex>
+//   size: 123456
+//   blockSize: 262144        # delta por bloques
+//   blockmap: https://…/MiApp-1.4.0.bin.blockmap
+//   signature: <base64>      # Ed25519 sobre "<version>:<sha256>" (metadata)
+//   binarySig: <base64>      # Ed25519 sobre los bytes del artefacto (payload)
+//
+// La firma se verifica con la clave pública del bridge (`updater.publicKey`).
+import { EventEmitter } from 'node:events';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { app } from './app.js';
+import { invokeNative } from './channel.js';
+import { parseYaml } from './updater/yaml.js';
+import { assemble, blockHashes, planDelta } from './updater/delta.js';
+import { bootRecordPath, nextBoot, readBoot, writeBoot } from './updater/boot.js';
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function semverGt(a, b) {
+    const p = (s) => {
+        const core = s.replace(/^v/, '').split('-')[0];
+        const parts = core.split('.').map((n) => parseInt(n, 10) || 0);
+        while (parts.length < 3)
+            parts.push(0);
+        return parts;
+    };
+    const [x, y] = [p(a), p(b)];
+    for (let i = 0; i < 3; i++)
+        if (x[i] !== y[i])
+            return x[i] > y[i];
+    return false;
+}
+function isPrerelease(v) {
+    return v.replace(/^v/, '').includes('-');
+}
+function canonical(version, sha256) {
+    return Buffer.from(`${version}:${sha256}`);
+}
+const RETRYABLE = new Set([408, 425, 429, 500, 502, 503, 504]);
+class AutoUpdater extends EventEmitter {
+    currentVersion = app.getVersion();
+    channel = 'latest';
+    allowPrerelease = false;
+    autoDownload = true;
+    autoInstallOnAppQuit = true;
+    /** Nº de reintentos por petición (con backoff exponencial). */
+    maxRetries = 3;
+    /** Espera base entre reintentos (ms); se duplica cada intento. */
+    retryDelay = 800;
+    /** Timeout por petición (ms). */
+    requestTimeout = 60_000;
+    feed = null;
+    info = null;
+    newFile = '';
+    healthTimer = null;
+    setFeedURL(opts) {
+        this.feed = opts;
+        if (opts.channel)
+            this.channel = opts.channel;
+    }
+    manifestUrl() {
+        if (!this.feed)
+            throw new Error('autoUpdater.setFeedURL() primero');
+        const { provider = 'generic', url } = this.feed;
+        if (provider === 'github')
+            return `https://github.com/${url}/releases/latest/download/${this.channel}.yml`;
+        return `${url.replace(/\/+$/, '')}/${this.channel}.yml`;
+    }
+    publicKey() {
+        const pub = this.feed?.publicKey;
+        if (!pub)
+            return null;
+        try {
+            if (pub.includes('BEGIN'))
+                return crypto.createPublicKey(pub);
+            return crypto.createPublicKey({
+                key: Buffer.from(pub, 'base64'),
+                format: 'der',
+                type: 'spki',
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Verifica la firma Ed25519 del manifiesto (sobre `"<version>:<sha256>"`). */
+    verifyManifest(info) {
+        const key = this.publicKey();
+        if (!key)
+            return true; // sin clave pública: no se exige (pero sha256 sí)
+        if (!info.signature || !info.sha256)
+            return false;
+        try {
+            return crypto.verify(null, canonical(info.version, info.sha256), key, Buffer.from(info.signature, 'base64'));
+        }
+        catch {
+            return false;
+        }
+    }
+    backoff(attempt) {
+        const ms = Math.min(this.retryDelay * 2 ** (attempt - 1), 15_000) + Math.floor(Math.random() * 250);
+        return sleep(ms);
+    }
+    /**
+     * `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).
+     */
+    async request(url, init = {}, what = 'petición') {
+        let lastErr;
+        for (let attempt = 0;; attempt++) {
+            const ctrl = new AbortController();
+            const timer = setTimeout(() => ctrl.abort(), this.requestTimeout);
+            try {
+                const res = await fetch(url, { ...init, signal: ctrl.signal });
+                if (RETRYABLE.has(res.status) && attempt < this.maxRetries) {
+                    // libera la conexión antes de reintentar (si no, se filtra el socket)
+                    await res.body?.cancel().catch(() => undefined);
+                    await this.backoff(attempt + 1);
+                    continue;
+                }
+                return res;
+            }
+            catch (e) {
+                lastErr = e;
+                if (attempt >= this.maxRetries)
+                    throw e;
+                await this.backoff(attempt + 1);
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }
+        throw lastErr instanceof Error ? lastErr : new Error(`${what} falló`);
+    }
+    async checkForUpdates() {
+        this.emit('checking-for-update');
+        try {
+            const res = await this.request(this.manifestUrl(), {}, 'manifiesto');
+            if (!res.ok)
+                throw new Error(`feed ${res.status} ${res.statusText}`);
+            const text = await res.text();
+            const doc = parseYaml(text);
+            if (!doc || typeof doc !== 'object')
+                throw new Error('manifiesto YAML inválido');
+            const version = String(doc.version ?? '');
+            const filePath = String(doc.path ?? '');
+            const base = this.manifestUrl().replace(/\/[^/]+$/, '');
+            const rawBlockmap = doc.blockmap != null ? String(doc.blockmap) : undefined;
+            const info = {
+                version,
+                notes: doc.notes != null ? String(doc.notes) : undefined,
+                releaseDate: doc.releaseDate != null ? String(doc.releaseDate) : undefined,
+                mandatory: doc.mandatory === true,
+                sha256: doc.sha256 != null ? String(doc.sha256) : undefined,
+                sha512: doc.sha512 != null ? String(doc.sha512) : undefined,
+                size: typeof doc.size === 'number' ? doc.size : undefined,
+                blockSize: typeof doc.blockSize === 'number' ? doc.blockSize : undefined,
+                // un blockmap relativo se resuelve contra el directorio del manifiesto
+                blockmap: rawBlockmap && !/^https?:\/\//i.test(rawBlockmap) ? `${base}/${rawBlockmap}` : rawBlockmap,
+                signature: doc.signature != null ? String(doc.signature) : undefined,
+                binarySig: doc.binarySig != null ? String(doc.binarySig) : undefined,
+                file: {
+                    url: `${base}/${filePath}`,
+                    sha256: doc.sha256 != null ? String(doc.sha256) : undefined,
+                },
+            };
+            if (!version)
+                throw new Error('manifiesto sin version');
+            if (!this.verifyManifest(info))
+                throw new Error('firma del manifiesto inválida');
+            // sin clave pública la firma es best-effort (documentado): no abortamos.
+            // Si hay clave, `verifyManifest` ya exigió `signature`.
+            this.info = info;
+            const isNew = semverGt(version, this.currentVersion);
+            const preBlocked = isPrerelease(version) && !this.allowPrerelease && !isPrerelease(this.currentVersion);
+            if (isNew && !preBlocked) {
+                this.emit('update-available', info);
+                if (this.autoDownload)
+                    void this.downloadUpdate().catch((e) => this.emit('error', e));
+                return { updateInfo: info };
+            }
+            this.emit('update-not-available', info);
+            return null;
+        }
+        catch (e) {
+            this.emit('error', e instanceof Error ? e : new Error(String(e)));
+            return null;
+        }
+    }
+    async fetchRange(url, r) {
+        const res = await this.request(url, { headers: { Range: `bytes=${r.start}-${r.end}` } }, 'rango');
+        if (res.status !== 206)
+            throw new Error(`el servidor no soporta Range (${res.status} al pedir ${r.start}-${r.end})`);
+        const buf = Buffer.from(await res.arrayBuffer());
+        if (buf.length !== r.end - r.start + 1)
+            throw new Error(`rango ${r.start}-${r.end}: recibidos ${buf.length} bytes`);
+        return buf;
+    }
+    /** Delta por bloques: blockmap + reutilización local + rangos. */
+    async downloadDelta(info, local) {
+        const bmRes = await this.request(info.blockmap, {}, 'blockmap');
+        if (!bmRes.ok)
+            throw new Error(`blockmap ${bmRes.status}`);
+        const bm = JSON.parse(await bmRes.text());
+        const plan = planDelta(blockHashes(local, bm.blockSize), bm.blocks, bm.blockSize, bm.size);
+        this.emit('download-progress', { total: plan.totalBytes, transferred: 0, percent: 0, bytesPerSecond: 0 });
+        const started = Date.now();
+        let done = 0;
+        const out = await assemble(local, bm.blocks, plan, bm.size, async (r) => {
+            const buf = await this.fetchRange(info.file.url, r);
+            done += buf.length;
+            const elapsed = (Date.now() - started) / 1000 || 0.001;
+            this.emit('download-progress', {
+                total: plan.totalBytes,
+                transferred: done,
+                percent: plan.totalBytes ? Math.round((done / plan.totalBytes) * 100) : 100,
+                bytesPerSecond: Math.round(done / elapsed),
+            });
+            return buf;
+        });
+        // cierre: el "100%" del delta es sobre los bloques descargados, no sobre el
+        // total del artefacto; al terminar lo reflejamos explícitamente.
+        const elapsed = (Date.now() - started) / 1000 || 0.001;
+        this.emit('download-progress', {
+            total: plan.totalBytes,
+            transferred: plan.totalBytes,
+            percent: 100,
+            bytesPerSecond: Math.round(plan.totalBytes / elapsed),
+        });
+        return out;
+    }
+    /**
+     * 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.
+     */
+    async downloadFull(info) {
+        const url = info.file.url;
+        const started = Date.now();
+        let chunks = [];
+        let got = 0;
+        let lastErr;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+                const headers = {};
+                if (got > 0)
+                    headers.Range = `bytes=${got}-`;
+                const res = await this.request(url, { headers }, 'descarga');
+                if (!res.ok && res.status !== 206)
+                    throw new Error(`descarga ${res.status}`);
+                if (got > 0 && res.status !== 206) {
+                    chunks = [];
+                    got = 0; // el servidor ignoró el Range
+                }
+                const total = Number(res.headers.get('content-length') ?? 0) + got || info.size || 0;
+                const reader = res.body?.getReader();
+                if (!reader) {
+                    const buf = Buffer.from(await res.arrayBuffer());
+                    chunks.push(buf);
+                    got += buf.length;
+                    return Buffer.concat(chunks);
+                }
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    const b = Buffer.from(value);
+                    chunks.push(b);
+                    got += b.length;
+                    const elapsed = (Date.now() - started) / 1000 || 0.001;
+                    this.emit('download-progress', {
+                        total,
+                        transferred: got,
+                        percent: total ? Math.min(100, Math.round((got / total) * 100)) : 0,
+                        bytesPerSecond: Math.round(got / elapsed),
+                    });
+                }
+                return Buffer.concat(chunks);
+            }
+            catch (e) {
+                lastErr = e;
+                if (attempt >= this.maxRetries)
+                    break;
+                await this.backoff(attempt + 1); // continúa desde `got` (resume)
+            }
+        }
+        throw lastErr instanceof Error ? lastErr : new Error('descarga falló');
+    }
+    /** Descarga el update (delta si hay blockmap; si no, completa con resume). */
+    async downloadUpdate() {
+        const info = this.info;
+        if (!info)
+            throw new Error('checkForUpdates() primero');
+        const state = await invokeNative('updater', 'state').catch(() => ({}));
+        const dest = path.join(os.tmpdir(), `owear-update-${info.version}${path.extname(info.file.url) || '.bin'}`);
+        let local = Buffer.alloc(0);
+        if (info.blockmap && info.blockSize && state.exe) {
+            try {
+                local = fs.readFileSync(state.exe);
+            }
+            catch {
+                local = Buffer.alloc(0);
+            }
+        }
+        let data;
+        if (info.blockmap && info.blockSize && local.length > 0) {
+            try {
+                data = await this.downloadDelta(info, local);
+            }
+            catch {
+                // sin Range / blockmap inválido → descarga completa
+                data = await this.downloadFull(info);
+            }
+        }
+        else {
+            data = await this.downloadFull(info);
+        }
+        // Integridad (sha256; sha512 opcional) y firma del payload (binarySig).
+        if (info.sha256) {
+            const got = crypto.createHash('sha256').update(data).digest('hex');
+            if (got !== info.sha256)
+                throw new Error('sha256 del update no coincide');
+        }
+        if (info.sha512) {
+            const got = crypto.createHash('sha512').update(data).digest('hex');
+            if (got !== info.sha512)
+                throw new Error('sha512 del update no coincide');
+        }
+        if (info.binarySig) {
+            const key = this.publicKey();
+            if (key) {
+                const ok = crypto.verify(null, data, key, Buffer.from(info.binarySig, 'base64'));
+                if (!ok)
+                    throw new Error('firma del binario (binarySig) inválida');
+            }
+            // sin clave pública: best-effort (el sha256 ya garantiza integridad)
+        }
+        fs.writeFileSync(dest, data);
+        this.newFile = dest;
+        this.emit('update-downloaded', info);
+        if (this.autoInstallOnAppQuit) {
+            app.once('before-quit', () => void this.quitAndInstall().catch(() => undefined));
+        }
+        return [dest];
+    }
+    /**
+     * 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).
+     */
+    async quitAndInstall(opts = {}) {
+        if (!this.newFile)
+            throw new Error('downloadUpdate() primero');
+        const backup = opts.backup !== false;
+        try {
+            await invokeNative('updater', 'apply', { path: this.newFile, backup });
+        }
+        catch {
+            // esperado: el proceso fue reemplazado y relanzado
+        }
+    }
+    /**
+     * 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).
+     */
+    async rollback() {
+        try {
+            await invokeNative('updater', 'rollback');
+        }
+        catch {
+            // el proceso fue reemplazado y relanzado
+        }
+    }
+    /** Confirma el update (borra la copia de seguridad) → desarma el rollback. */
+    async commitUpdate() {
+        if (this.healthTimer) {
+            clearTimeout(this.healthTimer);
+            this.healthTimer = null;
+        }
+        await invokeNative('updater', 'commit').catch(() => undefined);
+    }
+    /**
+     * 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())
+     */
+    async armBootGuard(opts = {}) {
+        const threshold = opts.threshold ?? 3;
+        const healthDelayMs = opts.healthDelayMs ?? 10_000;
+        const st = await invokeNative('updater', 'state').catch(() => ({}));
+        if (!st.hasRollback)
+            return 'idle'; // sin update pendiente
+        const file = bootRecordPath(app.getPath('userData'));
+        const next = nextBoot(readBoot(file), this.currentVersion, threshold);
+        if (next.shouldRollback) {
+            await this.rollback();
+            return 'rolled-back';
+        }
+        writeBoot(file, next.record);
+        this.healthTimer = setTimeout(() => void this.commitUpdate(), healthDelayMs);
+        this.healthTimer.unref?.();
+        return 'armed';
+    }
+}
+export const autoUpdater = new AutoUpdater();
+export { semverGt, isPrerelease };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owear/core",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Owear core SDK — controla el kernel nativo desde JavaScript",
   "type": "module",
   "main": "./dist/index.js",
@@ -33,6 +33,6 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "node --test test/worker.test.mjs test/port.test.mjs test/app.test.mjs test/nativeimage.test.mjs test/menu.test.mjs test/c10.test.mjs"
+    "test": "node --test test/worker.test.mjs test/port.test.mjs test/app.test.mjs test/nativeimage.test.mjs test/menu.test.mjs test/c10.test.mjs test/updater.test.mjs test/updater-feed.test.mjs test/updater-boot.test.mjs test/updater-sign.test.mjs test/updater-retry.test.mjs"
   }
 }