@flighthq/updater 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './updater';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './updater';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}

package/dist/updater.d.ts

@@ -0,0 +1,25 @@
+import type { AppUpdater, UpdateInfo, UpdaterBackend, UpdaterConfig, UpdaterSignatureConfig, UpdaterState } from '@flighthq/types';
+export declare function attachAppUpdater(updater: AppUpdater): void;
+export declare function cancelAppUpdateDownload(): void;
+export declare function checkAndDownloadAppUpdate(): void;
+export declare function checkForAppUpdate(): void;
+export declare function createAppUpdater(): AppUpdater;
+export declare function createUpdaterConfig(): UpdaterConfig;
+export declare function createUpdaterState(): UpdaterState;
+export declare function createWebUpdaterBackend(): UpdaterBackend;
+export declare function detachAppUpdater(updater: AppUpdater): void;
+export declare function disposeAppUpdater(updater: AppUpdater): void;
+export declare function downloadAppUpdate(): void;
+export declare function getAppUpdaterState(updater: AppUpdater): Readonly<UpdaterState>;
+export declare function getUpdaterBackend(): UpdaterBackend;
+export declare function getUpdaterChannel(): string;
+export declare function getUpdaterConfig(): Readonly<UpdaterConfig>;
+export declare function isAppUpdateEligible(info: Readonly<UpdateInfo>, rolloutSeed: number): boolean;
+export declare function quitAndInstallUpdate(): void;
+export declare function rollbackAppUpdate(): void;
+export declare function setUpdaterBackend(backend: UpdaterBackend | null): void;
+export declare function setUpdaterChannel(channel: string): void;
+export declare function setUpdaterConfig(config: Readonly<UpdaterConfig>): void;
+export declare function setUpdaterFeedUrl(url: string): void;
+export declare function setUpdaterSignatureConfig(config: Readonly<UpdaterSignatureConfig> | null): void;
+//# sourceMappingURL=updater.d.ts.map

package/dist/updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updater.d.ts","sourceRoot":"","sources":["../src/updater.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,aAAa,EACb,sBAAsB,EACtB,YAAY,EACb,MAAM,iBAAiB,CAAC;AAMzB,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CA+C1D;AAID,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAID,wBAAgB,yBAAyB,IAAI,IAAI,CAMhD;AAID,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAID,wBAAgB,gBAAgB,IAAI,UAAU,CAe7C;AAID,wBAAgB,mBAAmB,IAAI,aAAa,CAMnD;AAGD,wBAAgB,kBAAkB,IAAI,YAAY,CAOjD;AAID,wBAAgB,uBAAuB,IAAI,cAAc,CAsDxD;AAGD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAM1D;AAID,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAE3D;AAID,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAKD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,UAAU,GAAG,QAAQ,CAAC,YAAY,CAAC,CAE9E;AAGD,wBAAgB,iBAAiB,IAAI,cAAc,CAGlD;AAGD,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAGD,wBAAgB,gBAAgB,IAAI,QAAQ,CAAC,aAAa,CAAC,CAE1D;AAMD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAE5F;AAGD,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAID,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAGD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,GAAG,IAAI,CAEtE;AAID,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAEvD;AAID,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,GAAG,IAAI,CAEtE;AAGD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEnD;AAKD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,QAAQ,CAAC,sBAAsB,CAAC,GAAG,IAAI,GAAG,IAAI,CAE/F"}

package/dist/updater.js

