@satinhq/kit 0.0.0-stage → 0.1.0-beta.0

package/dist/app/backgroundUpdate.js

@@ -0,0 +1,151 @@
+import { checkAppShellUpdate } from '../sw/updateCheck.js';
+/** Suspension is a safe apply boundary when the app has no unsaved edits or active media. */
+export const BACKGROUND_UPDATE_AFTER_MS = 0;
+export function hasUnsavedEditableState(root, baselines) {
+    for (const element of root.querySelectorAll('input, textarea, select, [contenteditable]')) {
+        if (element instanceof HTMLInputElement) {
+            if (element.type === 'hidden' || element.disabled)
+                continue;
+            if (element.type === 'file'
+                ? Boolean(element.files?.length)
+                : element.type === 'checkbox' || element.type === 'radio'
+                    ? element.checked !== (baselines?.checked.get(element) ?? element.defaultChecked)
+                    : element.value !== (baselines?.values.get(element) ?? element.defaultValue))
+                return true;
+        }
+        else if (element instanceof HTMLTextAreaElement) {
+            if (!element.disabled &&
+                element.value !== (baselines?.values.get(element) ?? element.defaultValue))
+                return true;
+        }
+        else if (element instanceof HTMLSelectElement) {
+            if (!element.disabled &&
+                [...element.options].some((option, index) => option.selected !==
+                    (baselines?.selected.get(element)?.[index] ?? option.defaultSelected)))
+                return true;
+        }
+        else if (element instanceof HTMLElement &&
+            element.isContentEditable &&
+            element.textContent?.trim())
+            return true;
+    }
+    return false;
+}
+/** Keep a controlled input's clean value even if React synchronizes defaultValue. */
+export function trackEditableState(root) {
+    const baselines = {
+        values: new WeakMap(),
+        checked: new WeakMap(),
+        selected: new WeakMap(),
+    };
+    const remember = (event) => {
+        const element = event.target;
+        if (element instanceof HTMLInputElement && !baselines.checked.has(element))
+            baselines.checked.set(element, element.defaultChecked);
+        if ((element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) &&
+            !baselines.values.has(element))
+            baselines.values.set(element, element.defaultValue);
+        if (element instanceof HTMLSelectElement && !baselines.selected.has(element))
+            baselines.selected.set(element, [...element.options].map(option => option.defaultSelected));
+    };
+    root.addEventListener('input', remember);
+    root.addEventListener('change', remember);
+    return {
+        hasUnsavedChanges: () => hasUnsavedEditableState(root, baselines),
+        dispose: () => {
+            root.removeEventListener('input', remember);
+            root.removeEventListener('change', remember);
+        },
+    };
+}
+export function mayApplyBackgroundUpdate(root, hasCustomUnsavedChanges, hiddenForMs, mediaActive = false) {
+    return (document.hidden &&
+        hiddenForMs >= BACKGROUND_UPDATE_AFTER_MS &&
+        !mediaActive &&
+        !hasCustomUnsavedChanges &&
+        !hasUnsavedEditableState(root));
+}
+/** Download while runnable; activation remains the caller's safe-boundary decision.
+ * Launch, return to the foreground and reconnect each check at once; this interval only
+ * covers a long visible session, so it is kept slow to spare network and battery. */
+export const FOREGROUND_UPDATE_CHECK_MS = 5 * 60_000;
+const UPDATE_CHECK_BUDGET_MS = 10_000;
+export function watchBackgroundUpdates(scope, onInstalled) {
+    let disposed = false;
+    let checking = false;
+    let checkGeneration = 0;
+    let checkTimer;
+    let registration;
+    let observed = null;
+    const inspect = () => {
+        if (disposed || !registration)
+            return;
+        const installing = registration.installing;
+        if (installing !== observed) {
+            observed?.removeEventListener('statechange', inspect);
+            observed = installing;
+            observed?.addEventListener('statechange', inspect);
+        }
+        if (registration.waiting)
+            onInstalled();
+    };
+    const check = async () => {
+        if (disposed || checking || !navigator.serviceWorker)
+            return;
+        checking = true;
+        const generation = ++checkGeneration;
+        clearTimeout(checkTimer);
+        // WebKit may leave an update promise unsettled. A later check can retry;
+        // the old operation cannot overwrite a newer registration observation.
+        checkTimer = setTimeout(() => {
+            if (generation === checkGeneration)
+                checking = false;
+        }, UPDATE_CHECK_BUDGET_MS);
+        try {
+            const found = await navigator.serviceWorker.getRegistration(scope);
+            if (disposed || generation !== checkGeneration || !found)
+                return;
+            if (found !== registration) {
+                registration?.removeEventListener('updatefound', inspect);
+                registration = found;
+                registration.addEventListener('updatefound', inspect);
+            }
+            inspect();
+            if (!registration.waiting && navigator.onLine !== false)
+                await checkAppShellUpdate(registration);
+            if (generation === checkGeneration)
+                inspect();
+        }
+        catch {
+            // Offline and failed installs leave the cached version usable.
+        }
+        finally {
+            if (generation === checkGeneration) {
+                clearTimeout(checkTimer);
+                checking = false;
+            }
+        }
+    };
+    const visibilityChanged = () => {
+        void check();
+    };
+    const pageHidden = () => void check();
+    document.addEventListener('visibilitychange', visibilityChanged);
+    window.addEventListener('pagehide', pageHidden);
+    const foregroundTimer = setInterval(() => {
+        if (!document.hidden)
+            void check();
+    }, FOREGROUND_UPDATE_CHECK_MS);
+    window.addEventListener('online', pageHidden);
+    visibilityChanged();
+    return () => {
+        disposed = true;
+        clearTimeout(checkTimer);
+        clearInterval(foregroundTimer);
+        window.removeEventListener('online', pageHidden);
+        document.removeEventListener('visibilitychange', visibilityChanged);
+        window.removeEventListener('pagehide', pageHidden);
+        registration?.removeEventListener('updatefound', inspect);
+        observed?.removeEventListener('statechange', inspect);
+    };
+}

