From 2fc3cdf331cf913c4ab8c729cb8ad80c3daafae8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Elberte=20Pl=C3=ADnio?= <elberte.dev@gmail.com>
Date: Thu, 23 Jul 2026 17:25:09 -0300
Subject: [PATCH 1/4] feat(update): integrate shared studio update dialog
 behind flag

Mount @pickforge/tauri-updater's shared controller and dialog element on
PickGauge's main window when studioUpdateDialog is on (default off via
@pickforge/flags); the legacy window.confirm flow in updater.ts is
untouched while the flag is off. Eligibility excludes the floating
capsule by Tauri window label and defers a hidden main window until its
first focus event, preserving the existing checkForUpdatesWhenVisible
deferral. Adds a dev-only ?updateDialogFixture= route for the available
and downloading states, tree-shaken from production builds, since
PickGauge has no visual-regression baseline harness.

Refs pickforge/pickforge-platform#36
---
 bun.lock                       |   6 ++
 docs/releases/UNRELEASED.md    |  21 +++++
 package.json                   |   2 +
 src/App.svelte                 |  12 +++
 src/lib/flags.test.ts          |  16 ++++
 src/lib/flags.ts               |  25 ++++++
 src/lib/updateDialog.test.ts   | 139 +++++++++++++++++++++++++++++++++
 src/lib/updateDialog.ts        | 137 ++++++++++++++++++++++++++++++++
 src/lib/updateDialogFixture.ts |  75 ++++++++++++++++++
 src/main.ts                    |  65 ++++++++++-----
 10 files changed, 479 insertions(+), 19 deletions(-)
 create mode 100644 src/lib/flags.test.ts
 create mode 100644 src/lib/flags.ts
 create mode 100644 src/lib/updateDialog.test.ts
 create mode 100644 src/lib/updateDialog.ts
 create mode 100644 src/lib/updateDialogFixture.ts

diff --git a/bun.lock b/bun.lock
index e2c707e..8dd965b 100644
--- a/bun.lock
+++ b/bun.lock
@@ -6,6 +6,8 @@
       "name": "pickgauge",
       "dependencies": {
         "@pickforge/brand": "0.2.1",
+        "@pickforge/flags": "^0.4.0",
+        "@pickforge/tauri-updater": "^0.12.0",
         "@tauri-apps/api": "^2.9.0",
         "@tauri-apps/plugin-process": "^2.3.1",
         "@tauri-apps/plugin-updater": "^2.10.1",
@@ -138,8 +140,12 @@
 
     "@pickforge/brand": ["@pickforge/brand@0.2.1", "", { "dependencies": { "@fontsource/geist-mono": "^5.2.8", "@fontsource/geist-sans": "^5.2.5" } }, "sha512-8VASbOUFJKUkb2zVvqto7aPynyICISCMzrh8jMRcvovtKNpzbLMrZ2xS7eeIPQyVs5NRbJ0457Vb0HQC+sIhQQ=="],
 
+    "@pickforge/flags": ["@pickforge/flags@0.4.0", "", {}, "sha512-Z0nlxk3/0HXA7em8+ZQ+BV3jfF2U0E8uCdDPdyW2WdbMHe2pF7rgukTAIAyAZexEB3c7SATEYCbrnNsEd9V9Nw=="],
+
     "@pickforge/tauri-release": ["@pickforge/tauri-release@0.3.0", "", { "bin": { "pickforge-tauri-release": "dist/cli.js" } }, "sha512-LTpsp6+zB9WU9eflvWH8tRFGNCJmiQW7ULYNnffQYCgfZ3fSqF33yDBKW38WdXdlyDBEcYpFnYjkw0+YnLob8Q=="],
 
+    "@pickforge/tauri-updater": ["@pickforge/tauri-updater@0.12.0", "", {}, "sha512-3q5SgSAJBV/ctpxFGKUvKOHZ6uIszhgO3BPajgA+BrffulARzrW9Uv4fXRy4TFWoV83LNlSy9GVnCi6dYWnJBw=="],
+
     "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.61.0", "", { "os": "android", "cpu": "arm" }, "sha512-dnxczajOqt0gesZlN5pGQ1s1imQVrsmCw5G2Ci4oM+0WvNz3pyRnlWrT7McoZIb8VlFwCawdmbWRmxRn7HI+VQ=="],
 
     "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.61.0", "", { "os": "android", "cpu": "arm64" }, "sha512-Bp3JpGP00Vu3f238ivRrjf7z3xSzVPXqCmaJYA9t2c+c8vKYvOzmXF7LkkeUalTEGd6cZcSWe+PFIP3Vy48fRg=="],
diff --git a/docs/releases/UNRELEASED.md b/docs/releases/UNRELEASED.md
index 8f95aea..f9c7210 100644
--- a/docs/releases/UNRELEASED.md
+++ b/docs/releases/UNRELEASED.md
@@ -52,6 +52,17 @@ reset this file.
 
 ## Internal/release changes
 
+- Added the shared `@pickforge/tauri-updater` dialog behind the `studioUpdateDialog`
+  flag (default off; `@pickforge/flags`), part of
+  pickforge/pickforge-platform#36. While off, the legacy `window.confirm`
+  updater in `src/lib/updater.ts` is untouched. When on, `src/lib/updateDialog.ts`
+  mounts the shared controller only on the visible main window: a Tauri
+  window-label check excludes the floating capsule outright, and a hidden
+  main window (tray/login-start) defers the check until its first focus
+  event, mirroring the pre-existing `checkForUpdatesWhenVisible` deferral.
+  One controller per process enforces a single check. A dev-only fixture
+  (`?updateDialogFixture=available|downloading`, tree-shaken from production
+  builds) stands in for a visual baseline since PickGauge has no VRT harness.
 - Headless `usage --json` refreshes independent providers concurrently
   (join-all, emit in fixed service order) so an offline credentialed install
   pays ~max per-provider timeout instead of the sequential sum.
@@ -152,8 +163,18 @@ reset this file.
   candidate by several days. The validated candidate remains installed with a
   checksum-verified rollback backup.
 