@@ -0,0 +1,254 @@
+import { createSignal, emitSignal } from '@flighthq/signals';
+// Begins delivering update lifecycle events to `updater`'s signals by subscribing to the active
+// backend. Each subscribe* is wired to its matching signal, and the phase state is updated on every
+// event so getAppUpdaterState reflects the latest lifecycle. Idempotent: a prior subscription is
+// torn down first. Pair with detachAppUpdater/disposeAppUpdater.
+export function attachAppUpdater(updater) {
+    detachAppUpdater(updater);
+    const backend = getUpdaterBackend();
+    const unsubscribes = [
+        backend.subscribeChecking(() => {
+            _setState(updater, { phase: 'Checking', info: null, progress: null, error: null });
+            emitSignal(updater.onChecking);
+        }),
+        backend.subscribeUpdateAvailable((info) => {
+            _setState(updater, { phase: 'UpdateAvailable', info, progress: null, error: null });
+            emitSignal(updater.onUpdateAvailable, info);
+        }),
+        backend.subscribeUpdateNotAvailable(() => {
+            _setState(updater, (prev) => ({ ...prev, phase: 'Idle' }));
+            emitSignal(updater.onUpdateNotAvailable);
+        }),
+        backend.subscribeDownloadProgress((progress) => {
+            _setState(updater, (prev) => ({ ...prev, phase: 'Downloading', progress }));
+            emitSignal(updater.onDownloadProgress, progress);
+        }),
+        backend.subscribeUpdateDownloaded((info) => {
+            _setState(updater, (prev) => ({ ...prev, phase: 'Downloaded', info, progress: null }));
+            emitSignal(updater.onUpdateDownloaded, info);
+        }),
+        backend.subscribeError((error) => {
+            _setState(updater, (prev) => ({ ...prev, phase: 'Error', error }));
+            emitSignal(updater.onError, error);
+        }),
+        backend.subscribeUpdateCancelled(() => {
+            _setState(updater, (prev) => ({ ...prev, phase: 'Idle' }));
+            emitSignal(updater.onUpdateCancelled);
+        }),
+        backend.subscribeUpdateStaging(() => {
+            _setState(updater, (prev) => ({ ...prev, phase: 'Staging' }));
+            emitSignal(updater.onUpdateStaging);
+        }),
+        backend.subscribeUpdateVerified(() => {
+            emitSignal(updater.onUpdateVerified);
+        }),
+        backend.subscribeUpdateRolledBack(() => {
+            _setState(updater, (prev) => ({ ...prev, phase: 'Idle', info: null, progress: null, error: null }));
+            emitSignal(updater.onUpdateRolledBack);
+        }),
+    ];
+    _subscriptions.set(updater, () => {
+        for (const unsubscribe of unsubscribes)
+            unsubscribe();
+    });
+}
+// Asks the active backend to cancel a download in progress. Result arrives via onUpdateCancelled or
+// onError(kind: 'Cancelled') depending on the backend.
+export function cancelAppUpdateDownload() {
+    getUpdaterBackend().cancelDownload();
+}
+// Triggers a check; if an update is found and autoDownload is true, also starts the download. This
+// is a single-call convenience; results still arrive through signals.
+export function checkAndDownloadAppUpdate() {
+    const config = getUpdaterConfig();
+    getUpdaterBackend().checkForUpdates();
+    if (config.autoDownload) {
+        getUpdaterBackend().downloadUpdate();
+    }
+}
+// Asks the active backend to check for an available update. Lifecycle results arrive through the
+// attached AppUpdater's signals.
+export function checkForAppUpdate() {
+    getUpdaterBackend().checkForUpdates();
+}
+// Allocates an AppUpdater event entity with inert signals and an Idle state; call attachAppUpdater
+// to start delivery.
+export function createAppUpdater() {
+    const updater = {
+        onChecking: createSignal(),
+        onDownloadProgress: createSignal(),
+        onError: createSignal(),
+        onUpdateAvailable: createSignal(),
+        onUpdateCancelled: createSignal(),
+        onUpdateDownloaded: createSignal(),
+        onUpdateNotAvailable: createSignal(),
+        onUpdateRolledBack: createSignal(),
+        onUpdateStaging: createSignal(),
+        onUpdateVerified: createSignal(),
+    };
+    _states.set(updater, createUpdaterState());
+    return updater;
+}
+// Allocates an UpdaterConfig with the recommended defaults: manual download, no auto-install, no
+// prerelease.
+export function createUpdaterConfig() {
+    return {
+        allowPrerelease: false,
+        autoDownload: false,
+        autoInstallOnAppQuit: false,
+    };
+}
+// Allocates a zeroed UpdaterState at the Idle phase with all payloads null.
+export function createUpdaterState() {
+    return {
+        error: null,
+        info: null,
+        phase: 'Idle',
+        progress: null,
+    };
+}
+// Builds the default web backend. Auto-update needs a native host, so every command no-ops and every
+// subscribe* returns an inert unsubscribe — the browser has no application updater to drive.
+export function createWebUpdaterBackend() {
+    let _config = createUpdaterConfig();
+    let _channel = 'stable';
+    return {
+        cancelDownload() { },
+        checkForUpdates() { },
+        downloadUpdate() { },
+        getChannel() {
+            return _channel;
+        },
+        getConfig() {
+            return _config;
+        },
+        quitAndInstall() { },
+        rollback() { },
+        setChannel(channel) {
+            _channel = channel;
+        },
+        setConfig(config) {
+            _config = { ...config };
+        },
+        setFeedUrl() { },
+        setSignatureConfig() { },
+        subscribeChecking() {
+            return () => { };
+        },
+        subscribeDownloadProgress() {
+            return () => { };
+        },
+        subscribeError() {
+            return () => { };
+        },
+        subscribeUpdateAvailable() {
+            return () => { };
+        },
+        subscribeUpdateCancelled() {
+            return () => { };
+        },
+        subscribeUpdateDownloaded() {
+            return () => { };
+        },
+        subscribeUpdateNotAvailable() {
+            return () => { };
+        },
+        subscribeUpdateRolledBack() {
+            return () => { };
+        },
+        subscribeUpdateStaging() {
+            return () => { };
+        },
+        subscribeUpdateVerified() {
+            return () => { };
+        },
+    };
+}
+// Stops delivery to `updater` and forgets its subscription. Safe to call when not attached.
+export function detachAppUpdater(updater) {
+    const unsubscribe = _subscriptions.get(updater);
+    if (unsubscribe !== undefined) {
+        unsubscribe();
+        _subscriptions.delete(updater);
+    }
+}
+// Releases `updater` for garbage collection by detaching its backend subscription. The signals remain
+// plain GC-managed memory afterward.
+export function disposeAppUpdater(updater) {
+    detachAppUpdater(updater);
+}
+// Asks the active backend to download the available update. Progress and completion arrive through
+// the attached AppUpdater's signals.
+export function downloadAppUpdate() {
+    getUpdaterBackend().downloadUpdate();
+}
+// Returns the current queryable lifecycle state for `updater`. This lets a late subscriber or UI
+// read whether a check is pending, what update is available, or the last error, without having
+// listened since the beginning.
+export function getAppUpdaterState(updater) {
+    return _states.get(updater) ?? createUpdaterState();
+}
+// The active updater backend, or a lazily-created web default. There is always a backend.
+export function getUpdaterBackend() {
+    if (_backend === null)
+        _backend = createWebUpdaterBackend();
+    return _backend;
+}
+// Returns the active update channel string. Conventional values are 'stable', 'beta', 'alpha'.
+export function getUpdaterChannel() {
+    return getUpdaterBackend().getChannel();
+}
+// Returns a copy of the active updater configuration.
+export function getUpdaterConfig() {
+    return getUpdaterBackend().getConfig();
+}
+// Deterministic check for staged-rollout eligibility. Returns true when the given `rolloutSeed`
+// (a number in [0, 1)) falls within the update's staged rollout percentage. A seed derived from a
+// stable device/user identifier ensures consistent results across sessions for the same device.
+// NOTE: `stagedRolloutPercent` is 0–100; 100 means full rollout.
+export function isAppUpdateEligible(info, rolloutSeed) {
+    return rolloutSeed * 100 < info.stagedRolloutPercent;
+}
+// Quits the application and installs a downloaded update via the active backend.
+export function quitAndInstallUpdate() {
+    getUpdaterBackend().quitAndInstall();
+}
+// Requests the active backend to roll back the last installed update. The backend must support
+// rollback (Squirrel/MSIX); the web default no-ops. Result arrives via onUpdateRolledBack.
+export function rollbackAppUpdate() {
+    getUpdaterBackend().rollback();
+}
+// Installs a native host updater backend; pass null to fall back to the web default.
+export function setUpdaterBackend(backend) {
+    _backend = backend;
+}
+// Sets the active update channel. Conventional values: 'stable', 'beta', 'alpha'. Free string so
+// hosts and apps can define their own channels. Layered over the feed URL, not replacing it.
+export function setUpdaterChannel(channel) {
+    getUpdaterBackend().setChannel(channel);
+}
+// Applies an updater configuration (auto-download, auto-install-on-quit, allow-prerelease) to the
+// active backend.
+export function setUpdaterConfig(config) {
+    getUpdaterBackend().setConfig(config);
+}
+// Points the active backend at an update feed URL.
+export function setUpdaterFeedUrl(url) {
+    getUpdaterBackend().setFeedUrl(url);
+}
+// Configures signature/integrity verification for the active backend. Verification executes in the
+// host backend; this package owns the configuration contract and the result events. Pass null to
+// clear any previously set signature config.
+export function setUpdaterSignatureConfig(config) {
+    getUpdaterBackend().setSignatureConfig(config);
+}
+let _backend = null;
+const _states = new WeakMap();
+const _subscriptions = new WeakMap();
+// Updates the per-entity state. Accepts either a full replacement or an updater function.
+function _setState(updater, update) {
+    const prev = _states.get(updater) ?? createUpdaterState();
+    const next = typeof update === 'function' ? update(prev) : update;
+    _states.set(updater, next);
+}
+//# sourceMappingURL=updater.js.map