package/dist/app/buildInfo.d.ts

@@ -0,0 +1,11 @@
+/** Identity embedded in the running app's JavaScript bundle. The app build ID is
+ * a unique build identifier, not a git revision or the service worker's cache hash. */
+export type BuildInfo = Readonly<{
+    frameworkVersion: string;
+    appBuildId: string;
+    builtAt: string | null;
+    buildKind: 'development' | 'production' | 'unavailable';
+}>;
+/** The build loaded by this app, including offline launches. Metadata comes from
+ * satinApp at build time; it never reads the server's latest deployment. */
+export declare function useBuildInfo(): BuildInfo;

package/dist/app/buildInfo.js

@@ -0,0 +1,12 @@
+const buildInfo = Object.freeze(import.meta.env
+    ?.SATIN_BUILD_INFO ?? {
+    frameworkVersion: 'unavailable',
+    appBuildId: 'unavailable',
+    builtAt: null,
+    buildKind: 'unavailable',
+});
+/** The build loaded by this app, including offline launches. Metadata comes from
+ * satinApp at build time; it never reads the server's latest deployment. */
+export function useBuildInfo() {
+    return buildInfo;
+}

package/dist/app/buildInfoBuild.d.ts

@@ -0,0 +1,3 @@
+import type { BuildInfo } from './buildInfo.js';
+/** One identity per Vite invocation, shared by every chunk of that app build. */
+export declare function createBuildInfo(command: 'build' | 'serve'): BuildInfo;

package/dist/app/buildInfoBuild.js

