@makershq/react 0.0.0-stage → 0.3.1

package/dist/tauri/components/release-notes-settings/index.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** Presents release notes and consumer-owned updates in native Tauri windows.
+ *
+ * Mounts SDK child views before app children and keeps all updater callbacks in the host.
+ *
+ * Import this optional entry point only in Tauri apps with the documented capabilities.
+ */
+import { useReleaseNotes } from '../../hooks/use-release-notes.js';
+/** Renders the approved Updates settings content using its enclosing native host.
+ * @returns Current version, manual update check, preference and changelog actions.
+ */
+export function ReleaseNotesSettings() {
+    const { state, open, checkForUpdates, setShowAfterUpdate } = useReleaseNotes();
+    return (_jsxs("section", { className: "flrn-native flrn-settings", "data-theme": state.theme, children: [_jsx("h1", { children: "Updates" }), _jsxs("div", { className: "flrn-setting-row", children: [_jsxs("div", { children: [_jsx("p", { children: "Current version" }), _jsx("p", { className: "flrn-muted", children: "The version installed on this device." })] }), _jsx("span", { children: state.currentVersion || 'Loading…' })] }), _jsxs("div", { className: "flrn-setting-row", children: [_jsxs("div", { children: [_jsx("p", { children: "Check for updates" }), _jsx("p", { className: "flrn-muted", children: "Checks the update server for a newer version." })] }), _jsx("button", { disabled: state.status === 'checking' ||
+                            state.status === 'progress' ||
+                            !state.ready, onClick: () => {
+                            void checkForUpdates().catch(() => undefined);
+                        }, children: state.status === 'checking' ? 'Checking…' : 'Check now' })] }), _jsxs("div", { className: "flrn-setting-row", children: [_jsxs("label", { htmlFor: "flrn-after-update", children: [_jsx("span", { children: "Show changelog after each update" }), _jsxs("span", { className: "flrn-muted", children: ["See what changed after ", state.name || 'this app', " updates."] })] }), _jsx("input", { disabled: !state.ready, id: "flrn-after-update", type: "checkbox", role: "switch", checked: state.preferences.showAfterUpdate, onChange: (event) => {
+                            void setShowAfterUpdate(event.target.checked).catch(() => undefined);
+                        } })] }), _jsxs("div", { className: "flrn-setting-row", children: [_jsxs("div", { children: [_jsx("p", { children: "Release notes" }), _jsx("p", { className: "flrn-muted", children: "Explore the latest changes and previous releases." })] }), _jsx("button", { className: "flrn-secondary", disabled: !state.ready, onClick: () => {
+                            void open().catch(() => undefined);
+                        }, children: "What\u2019s new" })] }), state.error && _jsx("p", { role: "alert", children: state.error })] }));
+}

package/dist/tauri/components/update-window/index.d.ts

@@ -0,0 +1,20 @@
+/** Presents release notes and consumer-owned updates in native Tauri windows.
+ *
+ * Mounts SDK child views before app children and keeps all updater callbacks in the host.
+ *
+ * Import this optional entry point only in Tauri apps with the documented capabilities.
+ */
+import type { NativeState } from '../../contracts.js';
+import type { ChildAction } from '../../protocol.js';
+/** Presents a consumer updater candidate and its installation progress.
+ * @param props - Authenticated host snapshot and bounded actions.
+ * @param props.state - Current host presentation state.
+ * @param props.act - Sends one supported action to the host.
+ * @param props.close - Closes this child without cancelling installation.
+ * @returns Native update window content.
+ */
+export declare function UpdateWindow({ state, act, close, }: {
+    state: NativeState;
+    act: (action: ChildAction) => void;
+    close: () => void;
+}): import("react").JSX.Element;