+- pickforge/pickforge-platform#36 (PR 5, PickGauge integration): `bun run
+  lint`, `bun run check`, `bun run test` (85 vitest tests including
+  `flags.test.ts` and `updateDialog.test.ts`, covering flag-off default,
+  eligibility for an already-visible main window, capsule exclusion by
+  window label, and hidden-main-window deferral until focus), and `bun run
+  test:coverage` (ratchet holds). No Rust touched.
+
 ### Not yet tested
 
+- pickforge/pickforge-platform#36 (PR 5): owner-gated packaged-update smoke
+  (old build to staged newer build) and design-lead visual acceptance from
+  the dev-only fixture; both deferred to a later PR per the issue's PR plan.
 - Issue #49: real KDE Wayland/XWayland Alt+Tab, taskbar, and pager behavior
   for the float capsule — deferred to Elberte-PC, a live KDE session with
   `qdbus`/`kwriteconfig6` available.
diff --git a/package.json b/package.json
index 17520e5..35f7aa7 100644
--- a/package.json
+++ b/package.json
@@ -28,6 +28,8 @@
   },
   "dependencies": {
     "@pickforge/brand": "0.2.1",
+    "@pickforge/flags": "^0.4.0",
+    "@pickforge/tauri-updater": "^0.12.0",
     "@tauri-apps/api": "^2.9.0",
     "@tauri-apps/plugin-process": "^2.3.1",
     "@tauri-apps/plugin-updater": "^2.10.1",
diff --git a/src/App.svelte b/src/App.svelte
index 5c46482..0016da3 100644
--- a/src/App.svelte
+++ b/src/App.svelte
@@ -18,6 +18,8 @@
     EVENT_SNAPSHOTS,
   } from "./lib/api";
   import { serviceLabels, settingsSaveDisplayState } from "./lib/display";
+  import { flagEnabled } from "./lib/flags";
+  import { mountUpdateDialog, type UpdateDialogHost } from "./lib/updateDialog";
   import {
     browserPreviewSnapshots,
     browserPreviewStateFromSearch,
@@ -47,6 +49,8 @@
   let statusMessage = $state<string | null>(null);
   let statusIsError = $state(false);
   let statusTimer: ReturnType<typeof setTimeout> | null = null;
+  let updateDialogEl: HTMLElement | undefined = $state();
+  const showUpdateDialog = flagEnabled("studioUpdateDialog");
 
   const navItems: { id: View; label: string; icon: typeof Gauge }[] = [
     { id: "dashboard", label: "Dashboard", icon: Gauge },
@@ -102,6 +106,10 @@
     let cancelled = false;
     const cleanups: (() => void)[] = [];
 
+    if (showUpdateDialog && updateDialogEl) {
+      mountUpdateDialog(updateDialogEl as unknown as UpdateDialogHost);
+    }
+
     if (!desktopApiAvailable()) {
       snapshots = browserPreviewSnapshots(browserPreviewStateFromSearch(window.location.search));
       loading = false;
@@ -288,6 +296,10 @@
   </div>
 {/if}
 
+{#if showUpdateDialog}
+  <pickforge-update-dialog bind:this={updateDialogEl}></pickforge-update-dialog>
+{/if}
+
 <style>
   .app {
     display: flex;
diff --git a/src/lib/flags.test.ts b/src/lib/flags.test.ts
new file mode 100644
index 0000000..869f66d
--- /dev/null
+++ b/src/lib/flags.test.ts
@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { flagEnabled, setFlagOverride } from "./flags";
+
+describe("studioUpdateDialog flag", () => {
+  it("defaults to off", () => {
+    expect(flagEnabled("studioUpdateDialog")).toBe(false);
+  });
+
+  it("can be flipped on for the current process via an override", () => {
+    setFlagOverride("studioUpdateDialog", true);
+    expect(flagEnabled("studioUpdateDialog")).toBe(true);
+
+    setFlagOverride("studioUpdateDialog", undefined);
+    expect(flagEnabled("studioUpdateDialog")).toBe(false);
+  });
+});
diff --git a/src/lib/flags.ts b/src/lib/flags.ts
new file mode 100644
index 0000000..6f97521
--- /dev/null
+++ b/src/lib/flags.ts
@@ -0,0 +1,25 @@
+// Feature-flag registry (@pickforge/flags). Mirrors the shape PickForge's
+// src/stores/flags.ts uses for the same package: definitions default off
+// unless `default: true` is set, and a launch flip means changing the
+// definition and releasing. PickGauge has no flag-override UI yet, so this
+// uses the package's default in-memory store — an override only lives for
+// the current process, which is enough for manual dev testing.
+import { createFlags } from "@pickforge/flags";
+
+const definitions = {
+  studioUpdateDialog: {
+    description: "Shared Pickforge update dialog (pickforge/pickforge-platform#36)",
+  },
+} as const;
+
+export type FlagKey = keyof typeof definitions;
+
+const flags = createFlags(definitions);
+
+export function flagEnabled(key: FlagKey): boolean {
+  return flags.isEnabled(key);
+}
+
+export function setFlagOverride(key: FlagKey, value: boolean | undefined): void {
+  flags.setOverride(key, value);
+}
diff --git a/src/lib/updateDialog.test.ts b/src/lib/updateDialog.test.ts
new file mode 100644
index 0000000..0e0d977
--- /dev/null
+++ b/src/lib/updateDialog.test.ts
@@ -0,0 +1,139 @@
+import { createUpdateController, type UpdateAdapter } from "@pickforge/tauri-updater";
+import { describe, expect, it, vi } from "vitest";
+import {
+  createMainWindowEligibility,
+  MAIN_WINDOW_LABEL,
+  type EligibilityWindow,
+} from "./updateDialog";
+
+function fakeWindow(overrides: Partial<EligibilityWindow> & { label: string }): EligibilityWindow {
+  return {
+    isVisible: vi.fn(async () => false),
+    onFocusChanged: vi.fn(async () => () => {}),
+    ...overrides,
+  };
+}
+
+function fakeAdapter(): UpdateAdapter {
+  return {
+    check: vi.fn(async () => ({ version: "1.2.3" })),
+    downloadAndInstall: vi.fn(async () => {}),
+    relaunch: vi.fn(async () => {}),
+  };
+}
+
+describe("createMainWindowEligibility", () => {
+  it("never becomes eligible for the floating capsule window", async () => {
+    const win = fakeWindow({ label: "float", isVisible: vi.fn(async () => true) });
+    const eligibility = createMainWindowEligibility(win, true);
+
+    await expect(eligibility.whenEligible()).resolves.toBe(false);
+    expect(win.isVisible).not.toHaveBeenCalled();
+    expect(win.onFocusChanged).not.toHaveBeenCalled();
+  });
+
+  it("never becomes eligible outside a packaged build", async () => {
+    const win = fakeWindow({ label: MAIN_WINDOW_LABEL, isVisible: vi.fn(async () => true) });
+    const eligibility = createMainWindowEligibility(win, false);
+
+    await expect(eligibility.whenEligible()).resolves.toBe(false);
+    expect(win.isVisible).not.toHaveBeenCalled();
+  });
+
+  it("resolves immediately for an already-visible main window", async () => {
+    const win = fakeWindow({ label: MAIN_WINDOW_LABEL, isVisible: vi.fn(async () => true) });
+    const eligibility = createMainWindowEligibility(win, true);
+
+    await expect(eligibility.whenEligible()).resolves.toBe(true);
+    expect(win.onFocusChanged).not.toHaveBeenCalled();
+  });
+
+  it("defers a hidden main window until it gains focus, then unlistens", async () => {
+    let handler: ((event: { payload: boolean }) => void) | undefined;
+    const unlisten = vi.fn();
+    const win = fakeWindow({
+      label: MAIN_WINDOW_LABEL,
+      isVisible: vi.fn(async () => false),
+      onFocusChanged: vi.fn(async (h) => {
+        handler = h;
+        return unlisten;
+      }),
+    });
+    const eligibility = createMainWindowEligibility(win, true);
+    const pending = eligibility.whenEligible();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    // A blur (or other unfocus) event before the window is shown must not
+    // resolve the prompt.
+    handler?.({ payload: false });
+    await Promise.resolve();
+
+    handler?.({ payload: true });
+    await expect(pending).resolves.toBe(true);
+    expect(unlisten).toHaveBeenCalledOnce();
+
+    // A later, redundant focus event is ignored (single-flight).
+    handler?.({ payload: true });
+    expect(unlisten).toHaveBeenCalledOnce();
+  });
+
+  it("never resolves for a hidden main window that stays unfocused", async () => {
+    const win = fakeWindow({
+      label: MAIN_WINDOW_LABEL,
+      isVisible: vi.fn(async () => false),
+    });
+    const eligibility = createMainWindowEligibility(win, true);
+    let resolved = false;
+    void eligibility.whenEligible().then(() => {
+      resolved = true;
+    });
+
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(resolved).toBe(false);
+  });
+});
+
+describe("capsule and hidden-window exclusion through the shared controller", () => {
+  it("never checks for updates when mounted for the floating capsule window", async () => {
+    const adapter = fakeAdapter();
+    const win = fakeWindow({ label: "float" });
+    const controller = createUpdateController({
+      adapter,
+      eligibility: createMainWindowEligibility(win, true),
+    });
+
+    await controller.start();
+
+    expect(adapter.check).not.toHaveBeenCalled();
+    expect(controller.getState()).toEqual({ status: "idle" });
+  });
+
+  it("defers the update check for a hidden main window until it is shown", async () => {
+    const adapter = fakeAdapter();
+    let handler: ((event: { payload: boolean }) => void) | undefined;
+    const win = fakeWindow({
+      label: MAIN_WINDOW_LABEL,
+      isVisible: vi.fn(async () => false),
+      onFocusChanged: vi.fn(async (h) => {
+        handler = h;
+        return () => {};
+      }),
+    });
+    const controller = createUpdateController({
+      adapter,
+      eligibility: createMainWindowEligibility(win, true),
+    });
+
+    const started = controller.start();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(adapter.check).not.toHaveBeenCalled();
+
+    handler?.({ payload: true });
+    await started;
+    expect(adapter.check).toHaveBeenCalledOnce();
+  });
+});
diff --git a/src/lib/updateDialog.ts b/src/lib/updateDialog.ts
new file mode 100644
index 0000000..1c82321
--- /dev/null
+++ b/src/lib/updateDialog.ts
@@ -0,0 +1,137 @@
+// Wires the shared @pickforge/tauri-updater controller into PickGauge's
+// main window, behind the `studioUpdateDialog` flag (see ./flags.ts). Only
+// App.svelte (the main-window component) imports this module — Float.svelte
+// (the floating capsule) never does, and `createMainWindowEligibility` below
+// additionally checks the real Tauri window label as a second, independent
+// guard against the capsule or a hidden main window ever surfacing the
+// prompt. This replaces the legacy `window.confirm` flow in ./updater.ts
+// once the flag is on; that file is untouched and keeps working while the
+// flag is off.
+import { getVersion } from "@tauri-apps/api/app";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import {
+  createProcessCheckGate,
+  createTauriUpdaterAdapter,
+  createUpdateController,
+  definePickforgeUpdaterElement,
+  type UpdateAdapter,
+  type UpdateController,
+  type UpdateDialogMetadata,
+  type UpdateEligibility,
+} from "@pickforge/tauri-updater";
+import { desktopApiAvailable } from "./api";
+
+export const MAIN_WINDOW_LABEL = "main";
+
+/** The subset of the Tauri `Window` API eligibility needs, so tests can
+ * inject a fake instead of a real webview window. */
+export interface EligibilityWindow {
+  label: string;
+  isVisible(): Promise<boolean>;
+  onFocusChanged(handler: (event: { payload: boolean }) => void): Promise<() => void>;
+}
+
+/** The DOM surface `mountUpdateDialog` needs from a `<pickforge-update-dialog>`
+ * element, so callers don't have to import the package's element class. */
+export interface UpdateDialogHost {
+  metadata: UpdateDialogMetadata;
+  controller: UpdateController | undefined;
+}
+
+/**
+ * Resolves eligible only for the packaged app's main window once it is
+ * visible. The floating capsule (`label !== "main"`) and a hidden main
+ * window (tray/login-start) never resolve true from here; a hidden main
+ * window waits for its first focus before resolving, exactly mirroring the
+ * pre-existing `checkForUpdatesWhenVisible` deferral in ./updater.ts.
+ */
+export function createMainWindowEligibility(
+  win: EligibilityWindow,
+  packaged: boolean,
+): UpdateEligibility {
+  return {
+    async whenEligible() {
+      if (!packaged || win.label !== MAIN_WINDOW_LABEL) {
+        return false;
+      }
+
+      if (await win.isVisible().catch(() => false)) {
+        return true;
+      }
+
+      return new Promise<boolean>((resolve) => {
+        let started = false;
+        let unlisten: (() => void) | undefined;
+
+        void win
+          .onFocusChanged(({ payload: focused }) => {
+            if (!focused || started) {
+              return;
+            }
+            started = true;
+            unlisten?.();
+            resolve(true);
+          })
+          .then((fn) => {
+            unlisten = fn;
+            if (started) {
+              fn();
+            }
+          });
+      });
+    },
+  };
+}
+
+async function createAdapter(): Promise<UpdateAdapter> {
+  const [{ check }, { relaunch }] = await Promise.all([
+    import("@tauri-apps/plugin-updater"),
+    import("@tauri-apps/plugin-process"),
+  ]);
+  return createTauriUpdaterAdapter({ check, relaunch });
+}
+
+let controllerPromise: Promise<UpdateController> | undefined;
+
+/** One controller for the process; its process-check gate enforces a
+ * single update check per process even if this is somehow called twice. */
+function getUpdateController(packaged: boolean): Promise<UpdateController> {
+  controllerPromise ??= (async () => {
+    const adapter = await createAdapter();
+    const eligibility = createMainWindowEligibility(getCurrentWindow(), packaged);
+    return createUpdateController({ adapter, eligibility, gate: createProcessCheckGate() });
+  })();
+  return controllerPromise;
+}
+
+/**
+ * Mounts the shared update dialog on `host` and starts the single
+ * per-process check. No-ops in dev builds and outside Tauri (browser
+ * preview), matching the legacy flow's packaged-build-only behavior.
+ * Startup check failures are swallowed by the controller (silent,
+ * non-blocking); anything else that goes wrong while wiring up is logged
+ * and otherwise ignored so it can never block app startup.
+ */
+export function mountUpdateDialog(host: UpdateDialogHost): void {
+  const packaged = !import.meta.env.DEV && desktopApiAvailable();
+  if (!packaged) {
+    return;
+  }
+
+  definePickforgeUpdaterElement();
+
+  void (async () => {
+    try {
+      const controller = await getUpdateController(packaged);
+      host.metadata = {
+        productName: "PickGauge",
+        currentVersion: await getVersion().catch(() => "—"),
+        productMark: "PG",
+      };
+      host.controller = controller;
+      await controller.start();
+    } catch (error) {
+      console.error("PickGauge update dialog setup failed", error);
+    }
+  })();
+}
diff --git a/src/lib/updateDialogFixture.ts b/src/lib/updateDialogFixture.ts
new file mode 100644
index 0000000..1cc18e0
--- /dev/null
+++ b/src/lib/updateDialogFixture.ts
@@ -0,0 +1,75 @@
+// Dev-only visual fixture for the shared update dialog. PickGauge has no
+// visual-regression/screenshot-baseline harness (see scripts/
+// validate-browser-preview.mjs — functional Playwright assertions, not
+// pixel baselines), so this route stands in for one: `bun run dev` then
+// open `?updateDialogFixture=available` or `?updateDialogFixture=downloading`
+// to inspect the dialog with deterministic, injected state. Resize the
+// window to PickGauge's normal (1000x700) and minimum (820x580) sizes to
+// check both. Never reachable in a production build — `import.meta.env.DEV`
+// is statically eliminated, so this module and its @pickforge/tauri-updater
+// imports are tree-shaken out entirely.
+import {
+  createEligibility,
+  createProcessCheckGate,
+  createUpdateController,
+  definePickforgeUpdaterElement,
+  type UpdateAdapter,
+  type UpdateDialogMetadata,
+} from "@pickforge/tauri-updater";
+import type { UpdateDialogHost } from "./updateDialog";
+
+const FIXTURE_UPDATE = {
+  version: "0.3.0",
+  notes: "Faster refresh polling\nFixed a tray icon flicker on Linux\nSmaller install size",
+};
+
+function fixtureAdapter(scenario: string): UpdateAdapter {
+  return {
+    async check() {
+      return FIXTURE_UPDATE;
+    },
+    async downloadAndInstall(onEvent) {
+      onEvent({ type: "started", contentLength: 100 });
+      if (scenario !== "downloading") {
+        onEvent({ type: "progress", chunkLength: 100 });
+        onEvent({ type: "finished" });
+        return;
+      }
+      // Report some progress, then hang forever so "downloading" is a
+      // stable, screenshot-able state instead of racing to "restarting".
+      onEvent({ type: "progress", chunkLength: 42 });
+      await new Promise<void>(() => {});
+    },
+    async relaunch() {},
+  };
+}
+
+const FIXTURE_METADATA: UpdateDialogMetadata = {
+  productName: "PickGauge",
+  currentVersion: "0.2.0",
+  productMark: "PG",
+};
+
+export async function mountUpdateDialogFixture(
+  target: HTMLElement,
+  scenario: string,
+): Promise<void> {
+  target.replaceChildren();
+  definePickforgeUpdaterElement();
+  const element = document.createElement("pickforge-update-dialog") as unknown as UpdateDialogHost &
+    HTMLElement;
+  target.append(element);
+
+  const controller = createUpdateController({
+    adapter: fixtureAdapter(scenario),
+    eligibility: createEligibility({ packaged: true, mainWindow: true, visible: true, focused: true }),
+    gate: createProcessCheckGate(),
+  });
+  element.metadata = FIXTURE_METADATA;
+  element.controller = controller;
+  await controller.start();
+
+  if (scenario === "downloading") {
+    void controller.install();
+  }
+}
diff --git a/src/main.ts b/src/main.ts
index a5d5dba..179ddd8 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -3,6 +3,7 @@ import { mount } from "svelte";
 import App from "./App.svelte";
 import Float from "./Float.svelte";
 import { api, desktopApiAvailable, EVENT_SETTINGS } from "./lib/api";
+import { flagEnabled } from "./lib/flags";
 import { initTheme, setTheme, type ThemeSetting } from "./lib/theme";
 import { checkForUpdatesWhenVisible } from "./lib/updater";
 import type { AppConfig } from "./lib/usage";
@@ -14,6 +15,24 @@ if (!target) {
   throw new Error("App root element was not found");
 }
 
+// Dev-only visual fixture for the shared update dialog (see
+// ./lib/updateDialogFixture.ts) — `import.meta.env.DEV` is statically
+// eliminated, so none of this (including the fixture module's
+// @pickforge/tauri-updater imports) reaches a production build.
+const fixtureScenario = import.meta.env.DEV
+  ? new URLSearchParams(window.location.search).get("updateDialogFixture")
+  : null;
+
+let app: ReturnType<typeof mount> | undefined;
+
+if (fixtureScenario) {
+  void import("./lib/updateDialogFixture").then(({ mountUpdateDialogFixture }) =>
+    mountUpdateDialogFixture(target, fixtureScenario),
+  );
+} else {
+  app = mountApp();
+}
+
 function currentWindowLabel() {
   const internals = (
     window as Window & {
@@ -29,27 +48,35 @@ function currentWindowLabel() {
   return new URLSearchParams(window.location.search).get("window") ?? "main";
 }
 
-const windowLabel = currentWindowLabel();
-const component = windowLabel === "float" ? Float : App;
+function mountApp() {
+  const windowLabel = currentWindowLabel();
+  const component = windowLabel === "float" ? Float : App;
 
-if (component === Float) {
-  document.documentElement.classList.add("is-float");
-  document.body.classList.add("float-host");
-}
+  if (component === Float) {
+    document.documentElement.classList.add("is-float");
+    document.body.classList.add("float-host");
+  }
 
-if (desktopApiAvailable()) {
-  api
-    .getAppConfig()
-    .then((config) => initTheme(config.ui.theme as ThemeSetting))
-    .catch(() => initTheme("system"));
-  void listen<AppConfig>(EVENT_SETTINGS, (event) => {
-    void setTheme(event.payload.ui.theme as ThemeSetting);
-  });
-  if (windowLabel === "main") {
-    void checkForUpdatesWhenVisible();
+  if (desktopApiAvailable()) {
+    api
+      .getAppConfig()
+      .then((config) => initTheme(config.ui.theme as ThemeSetting))
+      .catch(() => initTheme("system"));
+    void listen<AppConfig>(EVENT_SETTINGS, (event) => {
+      void setTheme(event.payload.ui.theme as ThemeSetting);
+    });
+    // App.svelte itself mounts the shared update dialog when
+    // `studioUpdateDialog` is on (see its `showUpdateDialog` check); running
+    // the legacy `window.confirm` flow here too would double-prompt, so it
+    // only runs while the flag is off.
+    if (windowLabel === "main" && !flagEnabled("studioUpdateDialog")) {
+      void checkForUpdatesWhenVisible();
+    }
+  } else {
+    initTheme("system");
   }
-} else {
-  initTheme("system");
+
+  return mount(component, { target: target! });
 }
 
-export default mount(component, { target });
+export default app;

From 5648831a0a4c25997b419eeeb73c5c59f88005c1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Elberte=20Pl=C3=ADnio?= <elberte.dev@gmail.com>
Date: Thu, 23 Jul 2026 17:49:50 -0300
Subject: [PATCH 2/4] fix(update): require visible+focused main window for
 eligibility

createMainWindowEligibility resolved eligible on visibility alone and
trusted a focus-changed event's payload without re-checking visibility,
so a hidden main window receiving an early focus event could pass, and a
window that became visible+focused during listener registration could
hang until a later focus event that might not come. Now eligibility
requires both isVisible() and isFocused(), re-queries both on every
focus-changed event instead of trusting the payload, and re-checks once
right after the listener registers to close that gap.

Also extracts the flag-on/flag-off startup routing decision (legacy
window.confirm vs. the shared dialog) out of main.ts/App.svelte into
src/lib/updateRouting.ts so the no-double-prompt guarantee between them
is directly unit tested.

Refs pickforge/pickforge-platform#36
---
 src/App.svelte                |   3 +-
 src/lib/updateDialog.test.ts  | 164 ++++++++++++++++++++++++----------
 src/lib/updateDialog.ts       |  62 +++++++++----
 src/lib/updateRouting.test.ts |  19 ++++
 src/lib/updateRouting.ts      |  19 ++++
 src/main.ts                   |  10 ++-
 6 files changed, 208 insertions(+), 69 deletions(-)
 create mode 100644 src/lib/updateRouting.test.ts
 create mode 100644 src/lib/updateRouting.ts

diff --git a/src/App.svelte b/src/App.svelte
index 0016da3..8844cbe 100644
--- a/src/App.svelte
+++ b/src/App.svelte
@@ -20,6 +20,7 @@
   import { serviceLabels, settingsSaveDisplayState } from "./lib/display";
   import { flagEnabled } from "./lib/flags";
   import { mountUpdateDialog, type UpdateDialogHost } from "./lib/updateDialog";
+  import { shouldMountSharedUpdateDialog } from "./lib/updateRouting";
   import {
     browserPreviewSnapshots,
     browserPreviewStateFromSearch,
@@ -50,7 +51,7 @@
   let statusIsError = $state(false);
   let statusTimer: ReturnType<typeof setTimeout> | null = null;
   let updateDialogEl: HTMLElement | undefined = $state();
-  const showUpdateDialog = flagEnabled("studioUpdateDialog");
+  const showUpdateDialog = shouldMountSharedUpdateDialog(flagEnabled("studioUpdateDialog"));
 
   const navItems: { id: View; label: string; icon: typeof Gauge }[] = [
     { id: "dashboard", label: "Dashboard", icon: Gauge },
diff --git a/src/lib/updateDialog.test.ts b/src/lib/updateDialog.test.ts
index 0e0d977..3f54354 100644
--- a/src/lib/updateDialog.test.ts
+++ b/src/lib/updateDialog.test.ts
@@ -6,12 +6,47 @@ import {
   type EligibilityWindow,
 } from "./updateDialog";
 
-function fakeWindow(overrides: Partial<EligibilityWindow> & { label: string }): EligibilityWindow {
-  return {
-    isVisible: vi.fn(async () => false),
-    onFocusChanged: vi.fn(async () => () => {}),
-    ...overrides,
-  };
+/** Stateful fake so tests can flip visibility/focus and emit focus-changed
+ * events the way a real Tauri window would, instead of a fresh mock per
+ * assertion. */
+class FakeEligibilityWindow implements EligibilityWindow {
+  label: string;
+  visible: boolean;
+  focused: boolean;
+  listeners: ((event: { payload: boolean }) => void)[] = [];
+  /** Fires synchronously inside `onFocusChanged`, before it resolves — lets
+   * tests simulate the window's state changing during listener registration. */
+  onRegister?: () => void;
+
+  constructor(label: string, opts: { visible?: boolean; focused?: boolean } = {}) {
+    this.label = label;
+    this.visible = opts.visible ?? false;
+    this.focused = opts.focused ?? false;
+  }
+
+  isVisible = vi.fn(async () => this.visible);
+  isFocused = vi.fn(async () => this.focused);
+  onFocusChanged = vi.fn(async (listener: (event: { payload: boolean }) => void) => {
+    this.listeners.push(listener);
+    this.onRegister?.();
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== listener);
+    };
+  });
+
+  emitFocus(focused: boolean) {
+    this.focused = focused;
+    for (const listener of this.listeners) {
+      listener({ payload: focused });
+    }
+  }
+}
+
+/** Flushes pending microtasks (the `currentlyEligible()` `Promise.all`
+ * round-trip inside `createMainWindowEligibility` takes a couple of ticks),
+ * more reliably than a fixed number of `await Promise.resolve()` calls. */
+async function flush() {
+  await new Promise((resolve) => setTimeout(resolve, 0));
 }
 
 function fakeAdapter(): UpdateAdapter {
@@ -24,7 +59,7 @@ function fakeAdapter(): UpdateAdapter {
 
 describe("createMainWindowEligibility", () => {
   it("never becomes eligible for the floating capsule window", async () => {
-    const win = fakeWindow({ label: "float", isVisible: vi.fn(async () => true) });
+    const win = new FakeEligibilityWindow("float", { visible: true, focused: true });
     const eligibility = createMainWindowEligibility(win, true);
 
     await expect(eligibility.whenEligible()).resolves.toBe(false);
@@ -33,73 +68,112 @@ describe("createMainWindowEligibility", () => {
   });
 
   it("never becomes eligible outside a packaged build", async () => {
-    const win = fakeWindow({ label: MAIN_WINDOW_LABEL, isVisible: vi.fn(async () => true) });
+    const win = new FakeEligibilityWindow(MAIN_WINDOW_LABEL, { visible: true, focused: true });
     const eligibility = createMainWindowEligibility(win, false);
 
     await expect(eligibility.whenEligible()).resolves.toBe(false);
     expect(win.isVisible).not.toHaveBeenCalled();
   });
 
-  it("resolves immediately for an already-visible main window", async () => {
-    const win = fakeWindow({ label: MAIN_WINDOW_LABEL, isVisible: vi.fn(async () => true) });
+  it("resolves immediately for an already-visible and focused main window", async () => {
+    const win = new FakeEligibilityWindow(MAIN_WINDOW_LABEL, { visible: true, focused: true });
     const eligibility = createMainWindowEligibility(win, true);
 
     await expect(eligibility.whenEligible()).resolves.toBe(true);
     expect(win.onFocusChanged).not.toHaveBeenCalled();
   });
 
-  it("defers a hidden main window until it gains focus, then unlistens", async () => {
-    let handler: ((event: { payload: boolean }) => void) | undefined;
-    const unlisten = vi.fn();
-    const win = fakeWindow({
-      label: MAIN_WINDOW_LABEL,
-      isVisible: vi.fn(async () => false),
-      onFocusChanged: vi.fn(async (h) => {
-        handler = h;
-        return unlisten;
-      }),
+  it("defers a visible-but-unfocused main window until it gains focus", async () => {
+    const win = new FakeEligibilityWindow(MAIN_WINDOW_LABEL, { visible: true, focused: false });
+    const eligibility = createMainWindowEligibility(win, true);
+
+    const pending = eligibility.whenEligible();
+    await flush();
+    expect(win.onFocusChanged).toHaveBeenCalledOnce();
+
+    win.emitFocus(true);
+    await expect(pending).resolves.toBe(true);
+  });
+
+  it("stays ineligible when a focus event fires without the window becoming visible", async () => {
+    const win = new FakeEligibilityWindow(MAIN_WINDOW_LABEL, { visible: false, focused: false });
+    const eligibility = createMainWindowEligibility(win, true);
+
+    const pending = eligibility.whenEligible();
+    await flush();
+
+    // Focused, but still hidden (e.g. a tray/login-start window regaining
+    // OS focus while its main window stays hidden) must not resolve.
+    win.emitFocus(true);
+    await flush();
+    let resolved = false;
+    void pending.then(() => {
+      resolved = true;
     });
+    await flush();
+    expect(resolved).toBe(false);
+
+    // Once it is actually shown and re-focused, it resolves.
+    win.visible = true;
+    win.emitFocus(true);
+    await expect(pending).resolves.toBe(true);
+  });
+
+  it("defers a hidden main window until it is visible and focused, then unlistens", async () => {
+    const win = new FakeEligibilityWindow(MAIN_WINDOW_LABEL, { visible: false, focused: false });
     const eligibility = createMainWindowEligibility(win, true);
     const pending = eligibility.whenEligible();
-    await Promise.resolve();
-    await Promise.resolve();
+    await flush();
 
     // A blur (or other unfocus) event before the window is shown must not
     // resolve the prompt.
-    handler?.({ payload: false });
-    await Promise.resolve();
+    win.emitFocus(false);
+    await flush();
 
-    handler?.({ payload: true });
+    win.visible = true;
+    win.emitFocus(true);
     await expect(pending).resolves.toBe(true);
-    expect(unlisten).toHaveBeenCalledOnce();
+    expect(win.listeners).toHaveLength(0);
 
     // A later, redundant focus event is ignored (single-flight).
-    handler?.({ payload: true });
-    expect(unlisten).toHaveBeenCalledOnce();
+    const callsBefore = win.onFocusChanged.mock.calls.length;
+    win.emitFocus(true);
+    expect(win.onFocusChanged.mock.calls.length).toBe(callsBefore);
   });
 
   it("never resolves for a hidden main window that stays unfocused", async () => {
-    const win = fakeWindow({
-      label: MAIN_WINDOW_LABEL,
-      isVisible: vi.fn(async () => false),
-    });
+    const win = new FakeEligibilityWindow(MAIN_WINDOW_LABEL, { visible: false, focused: false });
     const eligibility = createMainWindowEligibility(win, true);
     let resolved = false;
     void eligibility.whenEligible().then(() => {
       resolved = true;
     });
 
-    await Promise.resolve();
-    await Promise.resolve();
-    await Promise.resolve();
+    await flush();
     expect(resolved).toBe(false);
   });
+
+  it("does not miss eligibility reached while the focus listener registers", async () => {
+    // The window becomes visible and focused synchronously as a side effect
+    // of registering the listener (simulating a real focus/show event
+    // landing in the gap between the initial check and the listener being
+    // wired up) — whenEligible() must still resolve without waiting for a
+    // subsequent focus event that will never come.
+    const win = new FakeEligibilityWindow(MAIN_WINDOW_LABEL, { visible: false, focused: false });
+    win.onRegister = () => {
+      win.visible = true;
+      win.focused = true;
+    };
+    const eligibility = createMainWindowEligibility(win, true);
+
+    await expect(eligibility.whenEligible()).resolves.toBe(true);
+  });
 });
 
 describe("capsule and hidden-window exclusion through the shared controller", () => {
   it("never checks for updates when mounted for the floating capsule window", async () => {
     const adapter = fakeAdapter();
-    const win = fakeWindow({ label: "float" });
+    const win = new FakeEligibilityWindow("float", { visible: true, focused: true });
     const controller = createUpdateController({
       adapter,
       eligibility: createMainWindowEligibility(win, true),
@@ -111,28 +185,20 @@ describe("capsule and hidden-window exclusion through the shared controller", ()
     expect(controller.getState()).toEqual({ status: "idle" });
   });
 
-  it("defers the update check for a hidden main window until it is shown", async () => {
+  it("defers the update check for a hidden main window until it is shown and focused", async () => {
     const adapter = fakeAdapter();
-    let handler: ((event: { payload: boolean }) => void) | undefined;
-    const win = fakeWindow({
-      label: MAIN_WINDOW_LABEL,
-      isVisible: vi.fn(async () => false),
-      onFocusChanged: vi.fn(async (h) => {
-        handler = h;
-        return () => {};
-      }),
-    });
+    const win = new FakeEligibilityWindow(MAIN_WINDOW_LABEL, { visible: false, focused: false });
     const controller = createUpdateController({
       adapter,
       eligibility: createMainWindowEligibility(win, true),
     });
 
     const started = controller.start();
-    await Promise.resolve();
-    await Promise.resolve();
+    await flush();
     expect(adapter.check).not.toHaveBeenCalled();
 
-    handler?.({ payload: true });
+    win.visible = true;
+    win.emitFocus(true);
     await started;
     expect(adapter.check).toHaveBeenCalledOnce();
   });
diff --git a/src/lib/updateDialog.ts b/src/lib/updateDialog.ts
index 1c82321..80a21ba 100644
--- a/src/lib/updateDialog.ts
+++ b/src/lib/updateDialog.ts
@@ -28,6 +28,7 @@ export const MAIN_WINDOW_LABEL = "main";
 export interface EligibilityWindow {
   label: string;
   isVisible(): Promise<boolean>;
+  isFocused(): Promise<boolean>;
   onFocusChanged(handler: (event: { payload: boolean }) => void): Promise<() => void>;
 }
 
@@ -39,11 +40,16 @@ export interface UpdateDialogHost {
 }
 
 /**
- * Resolves eligible only for the packaged app's main window once it is
- * visible. The floating capsule (`label !== "main"`) and a hidden main
- * window (tray/login-start) never resolve true from here; a hidden main
- * window waits for its first focus before resolving, exactly mirroring the
- * pre-existing `checkForUpdatesWhenVisible` deferral in ./updater.ts.
+ * Resolves eligible only for the packaged app's main window once it is both
+ * visible AND focused, per the design contract. The floating capsule
+ * (`label !== "main"`) never resolves true from here. A hidden or unfocused
+ * main window (tray/login-start) waits: every focus-changed event re-queries
+ * both `isVisible()` and `isFocused()` rather than trusting the event payload
+ * alone, and once the listener is registered its current state is re-checked
+ * once more so a window that became visible+focused during that registration
+ * gap can't hang forever waiting for a focus event that already happened.
+ * This mirrors the pre-existing `checkForUpdatesWhenVisible` deferral in
+ * ./updater.ts, strengthened with the focus check.
  */
 export function createMainWindowEligibility(
   win: EligibilityWindow,
@@ -55,29 +61,55 @@ export function createMainWindowEligibility(
         return false;
       }
 
-      if (await win.isVisible().catch(() => false)) {
+      const currentlyEligible = async () => {
+        const [visible, focused] = await Promise.all([
+          win.isVisible().catch(() => false),
+          win.isFocused().catch(() => false),
+        ]);
+        return visible && focused;
+      };
+
+      if (await currentlyEligible()) {
         return true;
       }
 
       return new Promise<boolean>((resolve) => {
-        let started = false;
+        let settled = false;
         let unlisten: (() => void) | undefined;
 
+        const finish = (value: boolean) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          unlisten?.();
+          resolve(value);
+        };
+
         void win
           .onFocusChanged(({ payload: focused }) => {
-            if (!focused || started) {
+            if (!focused) {
               return;
             }
-            started = true;
-            unlisten?.();
-            resolve(true);
+            void currentlyEligible().then((eligible) => {
+              if (eligible) {
+                finish(true);
+              }
+            });
           })
           .then((fn) => {
             unlisten = fn;
-            if (started) {
-              fn();
-            }
-          });
+            // The window may have become visible and focused while the
+            // listener was being registered; re-check once so that gap
+            // can't leave whenEligible() hanging past an already-happened
+            // focus.
+            void currentlyEligible().then((eligible) => {
+              if (eligible) {
+                finish(true);
+              }
+            });
+          })
+          .catch(() => finish(false));
       });
     },
   };
diff --git a/src/lib/updateRouting.test.ts b/src/lib/updateRouting.test.ts
new file mode 100644
index 0000000..f040121
--- /dev/null
+++ b/src/lib/updateRouting.test.ts
@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { shouldMountSharedUpdateDialog, shouldRunLegacyUpdateCheck } from "./updateRouting";
+
+describe("update flow routing (no-double-prompt guarantee)", () => {
+  it("runs only the legacy check on the main window while the flag is off", () => {
+    expect(shouldRunLegacyUpdateCheck("main", false)).toBe(true);
+    expect(shouldMountSharedUpdateDialog(false)).toBe(false);
+  });
+
+  it("runs only the shared dialog once the flag is on", () => {
+    expect(shouldRunLegacyUpdateCheck("main", true)).toBe(false);
+    expect(shouldMountSharedUpdateDialog(true)).toBe(true);
+  });
+
+  it("never runs the legacy check outside the main window, flag on or off", () => {
+    expect(shouldRunLegacyUpdateCheck("float", false)).toBe(false);
+    expect(shouldRunLegacyUpdateCheck("float", true)).toBe(false);
+  });
+});
diff --git a/src/lib/updateRouting.ts b/src/lib/updateRouting.ts
new file mode 100644
index 0000000..d003883
--- /dev/null
+++ b/src/lib/updateRouting.ts
@@ -0,0 +1,19 @@
+// Single source of truth for which update flow may run where, so the legacy
+// `window.confirm` updater (./updater.ts, driven from main.ts) and the shared
+// dialog (./updateDialog.ts, mounted from App.svelte) can never both prompt
+// for the same window. Both derive from the same `studioUpdateDialog` flag
+// value (see ./flags.ts) through these two functions instead of duplicating
+// the condition inline in each call site.
+
+/** True only for the main window while the flag is off — the legacy
+ * `checkForUpdatesWhenVisible` flow. */
+export function shouldRunLegacyUpdateCheck(windowLabel: string, studioDialogEnabled: boolean): boolean {
+  return windowLabel === "main" && !studioDialogEnabled;
+}
+
+/** True once the flag is on — App.svelte (the main-window component; the
+ * floating capsule never imports the dialog module at all) mounts the shared
+ * controller only when this is true. */
+export function shouldMountSharedUpdateDialog(studioDialogEnabled: boolean): boolean {
+  return studioDialogEnabled;
+}
diff --git a/src/main.ts b/src/main.ts
index 179ddd8..792aab3 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -6,6 +6,7 @@ import { api, desktopApiAvailable, EVENT_SETTINGS } from "./lib/api";
 import { flagEnabled } from "./lib/flags";
 import { initTheme, setTheme, type ThemeSetting } from "./lib/theme";
 import { checkForUpdatesWhenVisible } from "./lib/updater";
+import { shouldRunLegacyUpdateCheck } from "./lib/updateRouting";
 import type { AppConfig } from "./lib/usage";
 import "./app.css";
 
@@ -66,10 +67,11 @@ function mountApp() {
       void setTheme(event.payload.ui.theme as ThemeSetting);
     });
     // App.svelte itself mounts the shared update dialog when
-    // `studioUpdateDialog` is on (see its `showUpdateDialog` check); running
-    // the legacy `window.confirm` flow here too would double-prompt, so it
-    // only runs while the flag is off.
-    if (windowLabel === "main" && !flagEnabled("studioUpdateDialog")) {
+    // `studioUpdateDialog` is on (see its `showUpdateDialog` check, driven by
+    // the same ./lib/updateRouting predicates); running the legacy
+    // `window.confirm` flow here too would double-prompt, so it only runs
+    // while the flag is off.
+    if (shouldRunLegacyUpdateCheck(windowLabel, flagEnabled("studioUpdateDialog"))) {
       void checkForUpdatesWhenVisible();
     }
   } else {

From 4945412130c1ab3d3a4f820519e8bf9477a8ae9f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Elberte=20Pl=C3=ADnio?= <elberte.dev@gmail.com>
Date: Thu, 23 Jul 2026 17:51:09 -0300
Subject: [PATCH 3/4] docs(agents): record the listener register-gap lesson
 from #70 review

Refs pickforge/pickforge-platform#36
---
 AGENTS.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/AGENTS.md b/AGENTS.md
index 61e2f12..d97a8f6 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -26,6 +26,10 @@ bun).
   without updating README's privacy section.
 - Follow the Pickforge design system: ember `#FF7A1A` accent, Geist/Geist Mono,
   tokens over raw values.
