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

package/dist/actions/types.js

@@ -0,0 +1,28 @@
+export function actionItems(actions, inheritedDisabled = false) {
+    return actions.flatMap(action => 'section' in action
+        ? actionItems(action.section, inheritedDisabled)
+        : 'submenu' in action
+            ? actionItems(action.submenu, inheritedDisabled || !!action.disabled)
+            : [inheritedDisabled ? { ...action, disabled: true } : action]);
+}
+export function contextDefinition(value) {
+    return 'actions' in value ? value : { actions: value };
+}
+/** Resolve each edge once, using a single configuration shape. */
+export function swipeEdge(value, edge) {
+    if (!value)
+        return { actions: [], allowsFullSwipe: true, shape: undefined };
+    if ('actions' in value) {
+        return {
+            actions: (value.edge ?? 'trailing') === edge ? actionItems(value.actions) : [],
+            allowsFullSwipe: value.allowsFullSwipe !== false,
+            shape: value.shape,
+        };
+    }
+    const configuration = value.find(item => (item.edge ?? 'trailing') === edge);
+    return {
+        actions: actionItems(configuration?.actions ?? []),
+        allowsFullSwipe: configuration?.allowsFullSwipe !== false,
+        shape: configuration?.shape,
+    };
+}

package/dist/app/InstallComponents.d.ts

@@ -0,0 +1,16 @@
+import { type InstallContext } from './installContext.js';
+/**
+ * Optional building blocks for a custom install page (public through `@satinhq/kit/install`): the
+ * context hook, the steps list and the tip, with the default page's words and look. Styles
+ * are scoped to `satin-` classes; `--satin-install-tint` overrides the app's tint.
+ */
+/** The install context, read once on the page (it does not change while the page is open). */
+export declare function useInstallContext(): InstallContext;
+/** The three steps, in the words of Satin's page, for this device, browser and Safari layout. */
+export declare function InstallSteps(): import("react").JSX.Element;
+/**
+ * The tip at Safari's real control ("Page Menu, then Share" or "Share"), in Satin's glass.
+ * Shown only in Safari 27 on an iPhone or iPad, where the control's place was measured;
+ * renders nothing anywhere else. Its glass takes the page's background colour.
+ */
+export declare function InstallTip(): import("react").JSX.Element | null;

