@owear/core 0.1.3 → 0.1.4

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