package/dist/tauri/components/update-window/index.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/** Presents release notes and consumer-owned updates in native Tauri windows.
+ *
+ * Mounts SDK child views before app children and keeps all updater callbacks in the host.
+ *
+ * Import this optional entry point only in Tauri apps with the documented capabilities.
+ */
+import { openUrl } from '@tauri-apps/plugin-opener';
+import { ReleaseNotesReader } from '../../../components/release-notes/index.js';
+import { safeHttpUrl } from '../../../api.js';
+async function openExternal(url) {
+    const safe = safeHttpUrl(url);
+    if (safe)
+        await openUrl(safe);
+}
+/** Presents a consumer updater candidate and its installation progress.
+ * @param props - Authenticated host snapshot and bounded actions.
+ * @param props.state - Current host presentation state.
+ * @param props.act - Sends one supported action to the host.
+ * @param props.close - Closes this child without cancelling installation.
+ * @returns Native update window content.
+ */
+export function UpdateWindow({ state, act, close, }) {
+    const progress = state.status === 'progress' ? state.progress : null;
+    const candidate = state.status === 'available' || state.status === 'progress'
+        ? state.candidate
+        : null;
+    const checking = state.status === 'checking';
+    const checkError = state.status === 'error';
+    const current = state.status === 'current';
+    const downloading = progress?.phase === 'downloading' ? progress : null;
+    const percent = downloading?.totalBytes
+        ? Math.min(100, Math.round((downloading.downloadedBytes / downloading.totalBytes) * 100))
+        : undefined;
+    const title = checkError
+        ? 'Couldn’t check for updates'
+        : checking
+            ? 'Checking for updates…'
+            : current
+                ? 'You’re up to date'
+                : progress
+                    ? progress.phase === 'downloading'
+                        ? 'Downloading your update'
+                        : progress.phase === 'installing'
+                            ? 'Installing your update'
+                            : 'Restarting…'
+                    : `A new version of ${state.name} is available`;
+    return (_jsxs(_Fragment, { children: [_jsxs("header", { className: "flrn-update-intro", children: [_jsx("img", { src: state.icon, alt: "" }), _jsxs("div", { children: [_jsx("h1", { children: title }), _jsx("p", { children: checkError
+                                    ? 'Check your connection and try again.'
+                                    : checking
+                                        ? 'Checking the update server for a newer version.'
+                                        : current
+                                            ? `${state.name} ${state.currentVersion} is the latest version.`
+                                            : candidate
+                                                ? progress
+                                                    ? `${progress.phase === 'downloading' ? 'Downloading' : progress.phase === 'installing' ? 'Installing' : 'Restarting'} ${state.name} ${candidate.version}.`
+                                                    : `${state.name} ${candidate.version} is available. You’re using ${state.currentVersion}. Would you like to download it now?`
+                                                : 'Checking for updates…' }), candidate && (_jsxs("p", { children: [state.name, " will restart automatically after installation."] })), state.error && _jsx("p", { role: "alert", children: state.error })] })] }), _jsx("div", { className: "flrn-child-scroll flrn-update-notes-panel", children: current ? (_jsx("p", { className: "flrn-current", children: "You have the latest improvements." })) : (candidate && (_jsxs(_Fragment, { children: [_jsx(ReleaseNotesReader, { projectId: state.projectId, version: candidate.version, theme: state.theme, openExternal: openExternal }), candidate.notes && (_jsxs("details", { className: "flrn-updater-notes", children: [_jsx("summary", { children: "Notes from the app updater" }), _jsx("p", { children: candidate.notes })] }))] }))) }), _jsx("footer", { children: progress ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: "flrn-progress", role: "status", children: [_jsx("p", { children: progress.phase === 'downloading'
+                                        ? `Downloading update…${percent === undefined ? '' : ` ${percent}%`}`
+                                        : progress.phase === 'installing'
+                                            ? 'Installing update…'
+                                            : 'Restarting…' }), downloading && (_jsxs(_Fragment, { children: [_jsx("progress", { max: 100, value: percent, "aria-label": "Download progress" }), _jsxs("p", { className: "flrn-muted", children: [formatBytes(downloading.downloadedBytes), downloading.totalBytes
+                                                    ? ` of ${formatBytes(downloading.totalBytes)}`
+                                                    : ''] })] }))] }), downloading && state.canCancel && (_jsx("button", { className: "flrn-secondary", onClick: () => act({ type: 'cancel' }), children: "Cancel" }))] })) : current ? (_jsxs(_Fragment, { children: [_jsx("button", { className: "flrn-secondary", onClick: () => act({ type: 'open-reader' }), children: "Read release notes" }), _jsx("button", { onClick: close, children: "Done" })] })) : candidate ? (_jsxs(_Fragment, { children: [_jsx("button", { className: "flrn-secondary", onClick: () => act({ type: 'skip', version: candidate.version }), children: "Skip this version" }), _jsx("button", { onClick: () => act({ type: 'install', version: candidate.version }), children: "Install update" })] })) : (_jsx("button", { disabled: checking, onClick: () => act({ type: 'check' }), children: checking ? 'Checking…' : 'Try again' })) })] }));
+}
+function formatBytes(bytes) {
+    return `${(bytes / 1_000_000).toLocaleString(undefined, { maximumFractionDigits: 1 })} MB`;
+}