+- Async waits built on event listeners must re-check the awaited condition
+  right after the listener registers (the state can change in the gap) and
+  re-verify every condition on each event instead of trusting the event
+  payload alone — pickgauge#70's eligibility gate shipped both mistakes.
 
 ## Releasing
 

From e17284687af531cb52f627325bff66690c4f7eba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Elberte=20Pl=C3=ADnio?= <elberte.dev@gmail.com>
Date: Thu, 23 Jul 2026 17:52:05 -0300
Subject: [PATCH 4/4] docs(updater): add fixture capture evidence for the
 shared dialog

Refs pickforge/pickforge-platform#36
---
 .../update-dialog-available-1000x700.png        | Bin 0 -> 26367 bytes
 .../update-dialog-available-820x580.png         | Bin 0 -> 27064 bytes
 .../update-dialog-downloading-1000x700.png      | Bin 0 -> 20725 bytes
 .../update-dialog-downloading-820x580.png       | Bin 0 -> 19223 bytes
 4 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 docs/release-evidence/update-dialog-available-1000x700.png
 create mode 100644 docs/release-evidence/update-dialog-available-820x580.png
 create mode 100644 docs/release-evidence/update-dialog-downloading-1000x700.png
 create mode 100644 docs/release-evidence/update-dialog-downloading-820x580.png

