@rightkit/video-ui 0.0.0-stage → 0.1.0

package/dist/lib/progress.js

@@ -0,0 +1,192 @@
+// Folds engine events into UI progress. Event names and fields are the engine's
+// (genright_cmd.rs, cutright-genright orchestrator/engine, project_cmd.rs `progress_line`):
+//
+//   assemble.started  {shots, narration, resumed, requests:{label:request_id}, assemble_id}
+//   genright.request  {request_id, state: journaled|submitted, job_id?}
+//   genright.job      {request_id, job_id, status, attempts, error}
+//   genright.job_progress {request_id?, job_id, status, stage, attempt, at, message?}
+//   genright.import   {request_id, job_id, asset_id, media_path, sha256}
+//   import.done       {item (label), request_id, job_id, path, blake3, needs_probe} (assemble)
+//                     {request_id, job_id, asset_id, path, source_id, needs_probe}  (generate)
+//   timeline.built    {video_clips, added_clips, titles, total_frames, revision}
+//   render.progress   {frame, out_time_ms, total_ms}   (inside assemble; tagged assemble_id)
+//   progress          {job, frame, out_time_ms, total_ms}   (standalone render)
+//   assemble.done     {result:{status, assemble_id, render?:{output, ...}}}
+//   assemble.failed   {code, message}
+//
+// Frames arrive as `{id, tag, event}` (engine request id, caller tag, engine event).
+export const initialProgress = {
+    tag: null,
+    frameId: null,
+    assembleId: null,
+    running: false,
+    resumed: false,
+    stages: [],
+    jobs: {},
+    imports: 0,
+    render: null,
+    timeline: null,
+    error: null,
+    cancelled: false,
+    output: null,
+    done: false,
+    log: [],
+};
+export const assembleRenderJob = (assembleId) => `assemble-${assembleId}-render`;
+const str = (v) => (typeof v === "string" ? v : undefined);
+const num = (v) => (typeof v === "number" ? v : undefined);
+const isObj = (v) => typeof v === "object" && v !== null;
+/** Starts tracking one engine call. */
+export function beginProgress(tag, assembleId) {
+    return { ...initialProgress, tag, assembleId, running: true };
+}
+function labelOf(state, requestId) {
+    return state.jobs[requestId]?.label ?? requestId;
+}
+function upsertJob(state, requestId, patch) {
+    const prev = state.jobs[requestId] ?? { id: requestId, label: labelOf(state, requestId), imported: false };
+    return { ...state.jobs, [requestId]: { ...prev, ...patch } };
+}
+const withStage = (state, name) => state.stages.includes(name) ? state.stages : [...state.stages, name];
+export function reduceFrame(state, frame) {
+    if (state.tag === null || frame.tag !== state.tag)
+        return state;
+    if (state.frameId !== null && frame.id !== null && frame.id !== state.frameId)
+        return state;
+    const ev = frame.event;
+    const next = {
+        ...state,
+        frameId: state.frameId ?? frame.id,
+        log: [...state.log.slice(-99), ev],
+    };
+    const requestId = str(ev.request_id);
+    switch (str(ev.event)) {
+        case "assemble.started": {
+            const jobs = {};
+            if (isObj(ev.requests)) {
+                for (const [label, rid] of Object.entries(ev.requests)) {
+                    if (typeof rid === "string")
+                        jobs[rid] = { id: rid, label, imported: false };
+                }
+            }
+            const assembleId = str(ev.assemble_id) ?? state.assembleId;
+            return {
+                ...next,
+                assembleId,
+                running: true,
+                resumed: ev.resumed === true,
+                jobs,
+                stages: ["assemble.started"],
+                error: null,
+                cancelled: false,
+            };
+        }
+        case "genright.request":
+            if (!requestId)
+                return next;
+            next.jobs = upsertJob(state, requestId, { request: str(ev.state), jobId: str(ev.job_id) });
+            return next;
+        case "genright.job":
+            if (!requestId)
+                return next;
+            next.jobs = upsertJob(state, requestId, {
+                jobId: str(ev.job_id),
+                status: str(ev.status),
+                message: isObj(ev.error) ? str(ev.error.message) : str(ev.error),
+            });
+            return next;
+        case "genright.job_progress": {
+            // job_progress carries request_id only when the orchestrator forwards it; fall back
+            // to matching the job id.
+            const jobId = str(ev.job_id);
+            const rid = requestId ?? Object.values(state.jobs).find((j) => j.jobId === jobId)?.id;
+            if (!rid)
+                return next;
+            next.jobs = upsertJob(state, rid, {
+                jobId: jobId ?? state.jobs[rid]?.jobId,
+                status: str(ev.status) ?? state.jobs[rid]?.status,
+                stage: str(ev.stage) ?? state.jobs[rid]?.stage,
+                message: str(ev.message) ?? state.jobs[rid]?.message,
+            });
+            return next;
+        }
+        case "genright.import":
+        case "import.done": {
+            if (requestId && state.jobs[requestId])
+                next.jobs = upsertJob(state, requestId, { imported: true });
+            if (str(ev.event) === "import.done")
+                next.imports = state.imports + 1;
+            return next;
+        }
+        case "timeline.built":
+            next.stages = withStage(state, "timeline.built");
+            next.timeline = {
+                video_clips: num(ev.video_clips),
+                titles: num(ev.titles),
+                total_frames: num(ev.total_frames),
+            };
+            return next;
+        case "render.progress":
+        case "progress":
+            next.stages = withStage(state, "render");
+            next.render = {
+                job: str(ev.job) ?? state.render?.job ?? (state.assembleId ? assembleRenderJob(state.assembleId) : undefined),
+                frame: num(ev.frame),
+                out_time_ms: num(ev.out_time_ms),
+                total_ms: num(ev.total_ms) ?? state.render?.total_ms,
+            };
+            return next;
+        case "assemble.done": {
+            const result = isObj(ev.result) ? ev.result : {};
+            const render = isObj(result.render) ? result.render : {};
+            next.running = false;
+            next.done = true;
+            next.output = str(render.output) ?? state.output;
+            next.stages = withStage(state, "assemble.done");
+            return next;
+        }
+        case "assemble.failed": {
+            const code = str(ev.code);
+            next.running = false;
+            if (code === "cancelled" || code === "render_cancelled") {
+                next.cancelled = true;
+                next.error = null;
+            }
+            else {
+                next.error = { code, message: str(ev.message) ?? "assembly failed" };
+            }
+            return next;
+        }
+        default:
+            return next;
+    }
+}
+/** Rebuilds what is known from an `assemble.status` result (after an app restart). */
+export function seedFromStatus(state, status) {
+    // A stored render whose file is gone is not a finished render: the render step must run again.
+    const renderMissing = !!status.render && status.render_exists === false;
+    const jobs = {};
+    for (const r of status.requests) {
+        jobs[r.request_id] = {
+            id: r.request_id,
+            label: r.item,
+            jobId: r.job_id ?? undefined,
+            request: r.state ?? undefined,
+            imported: r.imported,
+        };
+    }
+    const cancelled = status.status === "cancelled";
+    return {
+        ...state,
+        assembleId: status.assemble_id,
+        jobs,
+        stages: [
+            ...(status.timeline_built ? ["timeline.built"] : []),
+            ...(status.status === "done" && !renderMissing ? ["assemble.done"] : []),
+        ],
+        done: status.status === "done" && !renderMissing,
+        cancelled,
+        output: renderMissing ? null : (status.render?.output ?? null),
+        error: status.status === "failed" && status.error ? { code: status.error.code, message: status.error.message ?? "assembly failed" } : null,
+    };
+}