package/dist/tauri/context.d.ts

@@ -0,0 +1,20 @@
+/** Presents release notes and consumer-owned updates in native Tauri windows.
+ *
+ * Mounts SDK child views before app children and keeps all updater callbacks in the host.
+ *
+ * Import this optional entry point only in Tauri apps with the documented capabilities.
+ */
+import { type Context } from 'react';
+import type { NativeHost } from './host-controller.js';
+/** Internal presentation actions shared by local and connected settings views. */
+export type NativePresentationHost = Pick<NativeHost, 'subscribe' | 'getSnapshot' | 'open' | 'check' | 'setShowAfterUpdate' | 'notifyUpdateAvailable' | 'presentationAction'>;
+/** Shares the private native lifecycle owner with host-window presentation.
+ * @param props - React context provider properties.
+ * @returns Context provider content.
+ */
+export declare const HostContext: Context<NativePresentationHost | null>;
+/** Reads the enclosing native host.
+ * @returns Host lifecycle owner.
+ * @throws Error outside a host window provider.
+ */
+export declare function useHost(): NativePresentationHost;

package/dist/tauri/context.js

@@ -0,0 +1,22 @@
+/** Presents release notes and consumer-owned updates in native Tauri windows.
+ *
+ * Mounts SDK child views before app children and keeps all updater callbacks in the host.
+ *
+ * Import this optional entry point only in Tauri apps with the documented capabilities.
+ */
+import { createContext, useContext } from 'react';
+/** Shares the private native lifecycle owner with host-window presentation.
+ * @param props - React context provider properties.
+ * @returns Context provider content.
+ */
+export const HostContext = createContext(null);
+/** Reads the enclosing native host.
+ * @returns Host lifecycle owner.
+ * @throws Error outside a host window provider.
+ */
+export function useHost() {
+    const host = useContext(HostContext);
+    if (!host)
+        throw new Error('Use native release notes inside ReleaseNotesHost in its host window.');
+    return host;
+}

package/dist/tauri/contracts.d.ts