@@ -0,0 +1,12 @@
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+/** One identity per Vite invocation, shared by every chunk of that app build. */
+export function createBuildInfo(command) {
+    const framework = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+    return {
+        frameworkVersion: framework.version,
+        appBuildId: randomUUID().replaceAll('-', ''),
+        builtAt: new Date().toISOString(),
+        buildKind: command === 'build' ? 'production' : 'development',
+    };
+}

package/dist/app/checkCli.d.ts

@@ -0,0 +1 @@
+export declare function runDeployCheck(input: string, requestTimeoutMs?: number): Promise<0 | 1>;

package/dist/app/checkCli.js

@@ -0,0 +1,73 @@
+import sharp from 'sharp';
+import { checkMediaDeployment } from './mediaCheck.js';
+import { checkDeployment } from './deployment.js';
+import { appManifestPaths } from './manifests.js';
+export async function runDeployCheck(input, requestTimeoutMs = 30_000) {
+    const url = new URL(input);
+    if (url.protocol !== 'https:' &&
+        !(url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))) {
+        throw new Error(`HTTPS is required: ${url.href}`);
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), requestTimeoutMs);
+    let response;
+    let html;
+    try {
+        response = await fetch(url, { signal: controller.signal, cache: 'no-store' });
+        html = await response.text();
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            throw new Error(`Page did not finish within ${requestTimeoutMs / 1000} s\n  URL: ${url.href}\n  Fix: Check the server or connection, then try again.`);
+        }
+        throw new Error(`Server could not be reached\n  URL: ${url.href}\n  Fix: Start the server and check the URL and connection, then try again.`, { cause: error });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (response.status !== 200)
+        throw new Error(`Page HTTP ${response.status}: ${url.href}`);
+    if ((response.headers.get('content-type') ?? '').split(';')[0].trim().toLowerCase() !== 'text/html')
+        throw new Error(`Expected app HTML: ${url.href}`);
+    const metadata = html.match(/<script id="satin-deployment" type="application\/json">([^<]+)<\/script>/);
+    if (!metadata)
+        throw new Error(`Missing Satin deployment metadata: ${url.href}. Rebuild with the current Satin plugin.`);
+    const apps = JSON.parse(metadata[1]);
+    if (!Array.isArray(apps) || !apps.length)
+        throw new Error('Invalid deployment metadata.');
+    const finalPage = new URL(response.url || url.href);
+    const directoryPath = (pathname) => pathname.replace(/\/index\.html$/, '/').replace(/\/$/, '');
+    if (finalPage.origin !== url.origin ||
+        directoryPath(finalPage.pathname) !== directoryPath(url.pathname) ||
+        finalPage.search !== url.search)
+        throw new Error(`Page redirected to ${finalPage.href}`);
+    const path = directoryPath(finalPage.pathname);
+    for (const app of apps) {
+        const manifests = appManifestPaths(app, app.base);
+        const actual = Array.isArray(app.manifests) ? app.manifests : [];
+        const missing = manifests.filter(path => !actual.includes(path));
+        const unexpected = actual.filter(path => !manifests.includes(path));
+        if (missing.length || unexpected.length || new Set(actual).size !== actual.length) {
+            throw new Error(`Manifest inventory does not match this build for ${app.id}.\n  Missing: ${missing.join(', ') || 'none'}\n  Unexpected: ${unexpected.join(', ') || 'none'}\n  Fix: Rebuild and deploy the complete dist directory, including every idiom and appearance manifest.`);
+        }
+        const validPaths = [app.base, app.installRoute, app.scope, app.start_url].map(value => directoryPath(new URL(value, finalPage).pathname));
+        if (!validPaths.includes(path))
+            throw new Error(`Built for ${app.base} but checked at ${url.pathname}. Rebuild with matching Vite base or serve at ${app.base}.`);
+    }
+    const failures = (await Promise.all(apps.map(app => checkDeployment(app, finalPage.href, fetch, true, async (bytes) => {
+        await sharp(bytes, { limitInputPixels: 16_777_216 }).raw().toBuffer();
+    }, requestTimeoutMs, async (inventory, entries) => {
+        const media = await checkMediaDeployment(inventory, entries, finalPage.href, requestTimeoutMs, app.base);
+        if (!media.failures.length)
+            console.log(media.applicable
+                ? 'PASS media transport: bytes=0-1 returned matching 206 headers and bytes.'
+                : 'NOT APPLICABLE media transport: no bundled probe. Remote-only media needs satinApp(app, { mediaProbe: "media/probe.m4a" }) with an emitted local probe; the remote source remains unverified.');
+        return media.failures;
+    })))).flat();
+    for (const failure of failures)
+        console.error(`FAIL ${failure.reason}\n  URL: ${failure.url}\n  Fix: ${failure.fix}`);
+    if (failures.length)
+        return 1;
+    console.log(`PASS ${apps.length} app(s): manifests, install route, start_url, icons, worker and every precache entry.`);
+    return 0;
+}