package/dist/lib/project.d.ts

@@ -0,0 +1,138 @@
+/** Timeline ticks per second (cutright-timeline TICKS_PER_SECOND). */
+export declare const TICKS_PER_SECOND = 705600000;
+export declare const secondsToTicks: (seconds: number) => number;
+export declare const ticksToSeconds: (ticks: number) => number;
+export type SourceInfo = {
+    id: string;
+    duration: number;
+    video: {
+        width: number;
+        height: number;
+    } | null;
+    has_audio: boolean;
+};
+export type VideoClip = {
+    id: string;
+    source: string;
+    source_in: number;
+    source_out: number;
+};
+export type AudioClip = {
+    id: string;
+    source: string;
+    trim_in: number;
+    trim_out: number;
+    start: number;
+    /** MilliDb — thousandths of a dB. */
+    gain: number;
+    link: string | null;
+    /** UnderAudio: what happens to the video audio under this clip. */
+    under: {
+        mode: "keep";
+    } | {
+        mode: "duck";
+        amount: number;
+    } | {
+        mode: "mute";
+    };
+};
+/** `TitleTemplate` serde form: internally tagged by `template`, text inside the template. */
+export type TitleTemplate = {
+    template: "lower_third";
+    title: string;
+    subtitle?: string;
+} | {
+    template: "centered";
+    text: string;
+} | {
+    template: "caption";
+    text: string;
+};
+export type OverlayClip = {
+    id: string;
+    start_frame: number;
+    frames: number;
+    template: TitleTemplate;
+    fade_in_frames?: number;
+    fade_out_frames?: number;
+};
+export declare const titleLabel: (t: TitleTemplate) => string;
+export type Timeline = {
+    fps: {
+        num: number;
+        den: number;
+    };
+    sources: SourceInfo[];
+    video_tracks: {
+        id: string;
+        clips: VideoClip[];
+    }[];
+    audio_tracks: {
+        id: string;
+        role: string;
+        clips: AudioClip[];
+    }[];
+    overlay_tracks: {
+        id: string;
+        clips: OverlayClip[];
+    }[];
+};
+/** `project.show` result. */
+export type ProjectShow = {
+    project: {
+        id: string;
+        name: string | null;
+        dir: string;
+        fps: {
+            num: number;
+            den: number;
+        };
+    };
+    revision: {
+        cursor: number;
+        total: number;
+        can_undo: boolean;
+        can_redo: boolean;
+    };
+    summary: {
+        total_frames: number;
+        duration_ms: number;
+        sources: number;
+        video_clips: number;
+        audio_clips: number;
+    };
+    sources: {
+        info: SourceInfo;
+        name: string | null;
+        mode: string | null;
+    }[];
+    layout: {
+        track: string;
+        clip: string;
+        start_frame: number;
+        frames: number;
+    }[];
+    timeline: Timeline;
+    /** Engine extension ids the editor may open capability gates for. */
+    extensions?: string[];
+    /** Sources carrying a validated transcript under analysis/ (word-edge evidence). */
+    transcripts?: {
+        source: string;
+    }[];
+};
+export declare const projectShow: (dir: string) => Promise<ProjectShow>;
+/**
+ * Appends `source` [startMs, endMs) to the end of `track`. The range is clamped to
+ * the source's real duration: word timings can run a few ms past the media's end,
+ * and the engine rejects out-of-range indices and source ranges.
+ */
+export declare function appendClip(dir: string, source: string, startMs: number, endMs: number, track?: string): Promise<unknown>;
+export declare const projectInit: (dir: string, name?: string) => Promise<unknown>;
+export declare const fpsValue: (fps: {
+    num: number;
+    den: number;
+}) => number;
+export declare function formatSeconds(seconds: number): string;
+export declare function baseName(path: string): string;
+/** Collision-resistant clip id for new timeline clips. */
+export declare function newClipId(): string;