@@ -0,0 +1,84 @@
+/** Defines the consumer-owned updater contract for native release-note presentation.
+ *
+ * Keeps native resources, installation policy and restart control in the consuming app.
+ *
+ * Extend presentation states without transferring updater ownership into the SDK.
+ */
+/** A version offered by the consuming application's updater. */
+export interface AvailableUpdate {
+    version: string;
+    /** Exact updater candidate version. */
+    notes?: string;
+}
+/** Installation progress reported by the consuming application. */
+export type InstallProgress = {
+    phase: 'downloading';
+    downloadedBytes: number;
+    totalBytes?: number;
+} | {
+    phase: 'installing' | 'restarting';
+};
+/** Consumer-owned update operations; the SDK never obtains native update handles. */
+export interface AppUpdater {
+    /** Checks eligibility using the app's own updater policy.
+     * @returns A candidate or null when already current.
+     */
+    check(): Promise<AvailableUpdate | null>;
+    /** Flushes app state, installs the exact candidate and restarts automatically.
+     * @param version - Candidate selected by the user; reject stale candidates.
+     * @param reportProgress - Reports serializable presentation progress.
+     * @returns Completion or a rejected installation error.
+     */
+    install(version: string, reportProgress: (progress: InstallProgress) => void): Promise<void>;
+    /** Cancels a supported active download.
+     * @returns Completion after the consumer has cancelled its operation.
+     */
+    cancel?(): Promise<void>;
+}
+/** Only the three approved preferences persist in the app's local data directory. */
+export interface ReleaseNotesPreferences {
+    showAfterUpdate: boolean;
+    /** Whether an installed upgrade opens its exact release notes. */
+    acknowledgedVersion: string | null;
+    /** Highest installed version whose presentation has been acknowledged. */
+    skippedVersion: string | null;
+}
+/** Public synchronized state; update operations remain owned by the app. */
+export interface ReleaseNotesState {
+    ready: boolean;
+    /** True after app metadata, preferences and host listeners are ready. */
+    presentation: 'native' | 'headless';
+    /** Presentation policy fixed for this host lifecycle. */
+    projectId: string;
+    /** Public release-note project identifier. */
+    name: string;
+    /** Application name read from Tauri. */
+    currentVersion: string;
+    /** Installed application version. */
+    icon: string;
+    /** Consumer-owned application icon URL. */
+    theme: 'system' | 'light' | 'dark';
+    /** Consumer-selected presentation theme. */
+    preferences: ReleaseNotesPreferences;
+    /** Shared persistent release-note preferences. */
+    status: 'idle' | 'checking' | 'available' | 'current' | 'progress' | 'error';
+    /** Current consumer update operation state. */
+    candidate: AvailableUpdate | null;
+    /** Exact app-owned candidate, when one is available. */
+    progress: InstallProgress | null;
+    /** Current app-reported installation progress. */
+    canCancel: boolean;
+    /** Whether the active download currently accepts cancellation. */
+    error: string | null;
+}
+/** Private serializable identity for one reader or update presentation. */
+export interface NativePresentationRequest {
+    generation: number;
+    originWindowLabel: string;
+}
+/** Private synchronized snapshot used by authenticated native adapters. */
+export interface NativeState extends ReleaseNotesState {
+    readerVersion: string | null;
+    readerRequest: NativePresentationRequest | null;
+    updateRequest: NativePresentationRequest | null;
+}

package/dist/tauri/contracts.js

@@ -0,0 +1,7 @@
+/** Defines the consumer-owned updater contract for native release-note presentation.
+ *
+ * Keeps native resources, installation policy and restart control in the consuming app.
+ *
+ * Extend presentation states without transferring updater ownership into the SDK.
+ */
+export {};

package/dist/tauri/hooks/use-release-notes.d.ts