package/dist/updater.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"updater.js","sourceRoot":"","sources":["../src/updater.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@flighthq/updater",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/signals": "0.1.0",
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Application auto-update lifecycle signals (checking, available, progress, downloaded, error) over a swappable web/native backend",
+  "sideEffects": false
+}

package/src/updater.test.ts

@@ -0,0 +1,652 @@
+import { connectSignal } from '@flighthq/signals';
+import type { UpdateInfo, UpdateProgress, UpdaterBackend, UpdaterError } from '@flighthq/types';
+
+import {
+  attachAppUpdater,
+  cancelAppUpdateDownload,
+  checkAndDownloadAppUpdate,
+  checkForAppUpdate,
+  createAppUpdater,
+  createUpdaterConfig,
+  createUpdaterState,
+  createWebUpdaterBackend,
+  detachAppUpdater,
+  disposeAppUpdater,
+  downloadAppUpdate,
+  getAppUpdaterState,
+  getUpdaterBackend,
+  getUpdaterChannel,
+  getUpdaterConfig,
+  isAppUpdateEligible,
+  quitAndInstallUpdate,
+  rollbackAppUpdate,
+  setUpdaterBackend,
+  setUpdaterChannel,
+  setUpdaterConfig,
+  setUpdaterFeedUrl,
+  setUpdaterSignatureConfig,
+} from './updater';
+
+const FULL_UPDATE_INFO: UpdateInfo = {
+  deltaFromVersion: null,
+  downloadSizeBytes: 10_000_000,
+  isMandatory: false,
+  minimumOsVersion: null,
+  notes: 'fixes',
+  releaseDate: '2026-06-19',
+  sha512: 'abc123',
+  stagedRolloutPercent: 100,
+  version: '1.2.3',
+};
+
+interface FakeUpdaterBackend extends UpdaterBackend {
+  feedUrl: string;
+  checked: number;
+  downloaded: number;
+  cancelled: number;
+  quit: number;
+  rolledBack: number;
+  fireChecking: () => void;
+  fireUpdateAvailable: (info: Readonly<UpdateInfo>) => void;
+  fireUpdateNotAvailable: () => void;
+  fireDownloadProgress: (progress: Readonly<UpdateProgress>) => void;
+  fireUpdateDownloaded: (info: Readonly<UpdateInfo>) => void;
+  fireError: (error: Readonly<UpdaterError>) => void;
+  fireUpdateCancelled: () => void;
+  fireUpdateStaging: () => void;
+  fireUpdateVerified: () => void;
+  fireUpdateRolledBack: () => void;
+}
+
+function fakeBackend(): FakeUpdaterBackend {
+  let checking: (() => void) | null = null;
+  let updateAvailable: ((info: Readonly<UpdateInfo>) => void) | null = null;
+  let updateNotAvailable: (() => void) | null = null;
+  let downloadProgress: ((progress: Readonly<UpdateProgress>) => void) | null = null;
+  let updateDownloaded: ((info: Readonly<UpdateInfo>) => void) | null = null;
+  let error: ((error: Readonly<UpdaterError>) => void) | null = null;
+  let updateCancelled: (() => void) | null = null;
+  let updateStaging: (() => void) | null = null;
+  let updateVerified: (() => void) | null = null;
+  let updateRolledBack: (() => void) | null = null;
+  let channel = 'stable';
+  let config = createUpdaterConfig();
+  return {
+    feedUrl: '',
+    checked: 0,
+    downloaded: 0,
+    cancelled: 0,
+    quit: 0,
+    rolledBack: 0,
+    cancelDownload() {
+      this.cancelled++;
+    },
+    checkForUpdates() {
+      this.checked++;
+    },
+    downloadUpdate() {
+      this.downloaded++;
+    },
+    getChannel() {
+      return channel;
+    },
+    getConfig() {
+      return config;
+    },
+    quitAndInstall() {
+      this.quit++;
+    },
+    rollback() {
+      this.rolledBack++;
+    },
+    setChannel(c) {
+      channel = c;
+    },
+    setConfig(c) {
+      config = { ...c };
+    },
+    setFeedUrl(url) {
+      this.feedUrl = url;
+    },
+    setSignatureConfig() {},
+    subscribeChecking(listener) {
+      checking = listener;
+      return () => {
+        checking = null;
+      };
+    },
+    subscribeDownloadProgress(listener) {
+      downloadProgress = listener;
+      return () => {
+        downloadProgress = null;
+      };
+    },
+    subscribeError(listener) {
+      error = listener;
+      return () => {
+        error = null;
+      };
+    },
+    subscribeUpdateAvailable(listener) {
+      updateAvailable = listener;
+      return () => {
+        updateAvailable = null;
+      };
+    },
+    subscribeUpdateCancelled(listener) {
+      updateCancelled = listener;
+      return () => {
+        updateCancelled = null;
+      };
+    },
+    subscribeUpdateDownloaded(listener) {
+      updateDownloaded = listener;
+      return () => {
+        updateDownloaded = null;
+      };
+    },
+    subscribeUpdateNotAvailable(listener) {
+      updateNotAvailable = listener;
+      return () => {
+        updateNotAvailable = null;
+      };
+    },
+    subscribeUpdateRolledBack(listener) {
+      updateRolledBack = listener;
+      return () => {
+        updateRolledBack = null;
+      };
+    },
+    subscribeUpdateStaging(listener) {
+      updateStaging = listener;
+      return () => {
+        updateStaging = null;
+      };
+    },
+    subscribeUpdateVerified(listener) {
+      updateVerified = listener;
+      return () => {
+        updateVerified = null;
+      };
+    },
+    fireChecking() {
+      checking?.();
+    },
+    fireUpdateAvailable(info) {
+      updateAvailable?.(info);
+    },
+    fireUpdateNotAvailable() {
+      updateNotAvailable?.();
+    },
+    fireDownloadProgress(progress) {
+      downloadProgress?.(progress);
+    },
+    fireUpdateDownloaded(info) {
+      updateDownloaded?.(info);
+    },
+    fireError(e) {
+      error?.(e);
+    },
+    fireUpdateCancelled() {
+      updateCancelled?.();
+    },
+    fireUpdateStaging() {
+      updateStaging?.();
+    },
+    fireUpdateVerified() {
+      updateVerified?.();
+    },
+    fireUpdateRolledBack() {
+      updateRolledBack?.();
+    },
+  };
+}
+
+afterEach(() => setUpdaterBackend(null));
+
+describe('attachAppUpdater', () => {
+  it('is idempotent — re-attach tears down the prior subscription first', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    const updater = createAppUpdater();
+    let checking = 0;
+    connectSignal(updater.onChecking, () => checking++);
+    attachAppUpdater(updater);
+    attachAppUpdater(updater); // second attach
+    backend.fireChecking();
+    // Only one subscription should be active, so checking fires once
+    expect(checking).toBe(1);
+  });
+
+  it('is safe when not previously attached', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    const updater = createAppUpdater();
+    expect(() => attachAppUpdater(updater)).not.toThrow();
+  });
+
+  it('wires all ten signals and updates state for each', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    const updater = createAppUpdater();
+    let checking = 0;
+    let notAvailable = 0;
+    let availableInfo: Readonly<UpdateInfo> | null = null;
+    let downloadedInfo: Readonly<UpdateInfo> | null = null;
+    let progress: Readonly<UpdateProgress> | null = null;
+    let receivedError: Readonly<UpdaterError> | null = null;
+    let cancelled = 0;
+    let staging = 0;
+    let verified = 0;
+    let rolledBack = 0;
+
+    connectSignal(updater.onChecking, () => checking++);
+    connectSignal(updater.onUpdateNotAvailable, () => notAvailable++);
+    connectSignal(updater.onUpdateAvailable, (info) => (availableInfo = info));
+    connectSignal(updater.onDownloadProgress, (p) => (progress = p));
+    connectSignal(updater.onUpdateDownloaded, (info) => (downloadedInfo = info));
+    connectSignal(updater.onError, (e) => (receivedError = e));
+    connectSignal(updater.onUpdateCancelled, () => cancelled++);
+    connectSignal(updater.onUpdateStaging, () => staging++);
+    connectSignal(updater.onUpdateVerified, () => verified++);
+    connectSignal(updater.onUpdateRolledBack, () => rolledBack++);
+    attachAppUpdater(updater);
+
+    const prog: UpdateProgress = {
+      bytesPerSecond: 1000,
+      isDelta: false,
+      percent: 42,
+      totalBytes: 100,
+      transferredBytes: 42,
+    };
+    const err: UpdaterError = { kind: 'Network', message: 'timeout' };
+    backend.fireChecking();
+    backend.fireUpdateAvailable(FULL_UPDATE_INFO);
+    backend.fireUpdateNotAvailable();
+    backend.fireDownloadProgress(prog);
+    backend.fireUpdateDownloaded(FULL_UPDATE_INFO);
+    backend.fireError(err);
+    backend.fireUpdateCancelled();
+    backend.fireUpdateStaging();
+    backend.fireUpdateVerified();
+    backend.fireUpdateRolledBack();
+
+    expect(checking).toBe(1);
+    expect(notAvailable).toBe(1);
+    expect(availableInfo).toEqual(FULL_UPDATE_INFO);
+    expect(downloadedInfo).toEqual(FULL_UPDATE_INFO);
+    expect(progress).toEqual(prog);
+    expect(receivedError).toEqual(err);
+    expect(cancelled).toBe(1);
+    expect(staging).toBe(1);
+    expect(verified).toBe(1);
+    expect(rolledBack).toBe(1);
+  });
+
+  it('updates state machine phases in order', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    const updater = createAppUpdater();
+    attachAppUpdater(updater);
+
+    expect(getAppUpdaterState(updater).phase).toBe('Idle');
+
+    backend.fireChecking();
+    expect(getAppUpdaterState(updater).phase).toBe('Checking');
+
+    backend.fireUpdateAvailable(FULL_UPDATE_INFO);
+    expect(getAppUpdaterState(updater).phase).toBe('UpdateAvailable');
+    expect(getAppUpdaterState(updater).info).toEqual(FULL_UPDATE_INFO);
+
+    const prog: UpdateProgress = {
+      bytesPerSecond: 500,
+      isDelta: false,
+      percent: 50,
+      totalBytes: 200,
+      transferredBytes: 100,
+    };
+    backend.fireDownloadProgress(prog);
+    expect(getAppUpdaterState(updater).phase).toBe('Downloading');
+    expect(getAppUpdaterState(updater).progress).toEqual(prog);
+
+    backend.fireUpdateDownloaded(FULL_UPDATE_INFO);
+    expect(getAppUpdaterState(updater).phase).toBe('Downloaded');
+
+    backend.fireUpdateStaging();
+    expect(getAppUpdaterState(updater).phase).toBe('Staging');
+  });
+
+  it('transitions to Error phase when backend fires error', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    const updater = createAppUpdater();
+    attachAppUpdater(updater);
+
+    const err: UpdaterError = { kind: 'Signature', message: 'bad sig' };
+    backend.fireError(err);
+    expect(getAppUpdaterState(updater).phase).toBe('Error');
+    expect(getAppUpdaterState(updater).error).toEqual(err);
+  });
+
+  it('resets to Idle on cancel and rollback', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    const updater = createAppUpdater();
+    attachAppUpdater(updater);
+
+    backend.fireChecking();
+    backend.fireUpdateCancelled();
+    expect(getAppUpdaterState(updater).phase).toBe('Idle');
+
+    backend.fireChecking();
+    backend.fireUpdateRolledBack();
+    expect(getAppUpdaterState(updater).phase).toBe('Idle');
+    expect(getAppUpdaterState(updater).info).toBeNull();
+  });
+});
+
+describe('cancelAppUpdateDownload', () => {
+  it('delegates to the active backend', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    cancelAppUpdateDownload();
+    expect(backend.cancelled).toBe(1);
+  });
+});
+
+describe('checkAndDownloadAppUpdate', () => {
+  it('calls checkForUpdates; also calls downloadUpdate when autoDownload is true', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    backend.setConfig({ allowPrerelease: false, autoDownload: true, autoInstallOnAppQuit: false });
+    checkAndDownloadAppUpdate();
+    expect(backend.checked).toBe(1);
+    expect(backend.downloaded).toBe(1);
+  });
+
+  it('only checks when autoDownload is false', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    backend.setConfig({ allowPrerelease: false, autoDownload: false, autoInstallOnAppQuit: false });
+    checkAndDownloadAppUpdate();
+    expect(backend.checked).toBe(1);
+    expect(backend.downloaded).toBe(0);
+  });
+
+  it('downloads immediately under autoDownload without gating on update-available', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    backend.setConfig({ allowPrerelease: false, autoDownload: true, autoInstallOnAppQuit: false });
+    checkAndDownloadAppUpdate();
+    // The download fires in the same call as the check; it does not wait for fireUpdateAvailable.
+    // This pins the documented fire-both convenience for instant-trigger backends.
+    expect(backend.downloaded).toBe(1);
+  });
+});
+
+describe('checkForAppUpdate', () => {
+  it('delegates to the active backend', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    checkForAppUpdate();
+    expect(backend.checked).toBe(1);
+  });
+});
+
+describe('createAppUpdater', () => {
+  it('creates an entity with all ten signals', () => {
+    const updater = createAppUpdater();
+    expect(updater.onChecking).toBeDefined();
+    expect(updater.onUpdateAvailable).toBeDefined();
+    expect(updater.onUpdateNotAvailable).toBeDefined();
+    expect(updater.onDownloadProgress).toBeDefined();
+    expect(updater.onUpdateDownloaded).toBeDefined();
+    expect(updater.onError).toBeDefined();
+    expect(updater.onUpdateCancelled).toBeDefined();
+    expect(updater.onUpdateStaging).toBeDefined();
+    expect(updater.onUpdateVerified).toBeDefined();
+    expect(updater.onUpdateRolledBack).toBeDefined();
+  });
+
+  it('starts in Idle phase with all payloads null', () => {
+    const updater = createAppUpdater();
+    const state = getAppUpdaterState(updater);
+    expect(state.phase).toBe('Idle');
+    expect(state.info).toBeNull();
+    expect(state.progress).toBeNull();
+    expect(state.error).toBeNull();
+  });
+});
+
+describe('createUpdaterConfig', () => {
+  it('returns safe defaults', () => {
+    const config = createUpdaterConfig();
+    expect(config.autoDownload).toBe(false);
+    expect(config.autoInstallOnAppQuit).toBe(false);
+    expect(config.allowPrerelease).toBe(false);
+  });
+});
+
+describe('createUpdaterState', () => {
+  it('returns Idle phase with null payloads', () => {
+    const state = createUpdaterState();
+    expect(state.phase).toBe('Idle');
+    expect(state.info).toBeNull();
+    expect(state.progress).toBeNull();
+    expect(state.error).toBeNull();
+  });
+});
+
+describe('createWebUpdaterBackend', () => {
+  it('no-ops commands and returns inert unsubscribes without throwing', () => {
+    const backend = createWebUpdaterBackend();
+    expect(() => {
+      backend.setFeedUrl('https://example.com/feed');
+      backend.checkForUpdates();
+      backend.downloadUpdate();
+      backend.cancelDownload();
+      backend.quitAndInstall();
+      backend.rollback();
+      backend.setSignatureConfig(null);
+      backend.setSignatureConfig({ algorithm: 'ed25519', publicKey: 'abc' });
+    }).not.toThrow();
+    expect(typeof backend.subscribeChecking(() => {})).toBe('function');
+    expect(typeof backend.subscribeError(() => {})).toBe('function');
+    expect(typeof backend.subscribeUpdateCancelled(() => {})).toBe('function');
+    expect(typeof backend.subscribeUpdateStaging(() => {})).toBe('function');
+    expect(typeof backend.subscribeUpdateVerified(() => {})).toBe('function');
+    expect(typeof backend.subscribeUpdateRolledBack(() => {})).toBe('function');
+  });
+
+  it('stores and returns channel', () => {
+    const backend = createWebUpdaterBackend();
+    expect(backend.getChannel()).toBe('stable');
+    backend.setChannel('beta');
+    expect(backend.getChannel()).toBe('beta');
+  });
+
+  it('stores and returns config', () => {
+    const backend = createWebUpdaterBackend();
+    const config = createUpdaterConfig();
+    expect(backend.getConfig()).toEqual(config);
+    backend.setConfig({ ...config, autoDownload: true });
+    expect(backend.getConfig().autoDownload).toBe(true);
+  });
+
+  it('returns idle state for every query', () => {
+    const backend = createWebUpdaterBackend();
+    expect(backend.getChannel()).toBe('stable');
+    const config = backend.getConfig();
+    expect(config.autoDownload).toBe(false);
+    expect(config.autoInstallOnAppQuit).toBe(false);
+    expect(config.allowPrerelease).toBe(false);
+  });
+});
+
+describe('detachAppUpdater', () => {
+  it('stops further delivery', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    const updater = createAppUpdater();
+    let checking = 0;
+    connectSignal(updater.onChecking, () => checking++);
+    attachAppUpdater(updater);
+    detachAppUpdater(updater);
+    backend.fireChecking();
+    expect(checking).toBe(0);
+  });
+
+  it('is safe when not attached', () => {
+    const updater = createAppUpdater();
+    expect(() => detachAppUpdater(updater)).not.toThrow();
+  });
+});
+
+describe('disposeAppUpdater', () => {
+  it('detaches the subscription', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    const updater = createAppUpdater();
+    attachAppUpdater(updater);
+    expect(() => disposeAppUpdater(updater)).not.toThrow();
+  });
+});
+
+describe('downloadAppUpdate', () => {
+  it('delegates to the active backend', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    downloadAppUpdate();
+    expect(backend.downloaded).toBe(1);
+  });
+});
+
+describe('getAppUpdaterState', () => {
+  it('returns Idle state for an updater that has never been attached', () => {
+    const updater = createAppUpdater();
+    const state = getAppUpdaterState(updater);
+    expect(state.phase).toBe('Idle');
+  });
+
+  it('is per-entity — two updaters have independent states', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    const a = createAppUpdater();
+    const b = createAppUpdater();
+    attachAppUpdater(a);
+    backend.fireChecking();
+    expect(getAppUpdaterState(a).phase).toBe('Checking');
+    expect(getAppUpdaterState(b).phase).toBe('Idle');
+  });
+});
+
+describe('getUpdaterBackend', () => {
+  it('falls back to a web backend', () => {
+    expect(getUpdaterBackend()).not.toBeNull();
+  });
+});
+
+describe('getUpdaterChannel', () => {
+  it('returns the channel from the active backend', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    backend.setChannel('beta');
+    expect(getUpdaterChannel()).toBe('beta');
+  });
+});
+
+describe('getUpdaterConfig', () => {
+  it('returns the config from the active backend', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    expect(getUpdaterConfig().autoDownload).toBe(false);
+  });
+});
+
+describe('isAppUpdateEligible', () => {
+  it('returns true when seed falls within stagedRolloutPercent', () => {
+    const info: Readonly<UpdateInfo> = { ...FULL_UPDATE_INFO, stagedRolloutPercent: 50 };
+    expect(isAppUpdateEligible(info, 0.4)).toBe(true); // 0.4 * 100 = 40 < 50
+  });
+
+  it('returns false when seed is at or above stagedRolloutPercent', () => {
+    const info: Readonly<UpdateInfo> = { ...FULL_UPDATE_INFO, stagedRolloutPercent: 50 };
+    expect(isAppUpdateEligible(info, 0.5)).toBe(false); // 0.5 * 100 = 50, not < 50
+    expect(isAppUpdateEligible(info, 0.9)).toBe(false);
+  });
+
+  it('always eligible when stagedRolloutPercent is 100', () => {
+    const info: Readonly<UpdateInfo> = { ...FULL_UPDATE_INFO, stagedRolloutPercent: 100 };
+    expect(isAppUpdateEligible(info, 0.99)).toBe(true);
+  });
+
+  it('never eligible when stagedRolloutPercent is 0', () => {
+    const info: Readonly<UpdateInfo> = { ...FULL_UPDATE_INFO, stagedRolloutPercent: 0 };
+    expect(isAppUpdateEligible(info, 0)).toBe(false);
+  });
+});
+
+describe('quitAndInstallUpdate', () => {
+  it('delegates to the active backend', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    quitAndInstallUpdate();
+    expect(backend.quit).toBe(1);
+  });
+});
+
+describe('rollbackAppUpdate', () => {
+  it('delegates to the active backend', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    rollbackAppUpdate();
+    expect(backend.rolledBack).toBe(1);
+  });
+});
+
+describe('setUpdaterBackend', () => {
+  it('clears back to the web fallback when passed null', () => {
+    setUpdaterBackend(fakeBackend());
+    setUpdaterBackend(null);
+    expect(getUpdaterBackend()).not.toBeNull();
+  });
+});
+
+describe('setUpdaterChannel', () => {
+  it('sets the channel on the active backend', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    setUpdaterChannel('alpha');
+    expect(backend.getChannel()).toBe('alpha');
+  });
+});
+
+describe('setUpdaterConfig', () => {
+  it('forwards the config to the active backend', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    setUpdaterConfig({ allowPrerelease: true, autoDownload: true, autoInstallOnAppQuit: true });
+    const config = backend.getConfig();
+    expect(config.allowPrerelease).toBe(true);
+    expect(config.autoDownload).toBe(true);
+    expect(config.autoInstallOnAppQuit).toBe(true);
+  });
+});
+
+describe('setUpdaterFeedUrl', () => {
+  it('forwards the URL to the active backend', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    setUpdaterFeedUrl('https://example.com/feed');
+    expect(backend.feedUrl).toBe('https://example.com/feed');
+  });
+});
+
+describe('setUpdaterSignatureConfig', () => {
+  it('forwards the config to the active backend without throwing', () => {
+    const backend = fakeBackend();
+    setUpdaterBackend(backend);
+    expect(() => setUpdaterSignatureConfig({ algorithm: 'ed25519', publicKey: 'pubkey' })).not.toThrow();
+    expect(() => setUpdaterSignatureConfig(null)).not.toThrow();
+  });
+});