package/dist/lib/project.js

@@ -0,0 +1,48 @@
+import { engineCall } from "./engine.js";
+/** Timeline ticks per second (cutright-timeline TICKS_PER_SECOND). */
+export const TICKS_PER_SECOND = 705_600_000;
+export const secondsToTicks = (seconds) => Math.round(seconds * TICKS_PER_SECOND);
+export const ticksToSeconds = (ticks) => ticks / TICKS_PER_SECOND;
+export const titleLabel = (t) => (t.template === "lower_third" ? t.title : t.text);
+export const projectShow = (dir) => engineCall("project.show", { dir });
+/**
+ * Appends `source` [startMs, endMs) to the end of `track`. The range is clamped to
+ * the source's real duration: word timings can run a few ms past the media's end,
+ * and the engine rejects out-of-range indices and source ranges.
+ */
+export async function appendClip(dir, source, startMs, endMs, track = "V1") {
+    const show = await projectShow(dir);
+    const duration = show.timeline.sources.find((s) => s.id === source)?.duration ?? Infinity;
+    const index = show.timeline.video_tracks.find((t) => t.id === track)?.clips.length ?? 0;
+    return engineCall("edit", {
+        dir,
+        action: {
+            type: "insert_clip",
+            track_id: track,
+            index,
+            clip: {
+                id: newClipId(),
+                source,
+                source_in: Math.max(0, secondsToTicks(startMs / 1000)),
+                source_out: Math.min(duration, secondsToTicks(endMs / 1000)),
+            },
+        },
+    });
+}
+export const projectInit = (dir, name) => engineCall("project.init", name ? { dir, name } : { dir });
+export const fpsValue = (fps) => fps.num / fps.den;
+export function formatSeconds(seconds) {
+    if (!Number.isFinite(seconds))
+        return "-";
+    const m = Math.floor(seconds / 60);
+    const s = seconds - m * 60;
+    return m > 0 ? `${m}:${s.toFixed(1).padStart(4, "0")}` : `${s.toFixed(1)}s`;
+}
+export function baseName(path) {
+    const parts = path.split(/[\\/]+/).filter(Boolean);
+    return parts[parts.length - 1] ?? path;
+}
+/** Collision-resistant clip id for new timeline clips. */
+export function newClipId() {
+    return `clip-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+}

package/dist/lib/services.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The licence runs natively (src-tauri/src/licence.rs behind the shell's `rightkit_license_*` commands).
+ * The renderer holds no token, key or device id: it reads fixed-schema views, sends the licence key or
+ * trial e-mail once as a command argument, and hears `rightkit://license-changed`. Native code authorizes
+ * every protected operation itself; a view is a display hint.
+ */
+export declare const licenseClient: {
+    status: () => Promise<import("@rightkit/license").LicenseView>;
+    activate: (key: string) => Promise<import("@rightkit/license").LicenseView>;
+    refresh: () => Promise<import("@rightkit/license").RefreshView>;
+    deactivate: () => Promise<import("@rightkit/license").LicenseView>;
+    requestTrial: (email: string) => Promise<import("@rightkit/license").TrialView>;
+    onChange(callback: (view: import("@rightkit/license").LicenseView) => void, onError?: (error: import("@rightkit/license").LicenseClientError) => void): Promise<import("@rightkit/license").LicenseUnlisten>;
+};
+export declare const logs: import("@rightkit/logs").LogsClient;
+export declare function setUpdateBusy(busy: boolean): void;
+export declare function restartAfterUpdate(): Promise<void>;
+/**
+ * Patch releases only. An entitlement-gated "update" release needs the licence's update authorization,
+ * which exists only natively (rightkit-tauri-shell `update-license`); the renderer no longer holds the
+ * tokens that authorization used to send, so those releases are refused here until the native updater
+ * replaces this client.
+ */
+export declare const updates: import("@rightkit/app-update").AutoUpdateClient;

package/dist/lib/services.js

@@ -0,0 +1,38 @@
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { createAutoUpdateClient } from "@rightkit/app-update";
+import { createLicenseClient } from "@rightkit/license";
+import { createLogsClient } from "@rightkit/logs";
+import { engineBusy } from "./engine.js";
+/**
+ * The licence runs natively (src-tauri/src/licence.rs behind the shell's `rightkit_license_*` commands).
+ * The renderer holds no token, key or device id: it reads fixed-schema views, sends the licence key or
+ * trial e-mail once as a command argument, and hears `rightkit://license-changed`. Native code authorizes
+ * every protected operation itself; a view is a display hint.
+ */
+export const licenseClient = createLicenseClient({ invoke, listen });
+export const logs = createLogsClient({ invoke, allowedFields: ["surface", "state", "code"] });
+let updateBusy = false;
+export function setUpdateBusy(busy) {
+    updateBusy = busy;
+}
+export async function restartAfterUpdate() {
+    const { relaunch } = await import("@tauri-apps/plugin-process");
+    await relaunch();
+}
+/**
+ * Patch releases only. An entitlement-gated "update" release needs the licence's update authorization,
+ * which exists only natively (rightkit-tauri-shell `update-license`); the renderer no longer holds the
+ * tokens that authorization used to send, so those releases are refused here until the native updater
+ * replaces this client.
+ */
+export const updates = createAutoUpdateClient({
+    check: async (options) => {
+        const { check } = await import("@tauri-apps/plugin-updater");
+        return check(options);
+    },
+    // Closing a project also stops preview; engine calls cover background requests from other views.
+    canInstall: () => !updateBusy && !engineBusy(),
+    deferReason: () => "Close your project & finish media work before installing an update.",
+    isEligible: (tier) => tier === "patch",
+});

package/dist/lib/settingsBackend.d.ts

@@ -0,0 +1,2 @@
+import type { SettingsBackend } from "@rightkit/settings-ui";
+export declare function createHostSettingsBackend(): SettingsBackend;

package/dist/lib/settingsBackend.js

@@ -0,0 +1,57 @@
+import { errorCode, errorMessage } from "./engine.js";
+import { settingsGet, settingsSet } from "./media.js";
+import { themeStore } from "./shell.js";
+/**
+ * RightKit settings port over the engine's app-level settings file (the same
+ * store the engine reads for finishing defaults, project folder, the host app
+ * path). `appearance.theme` is mirrored from the app-shell theme store, which
+ * stays the single owner of the theme choice. `null` removes a key.
+ */
+const asError = (e) => {
+    throw e instanceof Error ? e : Object.assign(new Error(errorMessage(e)), { code: errorCode(e) });
+};
+export function createHostSettingsBackend() {
+    // The store's revision is a fingerprint of the file that can exceed 2^53, so the engine reports
+    // it as a string. The kit sees a number: each snapshot gets a token, remembered with the engine's
+    // revision it stands for, and a patch that names a token we did not hand out is stale.
+    let token = 0;
+    const revisions = new Map();
+    const snapshot = (values, engineRevision) => {
+        token += 1;
+        revisions.set(token, engineRevision);
+        revisions.delete(token - 32);
+        return { values: { ...values, "appearance.theme": themeStore.read() }, revision: token };
+    };
+    return {
+        // The engine rejects with a {code, message} object; the settings kit shows
+        // `Error.message`, so every failure leaves here as an Error.
+        async load() {
+            const s = await settingsGet().catch(asError);
+            return snapshot(s.app, s.revision);
+        },
+        async patch(patch, expectedRevision) {
+            const rest = {};
+            for (const [k, v] of Object.entries(patch)) {
+                if (k === "appearance.theme")
+                    continue; // themeStore persisted it
+                rest[k] = v;
+            }
+            let expected;
+            if (expectedRevision !== undefined) {
+                expected = revisions.get(expectedRevision);
+                if (expected === undefined) {
+                    throw Object.assign(new Error("Settings changed since they were read."), { code: "revision_conflict" });
+                }
+            }
+            const r = await (Object.keys(rest).length
+                ? settingsSet(rest, undefined, expected)
+                : settingsGet().then((s) => ({ settings: s.app, revision: s.revision }))).catch((e) => {
+                if (e && typeof e === "object" && e.code === "revision_conflict") {
+                    throw Object.assign(new Error(errorMessage(e)), { code: "revision_conflict" });
+                }
+                return asError(e);
+            });
+            return snapshot(r.settings, r.revision);
+        },
+    };
+}

package/dist/lib/shell.d.ts

@@ -0,0 +1,171 @@
+import { type AppShellBridge } from "@rightkit/react-shell";
+/** Persisted light/dark/system choice (same key the pre-RightKit app used, so
+ *  existing users keep their theme). */
+export declare const themeStore: {
+    read: () => import("@rightkit/react-shell").ThemeChoice;
+    resolved: (choice?: import("@rightkit/react-shell").ThemeChoice) => import("@rightkit/react-shell").ResolvedTheme;
+    apply: (choice: import("@rightkit/react-shell").ThemeChoice) => void;
+    save: (choice: import("@rightkit/react-shell").ThemeChoice) => void;
+    subscribe: (listener: (choice: import("@rightkit/react-shell").ThemeChoice) => void) => () => void;
+    dispose: () => void;
+};
+export declare const shell: {
+    ready: () => Promise<{
+        background: boolean;
+        appId: string;
+        appName: string;
+        engine: {
+            state: 'starting' | 'ready' | 'error';
+            hello?: unknown;
+            code?: string;
+            message?: string;
+        } | null;
+    }>;
+    status: () => Promise<import("@rightkit/tauri-shell").ShellStatus>;
+    capabilities: () => Promise<import("@rightkit/tauri-shell").ShellCapabilities>;
+    quit: (quitOptions?: import("@rightkit/tauri-shell").QuitOptions) => Promise<import("@rightkit/tauri-shell").QuitReport>;
+    onQuitRequested: (handler: import("@rightkit/tauri-shell").QuitHandler) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    openExternal: (url: string) => Promise<void>;
+    window: {
+        do: (action: import("@rightkit/tauri-shell").WindowAction) => Promise<void>;
+        minimize: () => Promise<void>;
+        toggleMaximize: () => Promise<void>;
+        close: () => Promise<void>;
+        startDrag: () => Promise<void>;
+        open: (spec: import("@rightkit/tauri-shell").WindowSpec) => Promise<string>;
+        trafficLights: (dx: number, dy: number) => Promise<void>;
+    };
+    menu: {
+        setEnabled: (id: string, enabled: boolean) => Promise<void>;
+        setChecked: (id: string, checked: boolean) => Promise<void>;
+        setState: (updates: import("@rightkit/tauri-shell").MenuItemState[]) => Promise<void>;
+        onClick: (h: (id: string) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    };
+    tray: {
+        update: (update: import("@rightkit/tauri-shell").TrayUpdate) => Promise<void>;
+        onEvent: (h: (e: {
+            kind: 'menu';
+            id: string;
+        } | {
+            kind: 'click';
+        }) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+        onCustom: (name: string, h: (payload: unknown) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    };
+    deepLinks: {
+        on: (h: (link: import("@rightkit/tauri-shell").DeepLink) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    };
+    onSecondInstance: (h: (e: {
+        argv: string[];
+        cwd: string;
+    }) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    onStall: (h: (e: {
+        stalledMs: number;
+        thresholdMs: number;
+    }) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    autostart: {
+        get: () => Promise<import("@rightkit/tauri-shell").AutostartStatus>;
+        set: (enabled: boolean) => Promise<import("@rightkit/tauri-shell").AutostartStatus>;
+        openLoginItemsSettings: () => Promise<void>;
+    };
+    clipboard: {
+        read: (board?: string) => Promise<import("@rightkit/tauri-shell").ClipboardContent>;
+        write: (c: import("@rightkit/tauri-shell").ClipboardContent) => Promise<void>;
+        item: () => Promise<import("@rightkit/tauri-shell").ClipboardItem>;
+    };
+    notifications: {
+        post: (request: import("@rightkit/tauri-shell").NotificationRequest) => Promise<import("@rightkit/tauri-shell").NotifyOutcome>;
+        status: () => Promise<import("@rightkit/tauri-shell").NotifyStatus>;
+        clear: (ids?: string[]) => Promise<void>;
+        setBadge: (count: number) => Promise<number>;
+    };
+    presence: {
+        state: () => Promise<import("@rightkit/tauri-shell").PresenceState>;
+        setDnd: (enabled: boolean) => Promise<import("@rightkit/tauri-shell").PresenceState>;
+        setAuto: (prefs: import("@rightkit/tauri-shell").AutoPrefs) => Promise<import("@rightkit/tauri-shell").PresenceState>;
+        probe: () => Promise<{
+            environment: import("@rightkit/tauri-shell").Environment;
+            windows: number;
+            supported: boolean;
+        }>;
+        evaluate: (monitor: import("@rightkit/tauri-shell").Rect, windows: import("@rightkit/tauri-shell").WindowObservation[], apply?: boolean) => Promise<{
+            environment: import("@rightkit/tauri-shell").Environment;
+            state: import("@rightkit/tauri-shell").PresenceState;
+        }>;
+        onChange: (h: (s: import("@rightkit/tauri-shell").PresenceState) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    };
+    idle: {
+        status: () => Promise<import("@rightkit/tauri-shell").IdleStatus>;
+        note: (hidden: boolean) => Promise<void>;
+        onChange: (h: (e: {
+            state: 'hidden' | 'visible' | 'suspended' | 'resumed';
+        }) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    };
+    paths: {
+        require: (path: string, write?: boolean) => Promise<string>;
+        revoke: (path: string) => Promise<void>;
+        grantRecent: (id: string) => Promise<string>;
+        regrantSaved: (path: string) => Promise<string>;
+        streamUrl: (path: string) => Promise<{
+            id: string;
+            url: string;
+        }>;
+    };
+    openPaths: {
+        ready: () => Promise<string[]>;
+        onOpen: (h: (e: {
+            paths: string[];
+        }) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    };
+    associations: {
+        status: (groups?: string[]) => Promise<import("@rightkit/tauri-shell").AssociationStatus>;
+        set: (groups?: string[], timeoutMs?: number) => Promise<import("@rightkit/tauri-shell").AssociationSetResult>;
+        openDefaultApps: () => Promise<void>;
+    };
+    print: (ui?: import("@rightkit/tauri-shell").PrintUi) => Promise<void>;
+    onPrintError: (h: (message: string) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    recovery: {
+        save: (snapshot: unknown) => Promise<void>;
+        load: <T = unknown>() => Promise<T | null>;
+        clear: () => Promise<void>;
+    };
+    site: {
+        grant: (document: string) => Promise<import("@rightkit/tauri-shell").SiteGrant>;
+        revoke: (token: string) => Promise<void>;
+    };
+    surface: {
+        set: (surface: string) => Promise<import("@rightkit/tauri-shell").SurfaceReport>;
+    };
+    preview: {
+        register: (kind: string, html: string) => Promise<import("@rightkit/tauri-shell").PreviewHandle>;
+        revoke: (token: string) => Promise<void>;
+        revokeAll: () => Promise<void>;
+    };
+    legal: {
+        read: () => Promise<import("@rightkit/tauri-shell").LegalReceiptRecord | null>;
+        create: (request: import("@rightkit/tauri-shell").LegalReceiptCreateRequest) => Promise<import("@rightkit/tauri-shell").LegalReceiptRecord>;
+        reset: () => Promise<void>;
+    };
+    update: {
+        check: () => Promise<import("@rightkit/tauri-shell").UpdateHostCheck>;
+        status: () => Promise<import("@rightkit/tauri-shell").UpdateHostStatus>;
+        download: (handleId: string) => Promise<import("@rightkit/tauri-shell").UpdateHostDownload>;
+        install: (handleId: string) => Promise<import("@rightkit/tauri-shell").UpdateHostInstall>;
+        cancel: (handleId: string) => Promise<{
+            cancelled: boolean;
+        }>;
+        onProgress: (h: (p: import("@rightkit/tauri-shell").UpdateHostProgress) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    };
+    engine: {
+        call: <T = unknown>(method: string, params?: unknown) => Promise<T>;
+        callTagged: <T = unknown>(method: string, params?: unknown, tag?: string) => Promise<T>;
+        status: () => Promise<import("@rightkit/tauri-shell").EngineStatus | null>;
+        onEvent: (h: (e: import("@rightkit/tauri-shell").EngineEvent) => void) => Promise<import("@rightkit/tauri-shell").Unlisten>;
+    };
+    bridge: () => import("@rightkit/tauri-shell").ShellBridge;
+};
+/** Native side of @rightkit/react-shell: caption buttons on Windows; macOS draws
+ *  its traffic lights through the overlay title bar. The caption actions reach the
+ *  host's `rk_shell_window` command (rightkit-tauri-shell) through @rightkit/tauri-shell. */
+export declare const shellBridge: AppShellBridge;
+/** Quits the app at once through the shell host (`rk_shell_quit`): no drain handlers run. */
+export declare const quitNow: () => Promise<import("@rightkit/tauri-shell").QuitReport>;