@@ -0,0 +1,92 @@
+/** Presents release notes and consumer-owned updates in native Tauri windows.
+ *
+ * Mounts SDK child views before app children and keeps all updater callbacks in the host.
+ *
+ * Import this optional entry point only in Tauri apps with the documented capabilities.
+ */
+import type { Release } from '../../api.js';
+import type { AvailableUpdate, ReleaseNotesState } from '../contracts.js';
+/** App-owned reader placement with acknowledgment bound to its active request. */
+export interface ReaderPresentation {
+    version?: string;
+    /** Exact installed version, or undefined for history. */
+    originWindowLabel: string;
+    /** Window which requested the reader. */
+    /** Hides this request without acknowledging unread content.
+     * @returns Completion after the active request is dismissed.
+     */
+    dismiss(): Promise<void>;
+    /** Confirms freshly rendered exact-version content; failures appear in shared state.
+     * @param release - The rendered release document.
+     * @param release.id - Stable public release identifier.
+     * @param release.version - Optional exact application version.
+     * @param release.title - Human-readable title.
+     * @param release.excerpt - Optional plain-text preview.
+     * @param release.previewImageSource - Optional preview image source.
+     * @param release.markdown - Complete release document.
+     * @param release.date - Publication calendar date.
+     * @param release.url - Public article URL.
+     * @param state - Rendered content provenance.
+     * @param state.cached - Whether this is an offline copy, which never acknowledges.
+     */
+    onReleaseRendered(release: Release, state: {
+        cached: boolean;
+    }): void;
+}
+/** App-owned update placement with commands bound to its active request. */
+export interface UpdatePresentation {
+    originWindowLabel: string;
+    /** Window which requested the update presentation. */
+    /** Hides presentation without cancelling installation.
+     * @returns Completion after the active request is dismissed.
+     */
+    dismiss(): Promise<void>;
+    /** Accepts installation; progress and failures arrive in shared state.
+     * @returns Command acceptance, without waiting for installation or restart.
+     */
+    install(): Promise<void>;
+    /** Persists this exact candidate as skipped and dismisses its presentation.
+     * @returns Completion after preference persistence and dismissal.
+     */
+    skip(): Promise<void>;
+    /** Accepts supported cancellation; completion and failures arrive in shared state.
+     * @returns Command acceptance, without waiting for consumer cancellation.
+     */
+    cancel(): Promise<void>;
+}
+/** Native release-note actions for menu items and an existing background update checker. */
+export interface ReleaseNotesActions {
+    /** Opens or focuses the changelog.
+     * @returns Completion after the native window is ready.
+     */
+    open(): Promise<void>;
+    /** Runs the app-owned manual check, including previously skipped candidates.
+     * @returns Completion after the host presents its result; rejects unavailable native connections.
+     */
+    checkForUpdates(): Promise<void>;
+    /** Presents an app-owned candidate unless the user skipped this exact version.
+     * @param candidate - Version and optional plain-text notes from the app updater.
+     * @param candidate.version - Exact candidate version.
+     * @param candidate.notes - Optional plain-text updater notes.
+     * @returns Presentation completion; rejects invalid candidates or missing capabilities.
+     */
+    notifyUpdateAvailable(candidate: AvailableUpdate): Promise<void>;
+}
+/** Shared native state and optional app-owned presentations, with existing actions preserved. */
+export interface ReleaseNotesResult extends ReleaseNotesActions {
+    state: ReleaseNotesState;
+    /** Synchronized public state; updater resources stay in the main window. */
+    reader: ReaderPresentation | null;
+    /** Active headless reader request; the app owns placement and focus. */
+    update: UpdatePresentation | null;
+    /** Active headless update request, independent of the reader. */
+    /** Persists the shared after-update reader preference.
+     * @param value - Whether installed upgrades should open their exact release notes.
+     * @returns Completion after preference persistence and synchronization.
+     */
+    setShowAfterUpdate(value: boolean): Promise<void>;
+}
+/** Gets host actions without exposing updater handles or SDK-managed scheduling.
+ * @returns Actions bound to the one native host.
+ */
+export declare function useReleaseNotes(): ReleaseNotesResult;

package/dist/tauri/hooks/use-release-notes.js