diff --git a/docs/release-evidence/update-dialog-available-1000x700.png b/docs/release-evidence/update-dialog-available-1000x700.png
new file mode 100644
index 0000000000000000000000000000000000000000..fa338eafa1db5e73facc16756a1e7cd9eeac6b44
GIT binary patch
literal 26367
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
AegFUf

literal 0
HcmV?d00001

diff --git a/docs/release-evidence/update-dialog-available-820x580.png b/docs/release-evidence/update-dialog-available-820x580.png
new file mode 100644
index 0000000000000000000000000000000000000000..fa43f4e844efe27875341f31eb51ce23b0dbce60
GIT binary patch
literal 27064
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
XW+N=c1Q~L%VxB)!moI+$`on(!e~bBn

literal 0
HcmV?d00001

diff --git a/docs/release-evidence/update-dialog-downloading-1000x700.png b/docs/release-evidence/update-dialog-downloading-1000x700.png
new file mode 100644
index 0000000000000000000000000000000000000000..46366b0945349eab33d7beb126f00a7aeb3b3ee8
GIT binary patch
literal 20725
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

literal 0
HcmV?d00001

diff --git a/docs/release-evidence/update-dialog-downloading-820x580.png b/docs/release-evidence/update-dialog-downloading-820x580.png
new file mode 100644
index 0000000000000000000000000000000000000000..a6193ca3ae0780ba96b41b019c26b8cfddaaef92
GIT binary patch
literal 19223
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
H`MduIzQ^6Q

literal 0
HcmV?d00001