package/dist/app/coldLaunchUpdate.d.ts

@@ -0,0 +1,14 @@
+import type { DownloadProgress } from './launchScreen.js';
+export declare const COLD_LAUNCH_UPDATE_BUDGET_MS = 800;
+/** The previous and current build identifiers after an app update. */
+export interface JustUpdated {
+    readonly previous: string | null;
+    readonly current: string | null;
+}
+export declare function consumeJustUpdated(scope: string): JustUpdated | null;
+/** Optional downloads stay silent until a safe document replacement is committed. */
+export declare function prepareColdLaunchUpdate(scope: string, onProgress: (progress: DownloadProgress | null) => void, options?: {
+    readonly background?: boolean;
+    readonly foreground?: boolean;
+    readonly canActivate?: () => boolean;
+}): Promise<'current' | 'reloading'>;

package/dist/app/coldLaunchUpdate.js

@@ -0,0 +1,384 @@
+import { APP_SHELL_APPLY_BACKGROUND_UPDATE, APP_SHELL_APPLY_COLD_UPDATE, APP_SHELL_BUILD_ID_REQUEST, APP_SHELL_BUILD_ID_RESPONSE, APP_SHELL_COLD_UPDATE_DENIED, APP_SHELL_VERSION_FILE, } from '../sw/protocol.js';
+export const COLD_LAUNCH_UPDATE_BUDGET_MS = 800;
+const ACTIVATION_BUDGET_MS = 3_000;
+const UPDATED_KEY = 'satin:just-updated:v1:';
+// The notification is consumable; permission to reload is not. A new process
+// gets a fresh document, while the reload successor burns this document latch.
+const launchFuses = new WeakMap();
+// WebKit can defer a hidden reload. Until navigation commits, this document
+// must retain its successor's marker and refuse another replacement request.
+const pendingReloads = new WeakMap();
+function reloadUpdatedDocument(scope) {
+    let scopes = pendingReloads.get(window);
+    if (!scopes) {
+        scopes = new Set();
+        pendingReloads.set(window, scopes);
+    }
+    scopes.add(scope);
+    window.location.reload();
+}
+// A claim can finish after the app returns to foreground. Keep the document's
+// original bundle identity so its next suspension can complete that reload.
+const documentWorkers = new WeakMap();
+function launchFuse() {
+    let scopes = launchFuses.get(window);
+    if (!scopes) {
+        scopes = new Set();
+        launchFuses.set(window, scopes);
+    }
+    return scopes;
+}
+function readBuildId(worker) {
+    if (!worker)
+        return Promise.resolve(null);
+    return new Promise(resolve => {
+        const channel = new MessageChannel();
+        let finished = false;
+        const finish = (id) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            channel.port1.close();
+            resolve(id);
+        };
+        const timer = setTimeout(() => finish(null), 200);
+        channel.port1.onmessage = event => {
+            const data = event.data;
+            if (data?.type === APP_SHELL_BUILD_ID_RESPONSE && typeof data.buildId === 'string')
+                finish(data.buildId);
+        };
+        try {
+            worker.postMessage({ type: APP_SHELL_BUILD_ID_REQUEST }, [channel.port2]);
+        }
+        catch {
+            finish(null);
+        }
+    });
+}
+function persistUpdated(scope, updated) {
+    try {
+        // New documents own the ring. Older deployed clients omit ringStart after
+        // completing their old-document ring; the successor preserves that full arc.
+        sessionStorage.setItem(UPDATED_KEY + scope, JSON.stringify({ at: Date.now(), ...updated, ringStart: 0 }));
+        return Boolean(sessionStorage.getItem(UPDATED_KEY + scope));
+    }
+    catch {
+        return false;
+    }
+}
+export function consumeJustUpdated(scope) {
+    try {
+        const key = UPDATED_KEY + scope;
+        const raw = sessionStorage.getItem(key);
+        sessionStorage.removeItem(key);
+        if (!raw)
+            return null;
+        const value = JSON.parse(raw);
+        if (typeof value !== 'object' ||
+            !value ||
+            !('at' in value) ||
+            typeof value.at !== 'number' ||
+            !Number.isFinite(value.at))
+            return null;
+        if (!('previous' in value) || !('current' in value))
+            return null;
+        if (value.previous !== null && typeof value.previous !== 'string')
+            return null;
+        if (value.current !== null && typeof value.current !== 'string')
+            return null;
+        launchFuse().add(scope);
+        return { previous: value.previous, current: value.current };
+    }
+    catch {
+        return null;
+    }
+}
+/** Optional downloads stay silent until a safe document replacement is committed. */
+export async function prepareColdLaunchUpdate(scope, onProgress, options = {}) {
+    const started = performance.now();
+    // Diagnostic sessions opt in before the update check begins.
+    const tracing = globalThis.__SATIN_LAUNCH_UPDATE_TRACE__ ===
+        true;
+    const trace = (reason) => {
+        if (!tracing)
+            return;
+        performance.mark('satin-launch-update', {
+            detail: {
+                reason,
+                elapsedMs: performance.now() - started,
+                background: Boolean(options.background),
+                foreground: Boolean(options.foreground),
+            },
+        });
+    };
+    const current = (reason) => {
+        trace(reason);
+        return 'current';
+    };
+    trace('start');
+    if (pendingReloads.get(window)?.has(scope))
+        return 'reloading';
+    const resume = options.background || options.foreground;
+    if (!resume && launchFuse().has(scope))
+        return current('launch-fuse');
+    if (!('serviceWorker' in navigator))
+        return current('offline-or-unavailable');
+    const workers = navigator.serviceWorker;
+    // The first connected installation has no old controlled document to replace.
+    if (!workers.controller)
+        return current('uncontrolled');
+    let scopedDocuments = documentWorkers.get(window);
+    if (!scopedDocuments) {
+        scopedDocuments = new Map();
+        documentWorkers.set(window, scopedDocuments);
+    }
+    let documentWorker = scopedDocuments.get(scope);
+    if (!documentWorker) {
+        documentWorker = { worker: workers.controller, buildId: readBuildId(workers.controller) };
+        scopedDocuments.set(scope, documentWorker);
+    }
+    if (resume && workers.controller !== documentWorker.worker) {
+        if (options.canActivate && !options.canActivate())
+            return current('activation-no-longer-safe');
+        const [previous, currentBuild] = await Promise.all([
+            documentWorker.buildId,
+            readBuildId(workers.controller),
+        ]);
+        if (options.canActivate && !options.canActivate())
+            return current('activation-no-longer-safe');
+        if (!persistUpdated(scope, { previous, current: currentBuild }))
+            return current('reload-fuse-unavailable');
+        if (options.canActivate && !options.canActivate())
+            return current('activation-no-longer-safe');
+        trace(options.background ? 'claimed-background-reload' : 'claimed-foreground-reload');
+        reloadUpdatedDocument(scope);
+        return 'reloading';
+    }
+    const checkStarted = started;
+    let lookupReason = 'no-registration';
+    let lookupTimer;
+    const registration = await Promise.race([
+        workers.getRegistration(scope).catch(() => {
+            lookupReason = 'registration-error';
+            return undefined;
+        }),
+        new Promise(resolve => {
+            lookupTimer = setTimeout(() => {
+                lookupReason = 'lookup-budget';
+                resolve(undefined);
+            }, COLD_LAUNCH_UPDATE_BUDGET_MS);
+        }),
+    ]);
+    clearTimeout(lookupTimer);
+    if (!registration)
+        return current(lookupReason);
+    if (!registration.active)
+        return current('no-active-worker');
+    if (registration.active.state !== 'activated')
+        return current('active-not-ready');
+    if (navigator.onLine === false && !registration.waiting)
+        return current('offline');
+    const remainingCheckMs = Math.max(0, COLD_LAUNCH_UPDATE_BUDGET_MS - (performance.now() - checkStarted));
+    if (!registration.waiting && !registration.installing && remainingCheckMs === 0)
+        return current('lookup-budget');
+    return new Promise(resolve => {
+        let finished = false;
+        let downloading = false;
+        let discovered = false;
+        const discovery = new AbortController();
+        let activating = false;
+        let activationTarget = null;
+        let observed = null;
+        let checkTimer;
+        let activationTimer;
+        const previousId = documentWorker.buildId;
+        const cleanup = () => {
+            clearTimeout(checkTimer);
+            clearTimeout(activationTimer);
+            discovery.abort();
+            registration.removeEventListener('updatefound', inspect);
+            observed?.removeEventListener('statechange', inspect);
+            workers.removeEventListener('message', receive);
+            workers.removeEventListener('controllerchange', changed);
+        };
+        const finish = (result, reason) => {
+            if (finished)
+                return;
+            finished = true;
+            trace(reason);
+            cleanup();
+            if (result === 'current') {
+                if (!resume && activating && workers.controller !== activationTarget)
+                    launchFuse().delete(scope);
+                onProgress(null);
+            }
+            resolve(result);
+        };
+        const changed = async () => {
+            if (finished)
+                return;
+            trace('controllerchange');
+            const [previous, current] = await Promise.all([previousId, readBuildId(workers.controller)]);
+            if (finished)
+                return;
+            if (options.canActivate && !options.canActivate()) {
+                finish('current', 'activation-no-longer-safe');
+                return;
+            }
+            // Refuse a reload unless its successor can read the fuse. Without storage,
+            // claim is still safe, but the current document must remain in place.
+            if (!persistUpdated(scope, { previous, current })) {
+                finish('current', 'reload-fuse-unavailable');
+                return;
+            }
+            // The successor confirms the update. Keep this document's cover unchanged
+            // through reload instead of playing a second ring before replacement.
+            clearTimeout(activationTimer);
+            if (options.canActivate && !options.canActivate()) {
+                finish('current', 'activation-no-longer-safe');
+                return;
+            }
+            finish('reloading', 'reload');
+            reloadUpdatedDocument(scope);
+        };
+        const activate = async (worker) => {
+            if (finished || activating)
+                return;
+            if (!resume && launchFuse().has(scope)) {
+                finish('current', 'launch-fuse');
+                return;
+            }
+            if (options.canActivate && !options.canActivate()) {
+                finish('current', 'activation-no-longer-safe');
+                return;
+            }
+            trace('activation-request');
+            activating = true;
+            if (!resume)
+                launchFuse().add(scope);
+            activationTarget = worker;
+            clearTimeout(checkTimer);
+            // Keep the cover through the document reload.
+            activationTimer = setTimeout(() => finish('current', 'activation-budget'), ACTIVATION_BUDGET_MS);
+            const previousBuildId = await previousId;
+            if (finished)
+                return;
+            if (options.canActivate && !options.canActivate()) {
+                finish('current', 'activation-no-longer-safe');
+                return;
+            }
+            workers.addEventListener('controllerchange', changed);
+            try {
+                worker.postMessage({
+                    previousBuildId,
+                    type: options.background
+                        ? APP_SHELL_APPLY_BACKGROUND_UPDATE
+                        : APP_SHELL_APPLY_COLD_UPDATE,
+                });
+            }
+            catch {
+                finish('current', 'post-message-error');
+            }
+        };
+        const receive = (event) => {
+            if (finished)
+                return;
+            if (event.data?.type === APP_SHELL_COLD_UPDATE_DENIED && event.source === activationTarget) {
+                finish('current', 'activation-denied');
+                return;
+            }
+        };
+        const inspect = () => {
+            // Activation empties waiting/installing before clients.claim() changes
+            // the controller. Only controllerchange (or its budget) ends this phase.
+            if (finished || activating)
+                return;
+            const waiting = registration.waiting;
+            if (waiting) {
+                void activate(waiting);
+                return;
+            }
+            const installing = registration.installing;
+            if (!installing) {
+                if (downloading)
+                    finish('current', observed?.state === 'redundant' ? 'install-redundant' : 'installing-disappeared');
+                return;
+            }
+            if (installing.state === 'redundant') {
+                finish('current', 'install-redundant');
+                return;
+            }
+            if (installing !== observed) {
+                observed?.removeEventListener('statechange', inspect);
+                observed = installing;
+                observed.addEventListener('statechange', inspect);
+                try {
+                    observed.postMessage?.({ type: 'SATIN_DOWNLOAD_PROGRESS_REQUEST' });
+                }
+                catch {
+                    finish('current', 'progress-request-error');
+                    return;
+                }
+            }
+            if (!downloading) {
+                trace('download-start');
+                downloading = true;
+            }
+        };
+        workers.addEventListener('message', receive);
+        registration.addEventListener('updatefound', inspect);
+        checkTimer = setTimeout(() => finish('current', 'check-budget'), remainingCheckMs);
+        inspect();
+        if (navigator.onLine !== false &&
+            !downloading &&
+            !activating &&
+            !registration.waiting &&
+            !finished) {
+            // WebKit can fetch sw.js immediately but publish installing >1s later.
+            // A small generated network-only hint discovers that new build within
+            // the same check budget. It never authorizes activation or fabricates
+            // byte progress: the real install must still finish successfully.
+            void Promise.all([
+                previousId,
+                fetch(scope + APP_SHELL_VERSION_FILE, { cache: 'no-store', signal: discovery.signal })
+                    .then(async (response) => (response.ok ? (await response.json()) : null))
+                    .catch(() => null),
+            ]).then(([currentId, version]) => {
+                if (finished ||
+                    activating ||
+                    downloading ||
+                    !currentId ||
+                    !version ||
+                    typeof version !== 'object' ||
+                    !('format' in version) ||
+                    version.format !== 1 ||
+                    !('buildId' in version) ||
+                    typeof version.buildId !== 'string' ||
+                    !version.buildId ||
+                    version.buildId === currentId)
+                    return;
+                discovered = true;
+                trace('version-discovered');
+            });
+            // WebKit may settle update() after installation. updatefound, not that
+            // promise, moves the gate into the download state.
+            try {
+                void checkAppShellUpdate(registration).then(() => {
+                    if (!finished && !downloading && !activating) {
+                        inspect();
+                        if (!downloading && !activating && !discovered)
+                            finish('current', 'check-complete');
+                    }
+                }, () => {
+                    if (!activating)
+                        finish('current', 'check-error');
+                });
+            }
+            catch {
+                finish('current', 'check-error');
+            }
+        }
+    });
+}
+import { checkAppShellUpdate } from '../sw/updateCheck.js';