@@ -0,0 +1,101 @@
+/** Presents release notes and consumer-owned updates in native Tauri windows.
+ *
+ * Mounts SDK child views before app children and keeps all updater callbacks in the host.
+ *
+ * Import this optional entry point only in Tauri apps with the documented capabilities.
+ */
+import { useCallback, useMemo, useSyncExternalStore } from 'react';
+import { useHost } from '../context.js';
+/** Gets host actions without exposing updater handles or SDK-managed scheduling.
+ * @returns Actions bound to the one native host.
+ */
+export function useReleaseNotes() {
+    const host = useHost();
+    const snapshot = useSyncExternalStore(host.subscribe, host.getSnapshot);
+    const checkForUpdates = useCallback(() => host.check(), [host]);
+    const state = useMemo(() => ({
+        ready: snapshot.ready,
+        presentation: snapshot.presentation,
+        projectId: snapshot.projectId,
+        name: snapshot.name,
+        currentVersion: snapshot.currentVersion,
+        icon: snapshot.icon,
+        theme: snapshot.theme,
+        preferences: snapshot.preferences,
+        status: snapshot.status,
+        candidate: snapshot.candidate,
+        progress: snapshot.progress,
+        canCancel: snapshot.status === 'progress' &&
+            snapshot.progress?.phase === 'downloading' &&
+            snapshot.canCancel,
+        error: snapshot.error,
+    }), [snapshot]);
+    const reader = useMemo(() => {
+        const request = snapshot.readerRequest;
+        if (snapshot.presentation !== 'headless' || !request)
+            return null;
+        return {
+            version: snapshot.readerVersion ?? undefined,
+            originWindowLabel: request.originWindowLabel,
+            dismiss: () => host.presentationAction('reader', request.generation, {
+                type: 'dismiss',
+            }),
+            onReleaseRendered: (release, info) => {
+                if (release.version)
+                    void host
+                        .presentationAction('reader', request.generation, {
+                        type: 'rendered',
+                        version: release.version,
+                        cached: info.cached,
+                    })
+                        .catch(() => undefined);
+            },
+        };
+    }, [
+        host,
+        snapshot.presentation,
+        snapshot.readerRequest,
+        snapshot.readerVersion,
+    ]);
+    const update = useMemo(() => {
+        const request = snapshot.updateRequest;
+        const version = snapshot.candidate?.version;
+        if (snapshot.presentation !== 'headless' || !request)
+            return null;
+        return {
+            originWindowLabel: request.originWindowLabel,
+            dismiss: () => host.presentationAction('update', request.generation, {
+                type: 'dismiss',
+            }),
+            install: () => version
+                ? host.presentationAction('update', request.generation, {
+                    type: 'install',
+                    version,
+                })
+                : Promise.resolve(),
+            skip: () => version
+                ? host.presentationAction('update', request.generation, {
+                    type: 'skip',
+                    version,
+                })
+                : Promise.resolve(),
+            cancel: () => host.presentationAction('update', request.generation, {
+                type: 'cancel',
+            }),
+        };
+    }, [
+        host,
+        snapshot.presentation,
+        snapshot.updateRequest,
+        snapshot.candidate?.version,
+    ]);
+    return {
+        state,
+        reader,
+        update,
+        open: host.open,
+        checkForUpdates,
+        setShowAfterUpdate: host.setShowAfterUpdate,
+        notifyUpdateAvailable: host.notifyUpdateAvailable,
+    };
+}

package/dist/tauri/host-controller.d.ts

