@satinhq/kit 0.1.0-beta.1 → 0.1.0-beta.2

package/NOTICE

@@ -12,7 +12,7 @@ is a separately installed build dependency. Consumer Vite builds emit NOTICE.txt
 and licenses.json from their actual emitted module graph, including runtime peers.
 Development dependencies are not assumed to be bundled.
 
-## Satin 0.1.0-beta.1
+## Satin 0.1.0-beta.2
 
 License: MIT
 Source: https://opensource.org/license/mit

package/dist/acknowledgements/inventory.json

@@ -1,7 +1,7 @@
 [
     {
         "name": "Satin",
-        "version": "0.1.0-beta.1",
+        "version": "0.1.0-beta.2",
         "license": "MIT",
         "source": "https://opensource.org/license/mit",
         "text": "MIT License\n\nCopyright (c) 2026 Satin contributors\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n",

package/dist/app/deployment.js

@@ -57,7 +57,7 @@ export async function checkDeployment(expected, pageUrl, fetcher = fetch, includ
         fail('HTTPS is required for installation and service workers.', page.href, false, 'Serve the app over trusted HTTPS.');
         return failures;
     }
-    const request = async (path, kind, allowDirectoryCanonicalization = false) => {
+    const request = async (path, kind, allowDirectoryCanonicalization = false, attempt = 0) => {
         const url = new URL(path, page).href;
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), requestTimeoutMs);
@@ -68,7 +68,7 @@ export async function checkDeployment(expected, pageUrl, fetcher = fetch, includ
                 cache: 'no-store',
                 redirect: path === expected.scope + 'sw.js' ? 'manual' : 'follow',
             });
-            definite = true;
+            definite = response.status < 500 && response.status !== 408 && response.status !== 429;
             if (response.status !== 200)
                 throw new Error(`HTTP ${response.status}`);
             const finalUrl = new URL(response.url || url);
@@ -119,6 +119,12 @@ export async function checkDeployment(expected, pageUrl, fetcher = fetch, includ
         }
         catch (error) {
             const reason = error instanceof Error ? error.message : String(error);
+            // Retry transport failures only. A mismatched deployment cannot heal with backoff.
+            if ((!definite || controller.signal.aborted) && attempt < 2) {
+                clearTimeout(timer);
+                await new Promise(resolve => setTimeout(resolve, 250 * 2 ** attempt));
+                return request(path, kind, allowDirectoryCanonicalization, attempt + 1);
+            }
             if (controller.signal.aborted) {
                 fail(`${label(url)} did not finish within ${requestTimeoutMs / 1000} s`, url, true, 'Check the server or connection, then try again.');
             }

package/dist/app/installCheck.js

@@ -100,7 +100,7 @@ onPass) {
     title.textContent = standalone
         ? 'Wrong Home Screen icon'
         : unverified
-            ? 'Could not verify this app'
+            ? "Can't reach the app right now"
             : 'This app is misconfigured';
     const explanation = document.createElement('p');
     const action = document.createElement('p');
@@ -119,11 +119,12 @@ onPass) {
         return;
     }
     if (unverified) {
-        explanation.textContent = 'The connection may be slow or offline.';
-        action.textContent = 'Try again when your connection is ready.';
+        explanation.textContent = 'Check your connection and try again.';
+        action.remove();
         const retry = document.createElement('button');
         retry.textContent = 'Retry';
         retry.addEventListener('click', () => {
+            retry.disabled = true;
             void installPageCheck(expected, check, 30_000, onPass);
         });
         content.append(retry);

package/dist/app/launchWatchdog.js

@@ -173,8 +173,13 @@ export function installLaunchWatchdog(budgetMs) {
         if (progress?.type === 'SATIN_DOWNLOAD_PROGRESS' &&
             progress.downloading &&
             Number.isFinite(progress.loaded) &&
-            progress.loaded >= 0)
+            progress.loaded >= 0) {
             receiveProgress(progress);
+            // A first install can download before the application module is available.
+            // Controlled documents are cached launches/updates and keep their existing policy.
+            if (!navigator.serviceWorker?.controller && !revealed)
+                window.__SATIN_LAUNCH_SCREEN__?.progress(progress);
+        }
     });
     // A client's worker messages are queued until DOMContentLoaded, and a bootstrap module that
     // never finishes holds DOMContentLoaded back: the worker's "this resource stalled" message

package/dist/docs/swiftui-reference.md