package/dist/app/InstallComponents.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { installSteps } from './installPolicy.js';
+import { useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { GLYPHS, INSTALL_STRINGS, springEasing } from './installStrings.js';
+import { deviceTokens } from './installExperienceDevice.js';
+import { TIP_GLASS } from './installExperienceHome.js';
+import { readInstallContext } from './installContext.js';
+import { classifySafariBar, tipPath } from './installTipPath.js';
+/**
+ * Optional building blocks for a custom install page (public through `@satinhq/kit/install`): the
+ * context hook, the steps list and the tip, with the default page's words and look. Styles
+ * are scoped to `satin-` classes; `--satin-install-tint` overrides the app's tint.
+ */
+/** The install context, read once on the page (it does not change while the page is open). */
+export function useInstallContext() {
+    const [context] = useState(readInstallContext);
+    return context;
+}
+function useSafariBar(context) {
+    const [bar, setBar] = useState('unknown');
+    useLayoutEffect(() => {
+        const update = () => setBar(classifySafariBar(context.safariVersion, context.device));
+        update();
+        addEventListener('resize', update);
+        return () => removeEventListener('resize', update);
+    }, [context.safariVersion, context.device]);
+    return bar;
+}
+const glyph = (name, className) => (_jsx("svg", { className: className, viewBox: "0 0 24 24", "aria-hidden": "true", dangerouslySetInnerHTML: { __html: GLYPHS[name] } }));
+const STEPS_CSS = `
+.satin-steps{list-style:none;margin:0;padding:0;border-radius:22px;background:color-mix(in srgb,currentColor 5%,transparent);text-align:start;--sym:36px;--tint:var(--satin-install-tint,var(--satin-app-tint))}
+.satin-steps li{display:grid;grid-template-columns:var(--sym) 1fr;column-gap:12px;align-items:center;min-height:60px;box-sizing:border-box;padding:10px 16px 10px 14px;position:relative}
+.satin-steps li:not(:has(span span)){min-height:52px;padding-block:8px}
+.satin-steps li+li::before{content:"";position:absolute;top:0;inset-inline:calc(var(--sym) + 26px) 0;height:.5px;background:color-mix(in srgb,currentColor 14%,transparent)}
+.satin-steps-sym{display:grid;place-items:center;width:var(--sym);height:var(--sym);border-radius:calc(var(--sym)*.27);background:color-mix(in srgb,var(--tint) 15%,transparent);color:var(--tint)}
+.satin-steps-g{width:22px;height:22px;fill:none;stroke:currentColor;stroke-width:1.9;stroke-linecap:round;stroke-linejoin:round}
+.satin-steps b{display:block;font-size:17px;font-weight:600;line-height:1.294}
+.satin-steps span span{display:block;opacity:.6;font-size:15px;line-height:1.33}
+`;
+function useStyle(id, css) {
+    useLayoutEffect(() => {
+        if (document.getElementById(id))
+            return;
+        const style = document.createElement('style');
+        style.id = id;
+        style.textContent = css;
+        document.head.append(style);
+    }, [id, css]);
+}
+function useAppTint(context) {
+    useLayoutEffect(() => {
+        document.documentElement.style.setProperty('--satin-app-tint', context.app.tint);
+    }, [context.app.tint]);
+}
+/** The three steps, in the words of Satin's page, for this device, browser and Safari layout. */
+export function InstallSteps() {
+    const context = useInstallContext();
+    const bar = useSafariBar(context);
+    useStyle('satin-steps-style', STEPS_CSS);
+    useAppTint(context);
+    const rows = installSteps(context.browser, bar, INSTALL_STRINGS);
+    return (_jsx("ol", { className: "satin-steps", role: "list", children: rows.map(({ symbol, action, where }) => (_jsxs("li", { children: [_jsx("span", { className: "satin-steps-sym", children: glyph(symbol, 'satin-steps-g') }), _jsxs("span", { children: [_jsx("b", { children: action }), where && _jsx("span", { children: where })] })] }, action))) }));
+}
+const TIP_CSS = `
+.satin-tip{position:fixed;z-index:2;left:9px;bottom:13px;display:flex;align-items:center;min-height:42px;box-sizing:border-box;padding:0 15px;font:600 15px/20px system-ui,-apple-system,sans-serif;white-space:nowrap;--tint:var(--satin-install-tint,var(--satin-app-tint));--zero:0;--one:1;--label:#000;transform-origin:105px calc(100% + 11px);animation:satin-tip .45s .3s ${springEasing()} both;color:var(--label);${deviceTokens(false)}}
+@media(prefers-color-scheme:dark){.satin-tip{--label:#fff;${deviceTokens(true)}}}
+@keyframes satin-tip{from{transform:scale(.2);opacity:0;filter:blur(4px)}}
+@media(prefers-reduced-motion:reduce){.satin-tip{animation:none}}
+.satin-tip[data-bar=toolbar]{right:16px;width:fit-content;margin:0 auto;transform-origin:50% calc(100% + 11px)}
+.satin-tip[data-bar=top]{left:auto;right:calc(env(safe-area-inset-right) + 78px);bottom:auto;top:12px;transform-origin:calc(100% - 42px) -11px}
+.satin-tip .ix-glass{position:absolute;inset:0;z-index:-1;width:100%;height:100%;overflow:visible}
+.satin-tip .ix-glass-fill{fill:var(--glass)}.satin-tip .ix-glass-band{stroke:var(--glass-band)}
+.satin-tip .ix-glass-line{opacity:var(--hl-line)}.satin-tip .ix-glass-soft{opacity:var(--hl-soft)}
+.satin-tip-g{flex:none;width:32px;height:32px;margin:-6px 3.5px -6px -6.6px;color:var(--tint);fill:none;stroke:currentColor;stroke-width:1.4;stroke-linecap:round;stroke-linejoin:round}
+`;
+/**
+ * The tip at Safari's real control ("Page Menu, then Share" or "Share"), in Satin's glass.
+ * Shown only in Safari 27 on an iPhone or iPad, where the control's place was measured;
+ * renders nothing anywhere else. Its glass takes the page's background colour.
+ */
+export function InstallTip() {
+    const context = useInstallContext();
+    const bar = useSafariBar(context);
+    const tip = useRef(null);
+    useStyle('satin-tip-style', TIP_CSS);
+    useAppTint(context);
+    useEffect(() => {
+        const element = tip.current;
+        if (!element || bar === 'unknown')
+            return;
+        element.style.setProperty('--bg', getComputedStyle(document.documentElement).backgroundColor);
+        const draw = () => element
+            .querySelector('#ix-shape')
+            ?.setAttribute('d', tipPath(element.offsetWidth, element.offsetHeight, bar));
+        draw();
+        const observer = new ResizeObserver(draw);
+        observer.observe(element);
+        return () => observer.disconnect();
+    }, [bar]);
+    if (bar === 'unknown' || context.browser !== 'safari')
+        return null;
+    const compact = bar === 'compact';
+    return (_jsxs("div", { ref: tip, className: "satin-tip", "data-bar": bar, "aria-hidden": "true", children: [_jsx("span", { dangerouslySetInnerHTML: { __html: TIP_GLASS }, style: { display: 'contents' } }), glyph(compact ? 'menu' : 'share', 'satin-tip-g'), compact ? INSTALL_STRINGS.tipMenu : INSTALL_STRINGS.tipShare] }));
+}

package/dist/app/InstallationDiagnostics.d.ts

@@ -0,0 +1,7 @@
+export { readInstallationFailure, type InstallationFailure } from './installationFailure.js';
+/** The app scope whose installation receipts are shown. */
+export type InstallationDiagnosticsProps = {
+    scope: string;
+};
+/** Installation receipts for an optional Settings diagnostics screen. Use the app's scope. */
+export declare function InstallationDiagnostics({ scope }: InstallationDiagnosticsProps): import("react").JSX.Element;

package/dist/app/InstallationDiagnostics.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { NavigationRow, Section, ValueRow } from '../list-form/ListForm.js';
+import { readInstallationFailure, readInstallationSuccess } from './installationFailure.js';
+export { readInstallationFailure } from './installationFailure.js';
+/** Installation receipts for an optional Settings diagnostics screen. Use the app's scope. */
+export function InstallationDiagnostics({ scope }) {
+    const [failure, setFailure] = useState(() => readInstallationFailure(scope));
+    const [success, setSuccess] = useState(() => readInstallationSuccess(scope));
+    const [expanded, setExpanded] = useState(false);
+    useEffect(() => {
+        const refresh = () => {
+            setFailure(readInstallationFailure(scope));
+            setSuccess(readInstallationSuccess(scope));
+        };
+        refresh();
+        window.addEventListener('satin-install-diagnostics', refresh);
+        return () => window.removeEventListener('satin-install-diagnostics', refresh);
+    }, [scope]);
+    return (_jsxs(Section, { header: "Settings", children: [_jsx(NavigationRow, { onPress: () => setExpanded(value => !value), accessibilityLabel: "Diagnostics", label: "Diagnostics" }), expanded && _jsx(ValueRow, { label: "Last installation", value: failure ? 'Failed' : 'Ready' }), expanded && (failure || success) && (_jsx(ValueRow, { label: "Build", value: (failure ?? success).buildId })), expanded && failure && _jsx(ValueRow, { label: "Resource", value: failure.url }), expanded && failure && _jsx(ValueRow, { label: "Reason", value: failure.reason }), expanded && failure && (_jsx(ValueRow, { label: "Fix", value: failure.networkFailure
+                    ? 'Check your connection and try again.'
+                    : 'Deploy the complete matching build, then retry.' }))] }));
+}

package/dist/app/OrientationGuard.d.ts

@@ -0,0 +1,8 @@
+import type { PropsWithChildren } from 'react';
+import type { AppDefinition } from './definition.js';
+/** A fallback, never a screen-orientation lock. Geometry is supplied by SatinRoot. */
+export declare function OrientationGuard({ app, width, height, children, }: PropsWithChildren<{
+    app: AppDefinition;
+    width: number;
+    height: number;
+}>): import("react").JSX.Element;

package/dist/app/OrientationGuard.js

@@ -0,0 +1,9 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { readDeviceIdiom } from '../layout/deviceIdiom.js';
+/** A fallback, never a screen-orientation lock. Geometry is supplied by SatinRoot. */
+export function OrientationGuard({ app, width, height, children, }) {
+    const policy = readDeviceIdiom() === 'pad' ? (app.orientations.ipad ?? app.orientations) : app.orientations;
+    const unsupported = policy.fallback !== 'responsive' &&
+        !policy.supported.includes(width > height ? 'landscape' : 'portrait');
+    return (_jsxs(_Fragment, { children: [_jsx("div", { style: { display: 'contents' }, inert: unsupported ? true : undefined, children: children }), unsupported && (_jsx("section", { "data-satin-orientation-fallback": "true", role: "status", children: "Rotate your device to continue." }))] }));
+}

package/dist/app/appearance.d.ts

@@ -0,0 +1,18 @@
+import { type PreferredColorScheme } from './appearanceStore.js';
+export declare const readDarkAppearance: () => boolean;
+export declare const subscribeAppearance: (listener: () => void) => () => void;
+export declare function useDarkAppearance(): boolean;
+/** Bounded trait and lifecycle log for installed-runtime resume diagnostics. */
+export declare const readAppearanceDiagnostics: () => readonly Readonly<{
+    at: number;
+    event: string;
+    state: string;
+    hidden: boolean;
+    queryDark: boolean;
+    eventDark?: boolean;
+    heldDark: boolean;
+}>[];
+/** Set this installed scene's appearance. System or null resumes the retained system trait.
+ * Store a user's choice with useAppStorage; the override itself lasts for this document. */
+export declare function preferredColorScheme(scheme: PreferredColorScheme): void;
+export type { PreferredColorScheme };

package/dist/app/appearance.js

@@ -0,0 +1,15 @@
+import { useSyncExternalStore } from 'react';
+import { installAppearanceStore } from './appearanceStore.js';
+const store = () => installAppearanceStore();
+export const readDarkAppearance = () => store().getSnapshot().dark;
+export const subscribeAppearance = (listener) => store().subscribe(listener);
+export function useDarkAppearance() {
+    return useSyncExternalStore(subscribeAppearance, readDarkAppearance, () => false);
+}
+/** Bounded trait and lifecycle log for installed-runtime resume diagnostics. */
+export const readAppearanceDiagnostics = () => store().getDiagnostics();
+/** Set this installed scene's appearance. System or null resumes the retained system trait.
+ * Store a user's choice with useAppStorage; the override itself lasts for this document. */
+export function preferredColorScheme(scheme) {
+    store().setPreferredColorScheme(scheme);
+}

package/dist/app/appearanceStore.d.ts

@@ -0,0 +1,30 @@
+/** `preferredColorScheme`: a whole-scene appearance override, or system appearance. */
+export type PreferredColorScheme = 'light' | 'dark' | 'system' | null;
+export type AppearanceSnapshot = Readonly<{
+    dark: boolean;
+    pending: boolean;
+}>;
+/** A diagnostic appearance event and its observed state. */
+export type AppearanceEvent = Readonly<{
+    at: number;
+    event: string;
+    state: string;
+    hidden: boolean;
+    queryDark: boolean;
+    eventDark?: boolean;
+    heldDark: boolean;
+}>;
+export type AppearanceStore = {
+    setPreferredColorScheme(scheme: PreferredColorScheme): void;
+    getDiagnostics(): readonly AppearanceEvent[];
+    getSnapshot(): AppearanceSnapshot;
+    subscribe(listener: () => void): () => void;
+};
+declare global {
+    interface Window {
+        __SATIN_APPEARANCE__?: AppearanceStore;
+    }
+}
+/** Shared by the generated head and React. Restore the session appearance before
+ * paint; defer only appearance reconciliation, never content or glass reveal. */
+export declare function installAppearanceStore(key?: string): AppearanceStore;

package/dist/app/appearanceStore.js

@@ -0,0 +1,228 @@
+/// <reference lib="dom" />
+/** Shared by the generated head and React. Restore the session appearance before
+ * paint; defer only appearance reconciliation, never content or glass reveal. */
+export function installAppearanceStore(key = 'satin-appearance:v1') {
+    if (window.__SATIN_APPEARANCE__)
+        return window.__SATIN_APPEARANCE__;
+    // CSS is useful for cold launch, but is NOT independent confirmation of a
+    // media query on resume: both can expose the same stale WebKit trait.
+    const media = matchMedia('(prefers-color-scheme: dark)');
+    let dark = media.matches;
+    try {
+        const style = document.createElement('style');
+        style.textContent =
+            ':root{--satin-system-appearance:light}@media(prefers-color-scheme:dark){:root{--satin-system-appearance:dark}}';
+        document.head.appendChild(style);
+        const css = getComputedStyle(document.documentElement)
+            .getPropertyValue('--satin-system-appearance')
+            .trim();
+        if (css === 'dark')
+            dark = true;
+        else if (css === 'light')
+            dark = false;
+    }
+    catch {
+        // A head-time CSS probe is optional; the retained query still works.
+    }
+    let restored = false;
+    try {
+        const saved = sessionStorage.getItem(key);
+        if (saved === 'dark' || saved === 'light') {
+            dark = saved === 'dark';
+            restored = true;
+        }
+    }
+    catch {
+        // Storage denial must not prevent launch.
+    }
+    let systemDark = dark;
+    let preferred = 'system';
+    let snapshot = { dark, pending: false };
+    const listeners = new Set();
+    // Installed iOS 27 emitted false light events 199–554 ms before hiding. This
+    // window quarantines active media events before publishing a stable appearance.
+    const backgroundWindowMs = 750;
+    let activeConfirmation;
+    let state = 'active';
+    const events = [];
+    const record = (event, eventDark) => {
+        events.push({
+            at: performance.now(),
+            event,
+            state,
+            hidden: document.hidden,
+            queryDark: media.matches,
+            eventDark,
+            heldDark: snapshot.dark,
+        });
+        if (events.length > 256)
+            events.shift();
+    };
+    let backgroundDark = dark;
+    // reference accepts a conservative hold as product policy, not native trait proof.
+    // 11c measured stale foreground traits for up to 1,082 ms. The first read
+    // at 1,600 ms adds 518 ms of margin; a matching read at least 300 ms later
+    // makes the earliest switch 1,900 ms after visibility. Hide restarts both.
+    const resumeGuardMs = 1600;
+    const confirmationMs = 300;
+    let reconciliation;
+    let latestEvent;
+    const save = (value) => {
+        try {
+            sessionStorage.setItem(key, value ? 'dark' : 'light');
+        }
+        catch {
+            // Optional session recovery.
+        }
+    };
+    let hiddenPublication = false;
+    const publish = (traitDark, notify = true) => {
+        const nextDark = preferred === 'dark' || (preferred !== 'light' && traitDark);
+        document.documentElement.dataset.satinAppearance = nextDark ? 'dark' : 'light';
+        document.documentElement.dataset.satinAppearancePending = 'false';
+        document.documentElement.style.colorScheme = nextDark ? 'dark' : 'light';
+        if (snapshot.dark === nextDark)
+            return;
+        snapshot = { dark: nextDark, pending: false };
+        if (notify)
+            for (const listener of listeners)
+                listener();
+        else
+            hiddenPublication = true;
+    };
+    const observe = (nextDark) => {
+        systemDark = nextDark;
+        save(nextDark);
+        publish(nextDark);
+    };
+    const cancelReconciliation = () => {
+        if (reconciliation !== undefined)
+            clearTimeout(reconciliation);
+        reconciliation = undefined;
+    };
+    const remember = () => {
+        if (state !== 'hidden') {
+            backgroundDark = systemDark;
+            if (activeConfirmation !== undefined)
+                clearTimeout(activeConfirmation);
+            activeConfirmation = undefined;
+            cancelReconciliation();
+            state = 'hidden';
+            record('hide');
+            publish(backgroundDark, false);
+        }
+        document.documentElement.dataset.satinAppearanceSession = 'true';
+        save(backgroundDark);
+    };
+    const reading = () => {
+        const query = media.matches;
+        // Capture event.matches even when WebKit has not updated the query object.
+        // A subsequent silent query update supersedes that event's query snapshot.
+        return { dark: latestEvent?.query === query ? latestEvent.dark : query, query };
+    };
+    const confirm = () => {
+        state = 'confirming';
+        record('confirm-start');
+        const candidate = reading();
+        reconciliation = setTimeout(() => {
+            reconciliation = undefined;
+            if (document.hidden) {
+                remember();
+                return;
+            }
+            const next = reading();
+            if (next.dark !== candidate.dark || next.query !== candidate.query) {
+                confirm();
+                return;
+            }
+            state = 'active';
+            latestEvent = undefined;
+            observe(next.dark);
+            record('confirmed');
+            document.documentElement.dataset.satinAppearanceSession = 'false';
+        }, confirmationMs);
+    };
+    const resume = () => {
+        if (document.hidden) {
+            remember();
+            return;
+        }
+        if (state !== 'hidden')
+            return;
+        state = 'holding';
+        record('resume');
+        if (hiddenPublication) {
+            hiddenPublication = false;
+            for (const listener of listeners)
+                listener();
+        }
+        reconciliation = setTimeout(() => {
+            reconciliation = undefined;
+            confirm();
+        }, resumeGuardMs);
+    };
+    const store = {
+        setPreferredColorScheme: scheme => {
+            if (scheme !== null && scheme !== 'system' && scheme !== 'light' && scheme !== 'dark') {
+                throw new Error('preferredColorScheme requires light, dark, system or null.');
+            }
+            preferred = scheme;
+            publish(systemDark);
+            record('preferred-color-scheme');
+        },
+        getSnapshot: () => snapshot,
+        getDiagnostics: () => events.map(event => ({ ...event })),
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+    window.__SATIN_APPEARANCE__ = store;
+    document.documentElement.dataset.satinAppearanceSession = String(restored);
+    publish(dark);
+    record('initial');
+    media.addEventListener('change', event => {
+        const matches = event?.matches;
+        record('media', typeof matches === 'boolean' ? matches : media.matches);
+        latestEvent = {
+            dark: typeof matches === 'boolean' ? matches : media.matches,
+            query: media.matches,
+        };
+        if (document.hidden || state === 'hidden') {
+            remember();
+            return;
+        }
+        if (state === 'confirming') {
+            cancelReconciliation();
+            confirm();
+            return;
+        }
+        if (state !== 'active')
+            return;
+        if (activeConfirmation !== undefined)
+            clearTimeout(activeConfirmation);
+        activeConfirmation = setTimeout(() => {
+            activeConfirmation = undefined;
+            if (document.hidden || state !== 'active')
+                return;
+            observe(reading().dark);
+            latestEvent = undefined;
+            record('active-confirmed');
+        }, backgroundWindowMs);
+    });
+    document.addEventListener('visibilitychange', () => {
+        if (document.hidden)
+            remember();
+        else
+            resume();
+    });
+    addEventListener('pagehide', remember);
+    addEventListener('pageshow', resume);
+    if (document.hidden || restored) {
+        remember();
+        resume();
+    }
+    return store;
+}

package/dist/app/backgroundUpdate.d.ts

@@ -0,0 +1,20 @@
+interface EditableBaselines {
+    readonly values: WeakMap<HTMLInputElement | HTMLTextAreaElement, string>;
+    readonly checked: WeakMap<HTMLInputElement, boolean>;
+    readonly selected: WeakMap<HTMLSelectElement, readonly boolean[]>;
+}
+/** Suspension is a safe apply boundary when the app has no unsaved edits or active media. */
+export declare const BACKGROUND_UPDATE_AFTER_MS = 0;
+export declare function hasUnsavedEditableState(root: ParentNode, baselines?: EditableBaselines): boolean;
+/** Keep a controlled input's clean value even if React synchronizes defaultValue. */
+export declare function trackEditableState(root: HTMLElement): {
+    hasUnsavedChanges: () => boolean;
+    dispose: () => void;
+};
+export declare function mayApplyBackgroundUpdate(root: ParentNode, hasCustomUnsavedChanges: boolean, hiddenForMs: number, mediaActive?: boolean): boolean;
+/** 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 declare const FOREGROUND_UPDATE_CHECK_MS: number;
+export declare function watchBackgroundUpdates(scope: string, onInstalled: () => void): () => void;
+export {};