@@ -0,0 +1,134 @@
+/** Coordinates native child windows while the main app retains its updater resources.
+ *
+ * Owns preferences, narrowly authenticated events and exact installed-version presentation.
+ *
+ * Keep callback execution in this host; child windows receive serializable state only.
+ */
+import type { AppUpdater, AvailableUpdate, NativeState } from './contracts.js';
+import { type ChildKind, type PresentationAction } from './protocol.js';
+/** Host-only state owner for one project and native main window. */
+export declare class NativeHostController {
+    private projectId;
+    private updater;
+    private hostWindowLabel;
+    private presentation;
+    private state;
+    private snapshotRevision;
+    private presentationGeneration;
+    private latestUpdateGeneration;
+    private automaticAttempt;
+    private listeners;
+    private children;
+    private peers;
+    private openings;
+    private store;
+    private disposers;
+    private disposed;
+    private automaticVersion;
+    private automaticPending;
+    private persistence;
+    private operation;
+    private installation;
+    private ready;
+    private initializationError;
+    private releaseLease;
+    private disposal;
+    private hostWindow;
+    private nativeThemeUpdates;
+    private nativeThemeRequest;
+    /** Initializes the single host and its app-local preference store.
+     * @param projectId - Public release-note project.
+     * @param icon - Consumer-owned app icon URL.
+     * @param updater - Consumer-owned updater callbacks.
+     * @param theme - App's selected theme.
+     * @param hostWindowLabel - Label of the sole callback-owning native window.
+     * @param presentation - Fixed presentation policy for this lifecycle.
+     */
+    constructor(projectId: string, icon: string, updater: AppUpdater, theme: NativeState['theme'], hostWindowLabel: string, presentation?: NativeState['presentation']);
+    /** Subscribes to host state.
+     * @param listener - React external-store listener.
+     * @returns Unsubscribe callback.
+     */
+    subscribe: (listener: () => void) => (() => void);
+    /** Returns the stable current state snapshot.
+     * @returns Serializable native presentation state.
+     */
+    getSnapshot: () => NativeState;
+    private initialize;
+    private patch;
+    private fail;
+    private sendState;
+    private sendPeerState;
+    private connectPeer;
+    private dispatchPeer;
+    private savePreferences;
+    private ensureReady;
+    /** Updates consumer callbacks and appearance without recreating native resources.
+     * @param updater - Latest app-owned callbacks.
+     * @param icon - Current app icon URL.
+     * @param theme - Current app theme.
+     */
+    configure(updater: AppUpdater, icon: string, theme: NativeState['theme']): void;
+    /** Synchronizes consumer theme changes to existing child windows.
+     * @param theme - System, light or dark consumer preference.
+     */
+    setTheme(theme: NativeState['theme']): void;
+    private synchronizeNativeTheme;
+    /** Opens or focuses the single changelog window.
+     * @returns Completion after the native window is ready.
+     */
+    open: () => Promise<void>;
+    private openFrom;
+    /** Offers a background updater candidate while respecting the skipped version.
+     * @param candidate - Version supplied by the consumer's existing background checker.
+     * @param candidate.version - Exact candidate version.
+     * @param candidate.notes - Optional plain-text updater notes.
+     * @returns Completion after a matching update window is open, or a quiet skip.
+     */
+    notifyUpdateAvailable: (candidate: AvailableUpdate) => Promise<void>;
+    private validateCandidate;
+    /** Runs an explicit user check, bypassing skipped-version suppression.
+     * @param originLabel - Existing settings window to receive focus after closing the update.
+     * @returns Completion after the updater result is shown.
+     */
+    check: (originLabel?: string) => Promise<void>;
+    /** Saves the shared after-update preference.
+     * @param value - Whether future upgrades should open a changelog.
+     * @returns Completion after persistence and child synchronization.
+     */
+    setShowAfterUpdate: (value: boolean) => Promise<void>;
+    private retryAutomatic;
+    private requestPresentation;
+    private settleUpdatePresentation;
+    private dismissPresentation;
+    /** Accepts one action bound to the active headless presentation.
+     * @param kind - Reader or update presentation.
+     * @param generation - Private presentation identity captured by the hook.
+     * @param action - Bounded presentation command.
+     * @param action.type - Fixed command discriminator.
+     * @param action.version - Exact displayed candidate or rendered release version.
+     * @param action.cached - Whether rendered content came from offline storage.
+     * @returns Command acceptance; installation and cancellation progress through shared state.
+     */
+    presentationAction: (kind: ChildKind, generation: number, action: PresentationAction) => Promise<void>;
+    private openWindow;
+    private createOrFocus;
+    private dispatch;
+    /** Releases listeners, local resources and native child windows on host unmount.
+     * @returns Completion after pending preference/appearance writes and child cleanup.
+     */
+    dispose(): Promise<void>;
+    private cleanup;
+}
+/** Creates the private native lifecycle owner for a single host window.
+ * @param projectId - Public release-note project.
+ * @param icon - Consumer icon URL.
+ * @param updater - Consumer updater callbacks.
+ * @param theme - Consumer theme.
+ * @param hostWindowLabel - Callback-owning native window.
+ * @param presentation - Fixed native or headless presentation policy.
+ * @returns Internal lifecycle owner; never exported by the package entry point.
+ */
+export declare function createNativeHostController(projectId: string, icon: string, updater: AppUpdater, theme: NativeState['theme'], hostWindowLabel: string, presentation?: NativeState['presentation']): NativeHostController;
+/** Internal controller type used only by native presentation components. */
+export type NativeHost = NativeHostController;