@@ -1892,4 +1892,4 @@ export function DraftEditor() {
 
 ## Framework source fingerprint
 
-SHA-256 of sorted TS/TSX/CSS source paths and bytes, excluding tests: b5ce591e73a0ec3a6d860cfa0434aa456a6128aa55251eed3e46b4e35ad8d223
+SHA-256 of sorted TS/TSX/CSS source paths and bytes, excluding tests: 1dfb5233c6482a7c54b0a396ffaa7079d66757b8816b1584c0eb39aad9428415

package/dist/glass/GlassMaterialRoot.d.ts

@@ -1,7 +1,9 @@
 import { type PropsWithChildren } from 'react';
 export type GlassDisplacementPolicy = 'auto' | 'disabled';
 /** The app paint layer remains untouched. Liquid regions own their retained image. */
-export declare function GlassMaterialRoot({ children, displacement, onLaunchReady, }: PropsWithChildren<{
+export declare function GlassMaterialRoot({ children, displacement, prepared, onLaunchReady, }: PropsWithChildren<{
     displacement: GlassDisplacementPolicy;
+    /** Lazy renderer modules wait for the verified offline bundle on first install. */
+    prepared?: boolean;
     onLaunchReady?: (ready: boolean) => void;
 }>): import("react").JSX.Element;

package/dist/glass/GlassMaterialRoot.js

@@ -12,7 +12,7 @@ function readAccessibilityPreferences() {
     };
 }
 /** The app paint layer remains untouched. Liquid regions own their retained image. */
-export function GlassMaterialRoot({ children, displacement, onLaunchReady, }) {
+export function GlassMaterialRoot({ children, displacement, prepared = true, onLaunchReady, }) {
     const scene = useRef(null);
     const [chromeLayer, setChromeLayer] = useState(null);
     const renderTest = 'passed';
@@ -35,5 +35,5 @@ export function GlassMaterialRoot({ children, displacement, onLaunchReady, }) {
     const registerRegion = useCallback((_registration) => () => { }, []);
     const diagnostics = useMemo(() => ({ accessibility, capability, renderTest, lensBoost: 1, mapRegenerationCount: 0 }), [accessibility, capability.reason, capability.state, renderTest]);
     const context = useMemo(() => ({ chromeLayer, diagnostics, registerRegion }), [chromeLayer, diagnostics, registerRegion]);
-    return (_jsxs(GlassMaterialContext, { value: context, children: [_jsx("div", { ref: scene, "data-satin-glass-capability": capability.state, "data-satin-scene-paint-layer": "true", "data-satin-diagnostic-glass-off": import.meta.env.SATIN_DIAGNOSTIC_GLASS_OFF || undefined, children: _jsx(MaterialEffectRoot, { scene: scene, chrome: chromeLayer, enabled: capability.state === 'displacement', capabilitySettled: true, onLaunchReady: onLaunchReady, children: children }) }), _jsx("div", { ref: setChromeLayer, "data-satin-glass-capability": capability.state, "data-satin-glass-chrome-layer": "true", "data-satin-glass-contrast": accessibility.increasedContrast ? 'more' : 'standard', "data-satin-glass-motion": accessibility.reducedMotion ? 'reduced' : 'full', "data-satin-glass-transparency": accessibility.reducedTransparency ? 'reduced' : 'full' })] }));
+    return (_jsxs(GlassMaterialContext, { value: context, children: [_jsx("div", { ref: scene, "data-satin-glass-capability": capability.state, "data-satin-scene-paint-layer": "true", "data-satin-diagnostic-glass-off": import.meta.env.SATIN_DIAGNOSTIC_GLASS_OFF || undefined, children: _jsx(MaterialEffectRoot, { scene: scene, chrome: chromeLayer, enabled: prepared && capability.state === 'displacement', capabilitySettled: prepared, onLaunchReady: onLaunchReady, children: children }) }), _jsx("div", { ref: setChromeLayer, "data-satin-glass-capability": capability.state, "data-satin-glass-chrome-layer": "true", "data-satin-glass-contrast": accessibility.increasedContrast ? 'more' : 'standard', "data-satin-glass-motion": accessibility.reducedMotion ? 'reduced' : 'full', "data-satin-glass-transparency": accessibility.reducedTransparency ? 'reduced' : 'full' })] }));
 }

package/dist/glass/MaterialEffectRoot.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { fallbackGlassRequested } from './fallback/selection.js';
-import { glassFallbackRequired, reportGlassError, subscribeGlassFallback } from './errors.js';
+import { glassFallbackRequired, reportGlassError, subscribeGlassFallback, watchGlassTransportRecovery, } from './errors.js';
 import { GlassRegionRegistry } from './regionRegistry.js';
 import { observeTabSources } from '../tabs/sourceRevision.js';
 import { useCallback, useEffect, useMemo, useState, useSyncExternalStore, } from 'react';
@@ -11,6 +11,10 @@ import { isSupportedTabCount } from './tabBarModel.js';
 /** One renderer per app. Registration is semantic; backdrop discovery is framework-owned. */
 export function MaterialEffectRoot({ children, scene, chrome, enabled, capabilitySettled, onLaunchReady, }) {
     const automaticFallback = useSyncExternalStore(subscribeGlassFallback, glassFallbackRequired, () => false);
+    useEffect(() => {
+        if (automaticFallback)
+            return watchGlassTransportRecovery();
+    }, [automaticFallback]);
     const [requestedFallback] = useState(fallbackGlassRequested);
     const backend = requestedFallback || automaticFallback ? 'fallback' : 'webgpu';
     const [regions] = useState(() => new GlassRegionRegistry());

package/dist/glass/errors.d.ts

@@ -12,7 +12,7 @@ export type GlassError = Readonly<{
     recovering?: true;
 }>;
 export declare function subscribeGlassFallback(listener: () => void): () => void;
-/** Successful resource reconstruction can retire only an adapter-outage fallback. */
+/** Retire a device outage only after resource reconstruction and presentation settle. */
 export declare function setGlassAdapterRecovery(pending: boolean): void;
 export declare function glassFallbackRequired(): boolean;
 export declare function reportGlassError(code: GlassErrorCode, cause: unknown, stage: string, reason?: string, recovery?: {
@@ -20,3 +20,5 @@ export declare function reportGlassError(code: GlassErrorCode, cause: unknown, s
 }): GlassError;
 export declare function subscribeGlassErrors(listener: (error: GlassError) => void): () => void;
 export declare function getGlassErrors(): readonly GlassError[];
+/** Retry a failed transport on a visible page; device reconstruction keeps its own owner. */
+export declare function watchGlassTransportRecovery(): () => void;

package/dist/glass/errors.js

@@ -1,10 +1,13 @@
 import { automaticGlassFallbackAllowed, strictGlassRequested } from './failurePolicy.js';
 import { recordGraphicsEvent } from '../graphicsProbe.js';
 const history = [];
-// Independent of diagnostic history. Only a reconstructed adapter outage can clear fallback.
+// Diagnostic history survives recovery; it is not the fallback state.
 let fallbackRequired = false;
 let permanentFallback = false;
 let adapterRecoveryPending = false;
+let transportRecoveryPending = false;
+let nextTransportRetry = 0;
+let transportFailures = 0;
 const fallbackListeners = new Set();
 export function subscribeGlassFallback(listener) {
     fallbackListeners.add(listener);
@@ -12,7 +15,7 @@ export function subscribeGlassFallback(listener) {
         fallbackListeners.delete(listener);
     };
 }
-/** Successful resource reconstruction can retire only an adapter-outage fallback. */
+/** Retire a device outage only after resource reconstruction and presentation settle. */
 export function setGlassAdapterRecovery(pending) {
     adapterRecoveryPending = pending;
     if (!pending && fallbackRequired && !permanentFallback) {
@@ -50,7 +53,17 @@ export function reportGlassError(code, cause, stage, reason, recovery) {
         history.shift();
     const release = automaticGlassFallbackAllowed();
     if (release && !error.recovering) {
-        if (!adapterRecoveryPending || (code !== 'adapter-unavailable' && code !== 'readiness-timeout'))
+        const transportFailure = code === 'worker-startup' ||
+            (!adapterRecoveryPending &&
+                ['adapter-unavailable', 'device-request', 'readiness-timeout'].includes(code)) ||
+            (code === 'presentation' &&
+                /import.*module|module.*script|loading.*chunk|load failed/i.test(message));
+        if (transportFailure) {
+            transportRecoveryPending = true;
+            nextTransportRetry = Date.now() + Math.min(3000 * 2 ** transportFailures++, 30_000);
+        }
+        else if (!adapterRecoveryPending ||
+            ['gpu-unavailable', 'unsupported-configuration', 'shader-compilation', 'validation'].includes(code))
             permanentFallback = true;
         fallbackRequired = true;
         for (const listener of fallbackListeners)
@@ -76,3 +89,36 @@ export function subscribeGlassErrors(listener) {
 export function getGlassErrors() {
     return history.slice();
 }
+/** Retry a failed transport on a visible page; device reconstruction keeps its own owner. */
+export function watchGlassTransportRecovery() {
+    let timer;
+    const retry = () => {
+        clearTimeout(timer);
+        if (!fallbackRequired ||
+            permanentFallback ||
+            !transportRecoveryPending ||
+            adapterRecoveryPending)
+            return;
+        if (document.visibilityState !== 'visible')
+            return;
+        const delay = nextTransportRetry - Date.now();
+        if (delay > 0) {
+            timer = setTimeout(retry, delay);
+            return;
+        }
+        transportRecoveryPending = false;
+        fallbackRequired = false;
+        for (const listener of fallbackListeners)
+            listener();
+    };
+    document.addEventListener('visibilitychange', retry);
+    window.addEventListener('pageshow', retry);
+    window.addEventListener('focus', retry);
+    retry();
+    return () => {
+        clearTimeout(timer);
+        document.removeEventListener('visibilitychange', retry);
+        window.removeEventListener('pageshow', retry);
+        window.removeEventListener('focus', retry);
+    };
+}

package/dist/glass/fallback/canvasOwnership.d.ts

@@ -0,0 +1,7 @@
+/** Parking WebGPU retains its last pixels. CSS ownership must hide those pixels,
+ * including lift/selection canvases, without destroying the renderer's reusable canvas. */
+export declare class FallbackCanvasOwnership {
+    private visibility;
+    update(canvases: Iterable<HTMLCanvasElement>): void;
+    dispose(): void;
+}

package/dist/glass/fallback/canvasOwnership.js

@@ -0,0 +1,23 @@
+/** Parking WebGPU retains its last pixels. CSS ownership must hide those pixels,
+ * including lift/selection canvases, without destroying the renderer's reusable canvas. */
+export class FallbackCanvasOwnership {
+    visibility = new Map();
+    update(canvases) {
+        const live = new Set(canvases);
+        for (const [canvas, visibility] of this.visibility) {
+            if (live.has(canvas))
+                continue;
+            canvas.style.visibility = visibility;
+            this.visibility.delete(canvas);
+        }
+        for (const canvas of live) {
+            if (this.visibility.has(canvas))
+                continue;
+            this.visibility.set(canvas, canvas.style.visibility);
+            canvas.style.visibility = 'hidden';
+        }
+    }
+    dispose() {
+        this.update([]);
+    }
+}

package/dist/glass/fallback/material.js

@@ -1,4 +1,4 @@
-import { animateElement } from '../../motion/animate.js';
+import { animateElement, timelineStart } from '../../motion/animate.js';
 /** CSS owns backdrop sampling, including video that cannot be read into a GPU texture. */
 export class FallbackMaterial {
     element = document.createElement('div');
@@ -61,6 +61,7 @@ export class FallbackMaterial {
         this.paint(specs[specs.length - 1], appearance);
         const count = Math.max(...specs.map(spec => this.shapes(spec).length));
         this.ensure(count, appearance, specs[specs.length - 1]);
+        const start = timelineStart(at);
         this.parts.forEach((part, index) => {
             const frames = specs.map((spec, sample) => {
                 const shape = this.shapes(spec)[index];
@@ -70,7 +71,7 @@ export class FallbackMaterial {
                 };
             });
             const animation = animateElement(part, frames, { duration, easing: 'linear', fill: 'both' });
-            animation.startTime = at;
+            animation.startTime = start;
             this.animations.push(animation);
         });
         return Promise.all(this.animations.map(animation => animation.finished)).then(() => { }, () => { });

package/dist/glass/fallback/regions.d.ts

@@ -1,6 +1,7 @@
 import type { GlassRegionRegistry } from '../regionRegistry.js';
 /** Registered DOM owners already follow scroll, sheets and navigation on the compositor. */
 export declare class FallbackRegions {
+    private canvases;
     private entries;
     private unsubscribe;
     private frame;

package/dist/glass/fallback/regions.js

@@ -4,11 +4,13 @@ import { sampleMenuCorner } from '../lens/menuCornerMotion.js';
 import { confirmHeldSources, heldPresentations } from '../presentationFrame.js';
 import { animateElement, timelineStart } from '../../motion/animate.js';
 import { FallbackMaterial } from './material.js';
+import { FallbackCanvasOwnership } from './canvasOwnership.js';
 import { GLASS_SHAPE_TRACK_EVENT, glassShapeTrack } from '../shapeTrackRegistry.js';
 import { trackedShapeSpec } from '../shapeTrack.js';
 import { glassRadius } from '../regions.js';
 /** Registered DOM owners already follow scroll, sheets and navigation on the compositor. */
 export class FallbackRegions {
+    canvases = new FallbackCanvasOwnership();
     entries = new Map();
     unsubscribe = [];
     frame = 0;
@@ -43,12 +45,15 @@ export class FallbackRegions {
     }
     refresh() {
         const registrations = this.registry?.values() ?? [];
+        this.canvases.update([
+            ...registrations.flatMap(entry => [entry.canvas, ...(entry.overlay ? [entry.overlay] : [])]),
+            ...[...(this.registry?.containers.values() ?? [])].map(entry => entry.canvas),
+        ]);
         const live = new Set(registrations.map(entry => entry.id));
         for (const [id, entry] of this.entries) {
             if (!live.has(id)) {
                 entry.ink?.cancel();
                 entry.material.dispose();
-                entry.restoreCanvas();
                 this.entries.delete(id);
             }
         }
@@ -90,18 +95,10 @@ export class FallbackRegions {
             const signature = JSON.stringify([region, this.appearance]);
             let entry = this.entries.get(id);
             if (!entry) {
-                // A live demotion can leave the last GPU frame on this canvas. Retain the
-                // canvas for presentation receipts, but let only the CSS material paint.
-                const canvas = registration.canvas;
-                const visibility = canvas.style.visibility;
-                canvas.style.visibility = 'hidden';
                 entry = {
                     material: new FallbackMaterial(element),
                     signature: '',
                     generation: 0,
-                    restoreCanvas: () => {
-                        canvas.style.visibility = visibility;
-                    },
                 };
                 this.entries.set(id, entry);
             }
@@ -129,7 +126,7 @@ export class FallbackRegions {
                 if (track.epoch === Number.MAX_VALUE || frames.length === 1)
                     entry.material.paint(frames[0], this.appearance);
                 else
-                    void entry.material.play(frames, track.duration, timelineStart(track.epoch - performance.timeOrigin), this.appearance);
+                    void entry.material.play(frames, track.duration, track.epoch - performance.timeOrigin, this.appearance);
                 continue;
             }
             if (!emerge || emerge.ready === false) {
@@ -204,7 +201,7 @@ export class FallbackRegions {
                     };
                 });
                 entry.ink = animateElement(ink, frames, { duration, easing: 'linear', fill: 'both' });
-                entry.ink.startTime = at;
+                entry.ink.startTime = timelineStart(at);
             }
             if (emerge.closing)
                 this.registry?.emergeInk({
@@ -242,8 +239,8 @@ export class FallbackRegions {
         this.entries.forEach(entry => {
             entry.ink?.cancel();
             entry.material.dispose();
-            entry.restoreCanvas();
         });
         this.entries.clear();
+        this.canvases.dispose();
     }
 }

package/dist/glass/fallback/runtime.d.ts

@@ -3,6 +3,7 @@ import type { RestorePath } from '../lens/tabRestoreMotion.js';
 import type { ScreenId } from '../lens/Scene.js';
 /** Material replacement only: semantic controls and measured motion keep their existing owners. */
 export declare class FallbackGlassRuntime {
+    private canvases;
     private regions;
     private dock;
     private thumb;
@@ -25,6 +26,7 @@ export declare class FallbackGlassRuntime {
     private scroll;
     private dockSpec;
     private minimizeTrack;
+    private playMinimizeTrack;
     restoreMinimizingTabBar(path?: RestorePath): boolean;
     private thumbSpec;
     private paintTabs;

package/dist/glass/fallback/runtime.js

@@ -6,8 +6,10 @@ import { tabHeldGeometry } from '../webgpu/interactionProfiles.js';
 import { WorkerMinimize } from '../webgpu/minimize.js';
 import { FallbackMaterial } from './material.js';
 import { FallbackRegions } from './regions.js';
+import { FallbackCanvasOwnership } from './canvasOwnership.js';
 /** Material replacement only: semantic controls and measured motion keep their existing owners. */
 export class FallbackGlassRuntime {
+    canvases = new FallbackCanvasOwnership();
     regions;
     dock;
     thumb;
@@ -25,18 +27,23 @@ export class FallbackGlassRuntime {
         Object.assign(globalThis, {
             __SATIN_GLASS_RENDERER__: { backend: 'fallback', errors: getGlassErrors },
         });
+        const band = options.elements.band;
+        const shell = band.canvas.closest('[data-satin-liquid]');
+        this.canvases.update([
+            band.canvas,
+            band.rimCanvas,
+            ...(shell?.querySelectorAll('canvas[data-satin-webgpu],canvas[data-satin-glass-lift]') ?? []),
+        ]);
         this.regions = new FallbackRegions(options.regions, options.appearance);
         this.dock = new FallbackMaterial(options.elements.chrome.dock);
         this.thumb = new FallbackMaterial(options.elements.chrome.dock);
         this.dock.element.style.zIndex = '-2';
         this.thumb.element.style.zIndex = '-1';
         this.minimizeDom = new WorkerMinimize(options, path => this.restoreMinimizingTabBar(path), {
-            begin: x => {
-                this.tabPointerDown(x, this.options.geometry.tabBarSelectedIndex ?? 0);
-            },
+            begin: x => this.tabPointerDown(x, this.options.geometry.tabBarSelectedIndex ?? 0),
             move: x => this.tabPointerMove(x),
             end: cancelled => this.tabPointerUp(cancelled),
-        });
+        }, track => this.playMinimizeTrack(track));
         this.bindScroll();
         this.unsubscribeAppearance = options.subscribeAppearance?.(() => this.commitAppearance(options.currentAppearance?.() ?? options.appearance));
         this.updateGeometry({});
@@ -90,6 +97,9 @@ export class FallbackGlassRuntime {
     }
     minimizeTrack(direction, path = 'tap') {
         const track = this.minimizeDom.start(direction, this.dockSpec(), path);
+        this.playMinimizeTrack(track);
+    }
+    playMinimizeTrack(track) {
         void this.dock.play(track.specs, track.duration, track.at, this.options.appearance);
         void this.thumb.play(track.specs.map(spec => this.thumbSpec(spec)), track.duration, track.at, this.options.appearance);
     }
@@ -272,6 +282,7 @@ export class FallbackGlassRuntime {
         this.unsubscribeAppearance?.();
         this.minimizeDom.dispose();
         this.regions.dispose();
+        this.canvases.dispose();
         this.dock.dispose();
         this.thumb.dispose();
     }

package/dist/glass/webgpu/client.d.ts

@@ -21,6 +21,7 @@ export declare class WebGPUClient {
     };
     private adapterDeadline?;
     private failed?;
+    private startingTransport;
     private frames;
     private webgpu;
     private currentAppearance;
@@ -45,5 +46,7 @@ export declare class WebGPUClient {
     private focus;
     private bindLifecycle;
     resume(): void;
+    /** Dispose a failed transport before constructing its replacement. */
+    close(): void;
     park(): Promise<unknown>;
 }

package/dist/glass/webgpu/client.js

@@ -30,6 +30,7 @@ export class WebGPUClient {
     }
     adapterDeadline;
     failed;
+    startingTransport = false;
     frames = new PageFrameHost();
     webgpu = false;
     currentAppearance = () => readDarkAppearance() ? 'dark' : 'light';
@@ -68,7 +69,26 @@ export class WebGPUClient {
         })), motionPreparationEnabled);
         glassTiming('client-start');
         try {
-            await this.initialize(canvas, resolution, worker, webgpu, appearance, execution);
+            for (let attempt = 0;; attempt++) {
+                this.startingTransport = true;
+                try {
+                    await this.initialize(canvas, resolution, worker, webgpu, appearance, execution);
+                    break;
+                }
+                catch (error) {
+                    const code = glassFailureCode('renderer initialization', error);
+                    const retryable = this.startingTransport &&
+                        ['worker-startup', 'readiness-timeout', 'device-request'].includes(code);
+                    if (!retryable || attempt === 2)
+                        throw error;
+                    this.close();
+                    this.failed = undefined;
+                    await new Promise(resolve => setTimeout(resolve, 250 * 2 ** attempt));
+                }
+                finally {
+                    this.startingTransport = false;
+                }
+            }
         }
         catch (error) {
             reportGlassError(glassFailureCode('renderer initialization', error), error, 'renderer initialization');
@@ -153,7 +173,7 @@ export class WebGPUClient {
                     return;
                 }
                 if (glassError) {
-                    reportGlassError(glassError.code, glassError.message, glassError.stage, glassError.reason);
+                    reportGlassError(glassError.code, glassError.message, glassError.stage, glassError.reason, this.startingTransport ? { recovering: true } : undefined);
                     return;
                 }
                 const request = this.pending.get(id);
@@ -174,12 +194,18 @@ export class WebGPUClient {
                 };
             }
             else {
-                const transport = new Worker(new URL('./entry.worker.js', import.meta.url), {
-                    type: 'module',
-                    name: 'satin-glass-webgpu',
-                });
+                let transport;
+                try {
+                    transport = new Worker(new URL('./entry.worker.js', import.meta.url), {
+                        type: 'module',
+                        name: 'satin-glass-webgpu',
+                    });
+                }
+                catch (error) {
+                    throw new Error(`Worker startup: ${String(error)}`, { cause: error });
+                }
                 transport.onmessage = receive;
-                transport.onerror = event => this.failTransport(new Error(event.message || 'Glass worker failed'), 'worker startup/runtime');
+                transport.onerror = event => this.failTransport(new Error(`Worker startup/runtime: ${event.message || 'Glass worker failed'}`), 'worker startup/runtime');
                 transport.onmessageerror = () => this.failTransport(Error('Glass worker message could not be deserialized'), 'worker transport');
                 this.transport = {
                     postMessage: (data, transfer = []) => transport.postMessage(data, transfer),
@@ -205,7 +231,7 @@ export class WebGPUClient {
                 }
                 catch (error) {
                     this.failed = error instanceof Error ? error : Error(String(error));
-                    reportGlassError(glassFailureCode('WebGPU startup', this.failed), this.failed, 'WebGPU startup');
+                    // init owns the bounded startup retry and terminal report.
                     this.transport?.terminate();
                     for (const pending of this.pending.values())
                         pending.reject(this.failed);
@@ -216,6 +242,7 @@ export class WebGPUClient {
                     clearTimeout(timeout);
                 }
             }
+            this.startingTransport = false;
             const offscreen = this.local ? canvas : canvas.transferControlToOffscreen();
             await this.request({
                 type: 'init',
@@ -233,7 +260,8 @@ export class WebGPUClient {
     failTransport(error, stage) {
         this.adapterDeadline?.cancel();
         this.failed = error;
-        reportGlassError(glassFailureCode(stage, error), error, stage);
+        if (!this.startingTransport)
+            reportGlassError(glassFailureCode(stage, error), error, stage);
         for (const pending of this.pending.values())
             pending.reject(error);
         this.pending.clear();
@@ -324,6 +352,26 @@ export class WebGPUClient {
         this.bindLifecycle();
         this.visibility();
     }
+    /** Dispose a failed transport before constructing its replacement. */
+    close() {
+        this.frames.cancel();
+        this.adapterDeadline?.cancel();
+        this.adapterDeadline = undefined;
+        document.removeEventListener('visibilitychange', this.visibility, true);
+        window.removeEventListener('pagehide', this.visibility, true);
+        window.removeEventListener('pageshow', this.visibility);
+        window.removeEventListener('focus', this.focus);
+        document.removeEventListener('visibilitychange', this.adapterVisibility, true);
+        window.removeEventListener('pagehide', this.adapterVisibility, true);
+        window.removeEventListener('pageshow', this.adapterVisibility);
+        window.removeEventListener('focus', this.adapterVisibility);
+        this.transport?.terminate();
+        this.transport = undefined;
+        this.local = undefined;
+        for (const pending of this.pending.values())
+            pending.reject(Error('Glass transport retired'));
+        this.pending.clear();
+    }
     park() {
         this.frames.cancel();
         document.removeEventListener('visibilitychange', this.visibility, true);

package/dist/glass/webgpu/errorCode.js

@@ -1,6 +1,9 @@
 /** Classification retains the raw message; it never chooses a replacement. */
 export function glassFailureCode(stage, cause) {
     const message = cause instanceof Error ? `${cause.name}: ${cause.message}` : String(cause), text = stage + ' ' + message;
+    // Preserve the failed transport owner when a worker reports its own device loss.
+    if (/worker.*(?:startup|runtime|transport|rejection)/i.test(text))
+        return 'worker-startup';
     if (/device\.lost|device.?lost/i.test(text))
         return 'device-lost';
     if (/out.?of.?memory/i.test(text))
@@ -19,8 +22,6 @@ export function glassFailureCode(stage, cause) {
         return 'context-configure';
     if (/readiness|2\.5 seconds|2500 ms/i.test(text))
         return 'readiness-timeout';
-    if (/worker.*(?:startup|runtime|transport|rejection)/i.test(text))
-        return 'worker-startup';
     if (/unsupported|invalid glass|Unknown.*(?:layer|region)|exceeds.*supported/i.test(text))
         return 'unsupported-configuration';
     return 'presentation';

package/dist/glass/webgpu/layers.d.ts

@@ -22,7 +22,9 @@ export declare class LayerDevice {
     private stopped;
     private adapterPending;
     private recovering;
-    private recoveryBlocked;
+    private recoveryBlockedUntil;
+    private recoveryTimer?;
+    private recoveryFailures;
     private forcedNullAdapters;
     private lastLoss?;
     readonly stats: {
@@ -43,6 +45,8 @@ export declare class LayerDevice {
     stop(): void;
     /** Foreground signals wake the single acquisition already in flight. */
     retryAdapter(): Promise<GPUDevice> | undefined;
+    private scheduleRecovery;
+    private waitUntilVisible;
     forceNullAdaptersForTest(attempts: number): void;
     private requestAdapter;
     private acquire;

package/dist/glass/webgpu/layers.js

@@ -34,7 +34,9 @@ export class LayerDevice {
     stopped = false;
     adapterPending = false;
     recovering = false;
-    recoveryBlocked = false;
+    recoveryBlockedUntil = 0;
+    recoveryTimer;
+    recoveryFailures = 0;
     forcedNullAdapters = 0;
     lastLoss;
     stats = {
@@ -57,8 +59,10 @@ export class LayerDevice {
     async ready() {
         if (this.device)
             return this.device;
-        if (this.recoveryBlocked)
-            throw Error('Glass device repeatedly lost during recovery');
+        if (Date.now() < this.recoveryBlockedUntil) {
+            this.scheduleRecovery();
+            throw Error('Glass device recovery is cooling down');
+        }
         if (this.starting)
             return this.starting;
         this.starting = this.acquire();
@@ -79,8 +83,13 @@ export class LayerDevice {
                 }
             }
             failedDevice?.destroy();
-            if (!this.stopped)
+            if (!this.stopped) {
                 this.reportError(this.recovering ? 'device recreation' : 'device acquisition', error);
+                if (this.recovering) {
+                    this.recoveryFailures++;
+                    this.scheduleRecovery();
+                }
+            }
             throw error;
         }
         finally {
@@ -91,21 +100,53 @@ export class LayerDevice {
     setAdapterVisible(visible) {
         this.adapterVisible = visible;
         this.retryWake?.();
+        if (!visible) {
+            clearTimeout(this.recoveryTimer);
+            this.recoveryTimer = undefined;
+        }
+        else if (this.recovering && !this.starting && !this.device)
+            this.scheduleRecovery();
     }
     stop() {
         this.stopped = true;
+        clearTimeout(this.recoveryTimer);
         this.retryWake?.();
     }
     /** Foreground signals wake the single acquisition already in flight. */
     retryAdapter() {
-        if (this.device || this.recoveryBlocked)
+        if (this.device || this.stopped || !this.adapterVisible)
+            return;
+        if (Date.now() < this.recoveryBlockedUntil) {
+            this.scheduleRecovery();
             return;
+        }
         if (this.starting) {
             this.retryWake?.();
             return;
         }
         return this.ready();
     }
+    scheduleRecovery() {
+        if (this.stopped || !this.adapterVisible || this.recoveryTimer)
+            return;
+        const delay = Math.max(this.recoveryBlockedUntil - Date.now(), Math.min(1000 * 2 ** this.recoveryFailures, 30_000));
+        this.recoveryTimer = setTimeout(() => {
+            this.recoveryTimer = undefined;
+            void this.retryAdapter()?.catch(() => {
+                /* ready records and schedules the next attempt. */
+            });
+        }, delay);
+    }
+    async waitUntilVisible() {
+        while (!this.adapterVisible && !this.stopped) {
+            await new Promise(resolve => {
+                this.retryWake = resolve;
+            });
+            this.retryWake = undefined;
+        }
+        if (this.stopped)
+            throw Error('Glass renderer stopped during adapter acquisition');
+    }
     forceNullAdaptersForTest(attempts) {
         if (!Number.isInteger(attempts) || attempts < 0 || attempts > 100)
             throw Error('Null-adapter attempts must be an integer between 0 and 100');
@@ -167,6 +208,15 @@ export class LayerDevice {
         })).catch(error => {
             throw Error(`requestDevice rejected: ${String(error)}`);
         });
+        // requestDevice may resolve after a quick re-background. Do not rebuild or
+        // announce readiness against a suspended presentation generation.
+        try {
+            await this.waitUntilVisible();
+        }
+        catch (error) {
+            device.destroy();
+            throw error;
+        }
         this.device = device;
         this.faults.length = 0;
         registerGPUReporter(device, (stage, error) => {
@@ -207,11 +257,13 @@ export class LayerDevice {
             }
             if (invalidationError) {
                 this.reportError('device recreation', invalidationError);
+                this.scheduleRecovery();
                 return;
             }
             // WebKit can report destroyed for an unexpected loss as well.
             if (this.lossTimes.length > 3) {
-                this.recoveryBlocked = true;
+                this.recoveryBlockedUntil = this.lossTimes[0] + 60_000;
+                this.scheduleRecovery();
                 this.reportError('device recreation', 'Glass device repeatedly lost during recovery');
                 return;
             }
@@ -227,6 +279,9 @@ export class LayerDevice {
             for (const listener of this.listeners)
                 listener(device);
             this.stats.restores++;
+            this.recoveryFailures = 0;
+            clearTimeout(this.recoveryTimer);
+            this.recoveryTimer = undefined;
             this.recovering = false;
             if (lagTraceEnabled())
                 glassTiming('device-restored');

package/dist/glass/webgpu/minimize.js

@@ -374,8 +374,26 @@ export class WorkerMinimize {
                 },
             };
         }
-        if (atRest(f))
-            return spec;
+        if (atRest(f)) {
+            // A retargeted track includes its pre-onset frames. They must use the current
+            // slot too; returning the captured spec preserves the old expanded width.
+            return {
+                ...spec,
+                frameWidth: geometry.dockWidth,
+                frameHeight: geometry.dockHeight,
+                shape: {
+                    ...spec.shape,
+                    first: {
+                        ...spec.shape.first,
+                        centerX: geometry.dockWidth / 2,
+                        centerY: geometry.dockHeight / 2,
+                        halfWidth: geometry.dockWidth / 2,
+                        halfHeight: geometry.dockHeight / 2,
+                        radius: geometry.dockRadius,
+                    },
+                },
+            };
+        }
         const g = this.options.geometry, p = minimizePlacement(f.progress, g.dockWidth, g.dockHeight, g.tabBarMinimizedOffsetX), height = g.dockHeight + (48 - g.dockHeight) * f.heightProgress, y = 7 * f.heightProgress, pill = spec.tabSelection?.capsule;
         const bar = {
             centerX: p.x + p.width / 2,

package/dist/glass/webgpu/production.js

@@ -304,6 +304,12 @@ export class ProductionGlassRuntime {
     static async create(options) {
         if (this.shared) {
             const runtime = await this.shared;
+            if (runtime.client.status().failed) {
+                runtime.teardown();
+                runtime.client.close();
+                this.shared = undefined;
+                return this.create(options);
+            }
             runtime.rebind(options);
             await runtime.prepare();
             return runtime;
@@ -317,7 +323,9 @@ export class ProductionGlassRuntime {
             catch (error) {
                 // A rejected create never reaches the React owner's cleanup. Retire its
                 // listeners and captures here before a release app mounts CSS material.
-                runtime.dispose(options);
+                runtime.teardown();
+                runtime.client.close();
+                this.shared = undefined;
                 throw error;
             }
         })();

package/dist/glass/webgpu/sourcePixels.d.ts

@@ -19,13 +19,12 @@ export declare class SourcePixels {
     private worker?;
     private next;
     private failure?;
+    private retrying?;
     private pending;
     private create;
     constructor(create?: () => Transport);
-    /** The upload worker failed (its device was lost, or a reply never came). The instance stays
-     * failed for images that need the worker: the bounded recovery of a source preparation replaces
-     * it (`ProductionGlassRuntime.replaceFailedSourcePixels`), so a failure is reported once per
-     * attempt and never retried in a loop. Canvas readbacks do not use the worker and still work. */
+    /** Exhausted upload failures let the production owner replace this source stager.
+     * Canvas readbacks remain available because they do not use the worker. */
     get failed(): boolean;
     private fail;
     /** Stage `image`'s premultiplied bytes for its upload (`takeSourcePixels`). When `capture` is a
@@ -39,4 +38,5 @@ export declare class SourcePixels {
      * in WebKit (157 ms for a 1320 x 5091 capture in the Catalyst host), more than half of the
      * stage. Measured for captures up to 1320 x 6495; the cause inside WebKit was not sampled. */
     prepare(image: ImageBitmap, capture?: ImageBitmapSource): Promise<void>;
+    private prepareOnce;
 }

package/dist/glass/webgpu/sourcePixels.js

@@ -32,6 +32,7 @@ export class SourcePixels {
     worker;
     next = 0;
     failure;
+    retrying;
     pending = new Map();
     create;
     constructor(create = () => new Worker(new URL('./sourcePixels.worker.js', import.meta.url), {
@@ -40,10 +41,8 @@ export class SourcePixels {
     })) {
         this.create = create;
     }
-    /** The upload worker failed (its device was lost, or a reply never came). The instance stays
-     * failed for images that need the worker: the bounded recovery of a source preparation replaces
-     * it (`ProductionGlassRuntime.replaceFailedSourcePixels`), so a failure is reported once per
-     * attempt and never retried in a loop. Canvas readbacks do not use the worker and still work. */
+    /** Exhausted upload failures let the production owner replace this source stager.
+     * Canvas readbacks remain available because they do not use the worker. */
     get failed() {
         return !!this.failure;
     }
@@ -51,7 +50,9 @@ export class SourcePixels {
         this.failure = error;
         this.worker?.terminate();
         this.worker = undefined;
-        reportGlassError('worker-startup', error, 'source upload worker');
+        reportGlassError('worker-startup', error, 'source upload worker', undefined, {
+            recovering: true,
+        });
         for (const job of this.pending.values()) {
             clearTimeout(job.timer);
             job.reject(error);
@@ -69,6 +70,30 @@ export class SourcePixels {
      * in WebKit (157 ms for a 1320 x 5091 capture in the Catalyst host), more than half of the
      * stage. Measured for captures up to 1320 x 6495; the cause inside WebKit was not sampled. */
     async prepare(image, capture = image) {
+        for (let attempt = 0;; attempt++) {
+            try {
+                if (this.retrying)
+                    await this.retrying;
+                return await this.prepareOnce(image, capture);
+            }
+            catch (error) {
+                if (!this.failure)
+                    throw error;
+                if (attempt === 2) {
+                    reportGlassError('worker-startup', error, 'source upload worker');
+                    throw new Error(`Source upload worker startup failed: ${String(error)}`, { cause: error });
+                }
+                // Concurrent uploads share one restart. Each retry clones from the retained
+                // source, never from the bitmap already transferred to the failed worker.
+                this.retrying ??= new Promise(resolve => setTimeout(resolve, 250 * 2 ** attempt)).then(() => {
+                    this.failure = undefined;
+                    this.retrying = undefined;
+                });
+                await this.retrying;
+            }
+        }
+    }
+    async prepareOnce(image, capture) {
         const readbackStarted = glassNow();
         const pixels = canvasPixels(capture);
         if (pixels) {
@@ -83,8 +108,17 @@ export class SourcePixels {
         if (this.failure)
             throw this.failure;
         if (!this.worker) {
-            this.worker = this.create();
+            try {
+                this.worker = this.create();
+            }
+            catch (error) {
+                this.fail(error instanceof Error ? error : Error(String(error)));
+                throw error;
+            }
+            const worker = this.worker;
             this.worker.onmessage = event => {
+                if (this.worker !== worker)
+                    return;
                 const data = event.data;
                 if (data.id === 0 && data.error) {
                     this.fail(Error(data.error));
@@ -109,8 +143,14 @@ export class SourcePixels {
                 prepared.set(job.image, new Uint8Array(data.buffer));
                 job.resolve();
             };
-            this.worker.onerror = event => this.fail(Error(event.message || 'Source upload worker failed'));
-            this.worker.onmessageerror = () => this.fail(Error('Source upload worker reply could not be decoded'));
+            this.worker.onerror = event => {
+                if (this.worker === worker)
+                    this.fail(Error(event.message || 'Source upload worker failed'));
+            };
+            this.worker.onmessageerror = () => {
+                if (this.worker === worker)
+                    this.fail(Error('Source upload worker reply could not be decoded'));
+            };
         }
         const started = glassNow(), clone = await createImageBitmap(capture);
         if (this.failure) {

package/dist/root/SatinRoot.js

@@ -159,6 +159,7 @@ export function SatinRoot({ background: legacyBackground, app: suppliedApp, offl
     const downloadedBytes = useRef(0);
     const [launchAttempt, setLaunchAttempt] = useState(0);
     const [glassReady, setGlassReady] = useState(false);
+    const [bundlePrepared, setBundlePrepared] = useState(import.meta.env.DEV || !app);
     const [glassError, setGlassError] = useState(null);
     const [glassFailed, setGlassFailed] = useState(false);
     useLayoutEffect(() => {
@@ -235,10 +236,13 @@ export function SatinRoot({ background: legacyBackground, app: suppliedApp, offl
                                 downloadActivity.current = performance.now();
                                 downloadedBytes.current = progress.loaded;
                             }
-                            // Release launch rings confirm updates; first-install bytes
-                            // still drive readiness/watchdogs without promising an update.
-                            if (app.updateProfile !== 'release')
-                                setLaunchProgress(progress);
+                            // First-install bytes describe a real download in every profile.
+                            // Applied-update confirmation remains a separate successor phase.
+                            setLaunchProgress(progress);
+                        }).then(ready => {
+                            if (!cancelled && ready)
+                                setBundlePrepared(true);
+                            return ready;
                         }),
                     prepareLaunchContent(rootRef.current, contentPreparation.signal),
                 ]);
@@ -489,7 +493,7 @@ export function SatinRoot({ background: legacyBackground, app: suppliedApp, offl
             return;
         return startDevFidelityAssertions(initialHistoryLength.current);
     }, []);
-    return (_jsx(RuntimeContext, { value: runtime, children: _jsxs(MediaPlayerRoot, { onActivityChange: onMediaActivityChange, children: [_jsx("div", { ...props, ref: rootRef, className: className, "data-satin-role": "chrome", "data-satin-root": "true", "data-satin-launch": launch, "data-satin-presentation": presentationPending ? 'preparing' : 'ready', inert: launch !== 'ready' || presentationPending, "data-satin-layout-horizontal": nextLayout.layoutClass.horizontal, "data-satin-layout-vertical": nextLayout.layoutClass.vertical, style: geometryStyles, children: _jsx(AdaptiveTabsContext, { value: tabs, children: _jsx("div", { "data-satin-status-band-source": "scene", children: _jsxs(GlassMaterialRoot, { displacement: glassDisplacement, onLaunchReady: setGlassReady, children: [DeveloperMenu && app && launch === 'ready' ? (_jsx(Suspense, { fallback: null, children: _jsx(DeveloperMenu, {}) })) : null, app ? (_jsx(OrientationGuard, { app: app, width: metrics.safeFrame.width, height: metrics.safeFrame.height, children: _jsx(ReachabilityProvider, { profile: app, offlinePresentation: offlinePresentation, children: children }) })) : (children)] }) }) }) }), launch === 'failed'
+    return (_jsx(RuntimeContext, { value: runtime, children: _jsxs(MediaPlayerRoot, { onActivityChange: onMediaActivityChange, children: [_jsx("div", { ...props, ref: rootRef, className: className, "data-satin-role": "chrome", "data-satin-root": "true", "data-satin-launch": launch, "data-satin-presentation": presentationPending ? 'preparing' : 'ready', inert: launch !== 'ready' || presentationPending, "data-satin-layout-horizontal": nextLayout.layoutClass.horizontal, "data-satin-layout-vertical": nextLayout.layoutClass.vertical, style: geometryStyles, children: _jsx(AdaptiveTabsContext, { value: tabs, children: _jsx("div", { "data-satin-status-band-source": "scene", children: _jsxs(GlassMaterialRoot, { displacement: glassDisplacement, prepared: bundlePrepared, onLaunchReady: setGlassReady, children: [DeveloperMenu && app && launch === 'ready' ? (_jsx(Suspense, { fallback: null, children: _jsx(DeveloperMenu, {}) })) : null, app ? (_jsx(OrientationGuard, { app: app, width: metrics.safeFrame.width, height: metrics.safeFrame.height, children: _jsx(ReachabilityProvider, { profile: app, offlinePresentation: offlinePresentation, children: children }) })) : (children)] }) }) }) }), launch === 'failed'
                     ? createPortal(_jsxs("div", { "data-satin-role": "chrome", "data-satin-launch-error": "true", "data-satin-glass-error": glassError ? true : undefined, role: "alert", style: { zIndex: launchErrorLayer }, children: [!glassError ? (_jsx("img", { className: "satin-launch-error-icon", src: document.querySelector('#satin-launch-screen .satin-launch-icon img')?.src ??
                                     app?.launchScreen?.icon ??
                                     app?.icons[0]?.src, alt: "" })) : null, _jsxs("div", { className: "satin-launch-error-message", children: [_jsx("h1", { children: glassError ? 'Glass Renderer Failed' : 'Unable to Open App' }), glassError ? (_jsx("pre", { style: { whiteSpace: 'pre-wrap', overflowWrap: 'anywhere' }, children: `${glassError.code} · ${glassError.stage}\n${glassError.message}${glassError.reason ? `\n${glassError.reason}` : ''}` })) : (_jsx("p", { children: preparationError })), _jsx("button", { type: "button", onClick: async () => {

package/dist/sw/renderServiceWorker.js

@@ -39,7 +39,8 @@ self.addEventListener('install', (event) => {
     await reportProgress()
     const activeDownloads = new Set()
     let failureReport
-    const download = async (entry) => {
+    const download = async (entry, attempt = 0) => {
+      let received = 0
       let networkFailure = true
       let stalled = false
       const controller = new AbortController()
@@ -76,7 +77,7 @@ self.addEventListener('install', (event) => {
         progress.activity++
         await reportProgress()
         if (installFailure) throw new Error('Installation cancelled')
-        networkFailure = false
+        networkFailure = response.status >= 500 || response.status === 408 || response.status === 429
         if (!response.ok || response.type === 'opaque') throw new Error('HTTP ' + response.status)
         if (response.redirected) throw new Error('Precache resource redirected')
         const mime = (response.headers.get('content-type') || '').split(';')[0].trim().toLowerCase()
@@ -86,7 +87,6 @@ self.addEventListener('install', (event) => {
         networkFailure = true
         reader = response.body?.getReader()
         const chunks = []
-        let received = 0
         if (reader) {
           while (true) {
             const { done, value } = await Promise.race([reader.read(), idleFailure])
@@ -112,6 +112,15 @@ self.addEventListener('install', (event) => {
         if (installFailure) throw new Error('Installation cancelled')
         await cache.put(request, new Response(blob, { status: response.status, statusText: response.statusText, headers: response.headers }))
       } catch (error) {
+        if (!installFailure && (networkFailure || stalled) && attempt < 2) {
+          clearTimeout(idleTimer)
+          activeDownloads.delete(cancelDownload)
+          // Retransmitted bytes are not extra installed bytes.
+          progress.loaded -= received
+          await new Promise(resolve => setTimeout(resolve, 250 * 2 ** attempt))
+          if (installFailure) throw error
+          return download(entry, attempt + 1)
+        }
         if (!installFailure) {
           installFailure = { type: 'SATIN_INSTALL_FAILURE', buildId: BUILD_ID, url: entry.url,
             reason: error instanceof Error ? error.message : String(error), networkFailure, stalled }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@satinhq/kit",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.2",
   "type": "module",
   "description": "Opinionated single-target framework for agent-generated personal iOS Home Screen apps.",
   "main": "./dist/index.js",