@rightkit/system-ui 0.0.0-stage → 0.1.0

package/dist/api.js

@@ -0,0 +1,296 @@
+import { invoke } from "@tauri-apps/api/core";
+import { getPlatform } from "@rightkit/platform-ui";
+import { formatBytes } from "@rightkit/settings-ui/core";
+/** True in the Windows webview: the hub runs one page on both systems and a few strings differ. */
+export const isWindows = getPlatform() === "windows";
+export const api = {
+    status: () => invoke("status"),
+    processes: () => invoke("processes"),
+    scan: (path) => invoke("scan", { path: path ?? null }),
+    scanStatus: () => invoke("scan_status"),
+    lastScan: () => invoke("last_scan"),
+    growth: () => invoke("growth"),
+    children: (path) => invoke("children", { path }),
+    /** `minBytes` keeps only items larger than that many bytes. */
+    search: (query, limit, extensions, minBytes) => invoke("search", { query, limit: limit ?? null, extensions: extensions ?? null, minBytes: minBytes ?? null, changed: null }).then((r) => r.rows),
+    /** `search` with a modified-time range; says how many matches had no date. */
+    searchChanged: (query, minBytes, changed, limit) => invoke("search", { query, limit: limit ?? null, extensions: null, minBytes: minBytes ?? null, changed: changed ?? null }),
+    diskIndexStatus: () => invoke("disk_index_status"),
+    diskIndexSizes: (paths) => invoke("disk_index_sizes", { paths }),
+    apps: () => invoke("apps_list"),
+    appDetail: (path) => invoke("app_detail", { path }),
+    uninstall: (path, bundleId, items) => invoke("app_uninstall", { path, bundleId, items }),
+    processRows: () => invoke("process_rows"),
+    quit: (r) => invoke("process_quit", { key: r.key, pid: r.lead.pid, startTime: r.lead.start_time }),
+    forceQuit: (r) => invoke("process_force_quit", { key: r.key, pid: r.lead.pid, startTime: r.lead.start_time }),
+    /** Listening ports and open files of one process, read now. Nothing is sampled in the background. */
+    inspectProcess: (r) => invoke("process_inspect", { pid: r.lead.pid, startTime: r.lead.start_time }),
+    volumes: () => invoke("volumes"),
+    eject: (mount) => invoke("eject", { mount }),
+    /** Opens the Full Disk Access pane in System Settings. */
+    openFullDiskAccess: () => invoke("fda_request"),
+    fullDiskAccessStatus: () => invoke("fda_status"),
+    cleanupScan: () => invoke("cleanup_scan"),
+    /** The last saved findings, or null when none were saved. Never scans. */
+    cleanupCached: () => invoke("cleanup_cached"),
+    cleanupApply: (items) => invoke("cleanup_apply", {
+        items: items.map((f) => ({ rule_id: f.rule_id, path: f.path, dev: f.dev, ino: f.ino })),
+    }),
+    cleanupRestore: (id) => invoke("cleanup_restore", { id }),
+    reveal: (path) => invoke("reveal", { path }),
+    /** Device and inode of an item now; the file actions check them again before acting. */
+    fileIdentity: (path) => invoke("file_identity", { path }),
+    /** Opens a folder, or selects a file, in Finder. Read-only. */
+    finderOpen: (path) => invoke("finder_open", { path }),
+    /** The native folder picker; null when cancelled. */
+    fileChooseFolder: () => invoke("file_choose_folder"),
+    fileMovePlan: (path, id, destination) => invoke("file_move_plan", { path, dev: id.dev, ino: id.ino, destination }),
+    /** Renames within one drive; across drives, copies then trashes the original when copyAcrossVolumes is set. */
+    fileMove: (path, id, destination, copyAcrossVolumes) => invoke("file_move", { path, dev: id.dev, ino: id.ino, destination, copyAcrossVolumes }),
+    fileTrash: (path, id) => invoke("file_trash", { path, dev: id.dev, ino: id.ino }),
+    mediaCompressStatus: () => invoke("media_compress_status"),
+    mediaCompress: (path, options) => invoke("media_compress", { path, options }),
+    /** Facts the scan does not hold for one item: read-only, one path, never recursive. */
+    storageInspect: (path) => invoke("storage_inspect", { path }),
+    /** The raw bytes of one image for the inspector's preview; rejects with the reason when there is no preview. */
+    storagePreview: (path) => invoke("storage_preview", { path }),
+    /** Drive health for these mounts; samples smartctl only when ten minutes have passed. */
+    driveHealth: (mounts) => invoke("drive_health", { mounts }),
+    /** Read-only merge of the records each feature keeps; newest first, at most `limit` rows older than `before`. */
+    activityTimeline: (limit, before) => invoke("activity_timeline", { limit, before }),
+    homePath: () => invoke("home_path"),
+    duplicatesScan: (path) => invoke("duplicates_scan", { path }),
+    /** Moves each extra copy to the Trash after re-checking it; the kept copy is never touched. */
+    duplicatesTrash: (items) => invoke("duplicates_trash", { items }),
+};
+/** Decimal byte count ("1.5 GB"), or "—" when the value is unknown. */
+export function bytes(n) {
+    return n == null ? "—" : formatBytes(n);
+}
+/** "136.3 GB more reclaimable by macOS" when it is at least 1 GB and 2% of the drive, else null. */
+export function reclaimableNote(v) {
+    const r = v.reclaimable_bytes;
+    if (r == null || v.total_bytes == null || v.total_bytes <= 0)
+        return null;
+    return r >= 1e9 && r >= v.total_bytes * 0.02 ? `${bytes(r)} more reclaimable by macOS` : null;
+}
+/** Saved results older than this refresh in the background when their view opens. */
+const STALE_SECS = 10 * 60;
+/** True when a saved result (Unix seconds) is old enough to refresh. */
+export function isStale(secs) {
+    return Date.now() / 1000 - secs > STALE_SECS;
+}
+/** "just now", "5 min ago", "2 h ago", or the date for anything older. */
+export function ago(secs) {
+    const elapsed = Math.max(0, Date.now() / 1000 - secs);
+    if (elapsed < 90)
+        return "just now";
+    if (elapsed < 3600)
+        return `${Math.round(elapsed / 60)} min ago`;
+    if (elapsed < 86400)
+        return `${Math.round(elapsed / 3600)} h ago`;
+    return new Date(secs * 1000).toLocaleDateString(undefined, { month: "short", day: "numeric" });
+}
+/** Colour for a 0–1 share, matching the notch rings. */
+export function tone(fraction) {
+    if (fraction >= 0.85)
+        return "var(--rk-bad)";
+    if (fraction >= 0.6)
+        return "var(--rk-warn)";
+    return "var(--rk-ok)";
+}
+export function signedBytes(n) {
+    return `${n < 0 ? "−" : "+"}${bytes(Math.abs(n))}`;
+}
+export const appsApi = {
+    cached: () => invoke("apps_cached"),
+    refresh: () => invoke("apps_refresh"),
+    summary: (path) => invoke("app_summary", { path }),
+    leftovers: (path) => invoke("app_leftovers", { path }),
+    /** Cached icons by path; the rest arrive as `apps-icon` events. */
+    icons: (paths) => invoke("app_icons", { paths }),
+    updatesCached: () => invoke("apps_updates_cached"),
+    updatesRefresh: (force) => invoke("apps_updates_refresh", { force }),
+    /** Returns "running", "opened" or "store". */
+    update: (path) => invoke("app_update", { path }),
+    /** Startup and login items, read only. Called when the Starts by itself section opens. */
+    startupItems: () => invoke("startup_items"),
+};
+export const shareApi = {
+    state: () => invoke("share_state"),
+    devices: () => invoke("share_devices"),
+    /** Send files and/or text to a device (by fingerprint). Resolves with the transfer id. */
+    send: (to, paths, text) => invoke("share_send", { to, paths, text }),
+    accept: (id) => invoke("share_accept", { id }),
+    decline: (id) => invoke("share_decline", { id }),
+    cancel: (id) => invoke("share_cancel", { id }),
+    dismiss: (id) => invoke("share_dismiss", { id }),
+    /**
+     * Events from the service: `share-devices` (ShareDevice[]), `share-incoming` (ShareIncoming),
+     * `share-incoming-resolved` (id), `share-progress` (ShareTransfer).
+     */
+};
+// ---- devices (device link; the resident engine's `device.*` methods, hub/src-tauri/src/commands.rs) ----
+/** Effect classes a paired device may request (`agent/effect.rs`, kebab-case). */
+export const DEVICE_GRANT_CLASSES = ["reversible", "irreversible-destruction", "spend", "publication"];
+/** The engine's refusal text is `code: message`; these codes mean the owner check wants a (new) PIN. */
+export const OWNER_CHECK_CODES = /^(unlock_needs_auth|pin_not_set|pin_wrong|pin_locked|pin_invalid): (.*)$/s;
+export const devicesApi = {
+    list: () => invoke("device_list"),
+    pending: () => invoke("device_pair_pending"),
+    /** Opens a phone pairing. The engine checks the owner (`pin`, the the host app PIN) first. */
+    pairStart: (pin, proof) => invoke("device_pair_start", { pin: pin ?? null, challenge: proof?.challenge ?? null, sig: proof?.sig ?? null }),
+    /** Joins the computer whose owner made `token` (`pulse-join:1:...`); nothing else is asked. */
+    joinWith: (token) => invoke("device_join", { token }),
+    /** The engine checks the owner itself: `pin` is the the host app PIN. Without it the engine refuses `unlock_needs_auth`. */
+    pairApprove: (pairingId, pin, proof) => invoke("device_pair_approve", { pairingId, pin: pin ?? null, challenge: proof?.challenge ?? null, sig: proof?.sig ?? null }),
+    /** Grants or takes away a computer's `admit` (it may add devices for the circle); owner-checked like Add a device. */
+    admitSet: (deviceId, allowed, pin, proof) => invoke("device_admit_set", { deviceId, allowed, pin: pin ?? null, challenge: proof?.challenge ?? null, sig: proof?.sig ?? null }),
+    /** The enrolled owner-check keys (`remote.owner.key.status`; the Mac notch's and Windows Hello's). */
+    ownerKeys: () => invoke("owner_key_status"),
+    /** Confirms this computer's owner-check key (binds it to this device) with one owner check. Windows signs in the hub; the Mac's notch signs (`notch_command`, `signOwnerChallenge`, op `bind`). */
+    ownerKeyBind: () => invoke("owner_key_bind"),
+    /** Removes one owner-check key; the engine checks `pin`. */
+    ownerKeyRevoke: (keyId, pin) => invoke("owner_key_revoke", { keyId, pin }),
+    /** "Add a device": the engine checks `pin` (the the host app PIN) first, then makes one join command valid for ten minutes. */
+    joinCreate: (pin, proof) => invoke("device_join_create", { pin: pin ?? null, challenge: proof?.challenge ?? null, sig: proof?.sig ?? null }),
+    /** "Make a guest link" (#492): the same owner check as Add a device, then one single-use link for a cloud box. */
+    guestCreate: (leaseMs, pin, proof) => invoke("device_guest_create", { pin: pin ?? null, challenge: proof?.challenge ?? null, sig: proof?.sig ?? null, leaseMs }),
+    guests: () => invoke("device_guest_list"),
+    /** Owner UI only: makes a pending cloud agent one of your machines until its lease ends. */
+    guestApprove: (deviceId) => invoke("device_guest_approve", { deviceId }),
+    /** Voids the open join command. */
+    joinCancel: () => invoke("device_join_cancel"),
+    pairReject: (pairingId) => invoke("device_pair_reject", { pairingId }),
+    revoke: (deviceId) => invoke("device_revoke", { deviceId }),
+    phoneAccess: () => invoke("device_phone_access"),
+    /** `read` allow|deny|default; `send` allow|ask|deny|default; omit one to leave it. */
+    phoneAccessSet: (deviceId, change) => invoke("device_phone_access_set", { deviceId, ...change }),
+    /** Off revokes the phone's approval key first (system prompt); rejects if cancelled, leaving admin on. */
+    phoneAdminSet: (deviceId, allow) => invoke("device_phone_admin_set", { deviceId, allow }),
+    phoneAsks: () => invoke("device_phone_asks"),
+    phoneAnswer: (askId, allow) => invoke("device_phone_answer", { askId, allow }),
+    computerName: () => invoke("device_computer_name"),
+    /** `revision` is the one the device was read at; `expiresAtMs` null means no expiry. */
+    grantsSet: (deviceId, revision, classes, expiresAtMs) => invoke("device_grants_set", { deviceId, revision, classes, expiresAtMs }),
+};
+/** The engine answers `remote.approvals.pending` with `{ items: [...] }` (engine/src/contract.rs); a bare list or `{ approvals }` is read too. */
+export function pendingApprovals(answer) {
+    const wrapped = answer;
+    const list = Array.isArray(answer) ? answer : (wrapped?.items ?? wrapped?.approvals);
+    return Array.isArray(list) ? list.filter((a) => a && typeof a.id === "string") : [];
+}
+export const remoteApprovalsApi = {
+    pending: () => invoke("remote_approvals_pending"),
+    /** Approves or denies one pending request, bound to the item as displayed (the engine compares a digest of its fields). Owner UI only: the engine checks that the caller is the the host app hub. */
+    decide: (a, approve, pin) => invoke("remote_approval_decide", {
+        id: a.id,
+        approve,
+        pin: approve ? pin ?? "" : null,
+        kind: a.kind,
+        scope: a.scope,
+        origin: a.origin,
+        bind: a.bind,
+        summary: a.summary,
+    }),
+};
+/** The per-chat unlock: the the host app PIN and the owner's answer to an unlock request (`scope === "unlock"`). Never log or keep a PIN. */
+export const remoteUnlockApi = {
+    pinStatus: () => invoke("remote_unlock_pin_status"),
+    /** `current` is needed only when a PIN is already set. */
+    pinSet: (pin, current) => invoke("remote_unlock_pin_set", { pin, current: current || null }),
+    /** Denies, or approves with the the host app PIN (the hub cannot show the system prompt). */
+    decide: (a, approve, pin) => invoke("remote_unlock_decide", {
+        args: {
+            id: a.id,
+            approve,
+            kind: a.kind,
+            scope: a.scope,
+            origin: a.origin,
+            bind: a.bind,
+            summary: a.summary,
+            pin: approve ? pin ?? "" : null,
+        },
+    }),
+};
+/** The rows a list call answers: a bare list, or the list under `items` or the given key. */
+export function browserRows(answer, key) {
+    if (Array.isArray(answer))
+        return answer;
+    const wrapped = answer;
+    const list = wrapped?.items ?? (key ? wrapped?.[key] : undefined);
+    return Array.isArray(list) ? list : [];
+}
+export const browserRemoteApi = {
+    pending: (device) => invoke("browser_remote_pending", { device }),
+    /** A single-use nonce for one approval (valid for 60 seconds). */
+    challenge: (device, id) => invoke("browser_remote_challenge", { device, id }),
+    approve: (device, id, nonce) => invoke("browser_remote_approve", { device, id, nonce }),
+    deny: (device, id) => invoke("browser_remote_deny", { device, id }),
+    sessions: (device) => invoke("browser_remote_sessions", { device }),
+    frame: (device, session, afterSeq) => invoke("browser_remote_frame", { device, session, afterSeq }),
+    input: (device, session, events) => invoke("browser_remote_input", { device, session, events }),
+    /** Hands the session back to the agent. */
+    done: (device, session) => invoke("browser_remote_done", { device, session }),
+};
+/**
+ * The agent secure box (#345 logins, #346 virtual cards). The renderer sends only non-secret fields and the PIN;
+ * the username, password, card number, name, expiry and CVC are typed into a system dialog opened by the command
+ * and go straight to the engine, so no secret ever exists in this page.
+ */
+export const secureBoxApi = {
+    list: () => invoke("remote_secure_list"),
+    remove: (id) => invoke("remote_secure_remove", { id }),
+    saveLogin: (label, host, pin, withTotp = false) => invoke("remote_secure_save_login", { label, host, pin, withTotp }),
+    /** Adds or replaces a saved login's one-time code; the secret is typed into the system dialog. */
+    setTotp: (id, host, pin) => invoke("remote_secure_set_totp", { id, host, pin }),
+    saveCard: (c, pin) => invoke("remote_secure_save_card", { ...c, pin }),
+};
+/** The sentence the Devices page shows when the engine refuses pairing with `listen_off`. */
+export const LISTEN_OFF_SENTENCE = "Turn on Settings > Devices > Accept device links (LAN only) on this computer first.";
+/** The engine's `listen_off` refusal (engine/src/devicelink_host.rs, pair_start). The hub's engine link
+ *  passes only the refusal's message, not its code, so the message text identifies it. */
+export function isListenOff(e) {
+    const text = typeof e === "string" ? e : e instanceof Error ? e.message : String(e);
+    return text.startsWith("listen_off:") || text.includes("turn on Accept device links first");
+}
+/** The owner-only security settings (`PROTECTED_KEYS`, core/src/remote/settings.rs; listed in docs/settings.md).
+ *  A `hub-commands` file never changes them: they go through the engine's owner check (`remote_setting_set`). */
+const PROTECTED_KEYS = new Set([
+    "chatUnlock", "chatUnlockMinutes", "remoteBlockedApps", "agentActions", "agentCliPath", "agentBrowser", "agentBrowserSessionMinutes", "remoteRoots", "remoteGateway",
+    "remoteChatRead", "phoneChatReadAll", "remoteDocs", "remoteLaunch", "remoteMedia",
+    "remoteReadMaxBytes", "remoteFindMaxResults", "remoteChatReadMaxTurns", "remoteChatReadMaxBytes", "remoteImageMaxBytes", "remoteDocsMaxBytes",
+    "remoteFormFill", "remoteFormFillStanding", "remoteFormFillProfile", "remoteScreenObserve", "remoteScreenAct",
+    "remoteScreenDisclosure", "remoteTerminals", "remoteTermStanding", "remoteTermAllow", "remoteTermDeny",
+    "remoteClipboard", "remoteReadOnly", "ledgerTranscriptSearch", "ledgerTranscriptShare", "remoteFilesWrite", "remoteTools",
+]);
+/** `PROTECTED_PREFIXES` in core: every key under one of these is owner-only too. */
+const PROTECTED_PREFIXES = ["remoteFormFill", "remoteScreen"];
+export const isProtectedKey = (key) => PROTECTED_KEYS.has(key) || PROTECTED_PREFIXES.some((prefix) => key.startsWith(prefix));
+let pinListener = null;
+export function onProtectedPin(fn) {
+    pinListener = fn;
+}
+/** Sends one protected change to the engine. Without a PIN a change that loosens a gate is refused with
+ *  `unlock_needs_auth`; that opens the PIN prompt (`ProtectedPinPrompt`). Never logs or keeps the PIN. */
+export async function setProtectedSetting(key, value, pin) {
+    try {
+        await invoke("remote_setting_set", { key, value, pin: pin ? pin : null });
+        pinListener?.(null);
+    }
+    catch (e) {
+        const text = typeof e === "string" ? e : e instanceof Error ? e.message : String(e);
+        const m = /^(unlock_needs_auth|pin_not_set|pin_wrong|pin_locked|pin_invalid): (.*)$/s.exec(text);
+        if (m && pinListener)
+            pinListener({ key, value, problem: pin || m[1] !== "unlock_needs_auth" ? m[2] : null });
+        else
+            throw e;
+    }
+}
+/** Sets one notch setting the way the Settings page does: `notch_command` with a `set` command
+ *  (a protected key goes through the engine instead). */
+export function setNotchSetting(key, value) {
+    if (isProtectedKey(key))
+        return setProtectedSetting(key, value);
+    return invoke("notch_command", { command: { command: "set", key, value } });
+}

package/dist/chart.d.ts

@@ -0,0 +1,14 @@
+export type KindId = "apps" | "downloads" | "developer" | "caches" | "media" | "documents" | "appdata" | "system" | "mixed";
+export declare const KINDS: Record<KindId, {
+    label: string;
+    color: string;
+}>;
+export declare function kindOf(path: string, isDir: boolean): KindId;
+export interface Tile {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Squarified treemap. `values` must be positive and sorted largest first. */
+export declare function squarify(values: number[], W: number, H: number): Tile[];

package/dist/chart.js

@@ -0,0 +1,94 @@
+// Kinds and the treemap layout for the Storage view.
+//
+// Adapted from Petal (https://github.com/henrydennis/petal, MIT; pinned in docs/donors.md):
+//  - the nine kinds and their colours are Petal's `src/classify/mod.rs` and
+//    `classify/model.rs`. Petal judges kind with a small trained model; this
+//    uses plain path rules instead, so a wrong guess only costs a wrong
+//    colour. It never decides what is safe to delete.
+//  - `squarify` is the squarified treemap (Bruls, Huizing and van Wijk) that
+//    Petal's `src/treemap.rs` lays tiles out with, rewritten for SVG.
+export const KINDS = {
+    apps: { label: "Apps", color: "#d95926" },
+    downloads: { label: "Downloads & Trash", color: "#3987e5" },
+    developer: { label: "Developer files", color: "#008300" },
+    caches: { label: "Caches & logs", color: "#199e70" },
+    media: { label: "Photos, video & music", color: "#d55181" },
+    documents: { label: "Documents", color: "#c98500" },
+    appdata: { label: "App data & backups", color: "#9085e9" },
+    system: { label: "System", color: "#5b5e66" },
+    mixed: { label: "Other", color: "#6b6e78" },
+};
+const MEDIA_EXT = /\.(mov|mp4|m4v|mkv|avi|mp3|m4a|wav|flac|jpg|jpeg|png|heic|raw|cr2|dng|photoslibrary|musiclibrary|fcpbundle)$/i;
+const DEV_NAMES = new Set([
+    "node_modules", "target", ".build", "DerivedData", ".git", ".cargo", ".rustup", ".npm", ".pnpm-store",
+    ".gradle", ".nvm", "Developer", "Pods", "venv", ".venv", "dist",
+]);
+export function kindOf(path, isDir) {
+    const name = path.split("/").pop() ?? "";
+    const rel = path.replace(/^\/Users\/[^/]+/, "~");
+    if (rel.includes("/Library/Caches") || rel.includes("/Library/Logs") || name === ".cache" || name === "Caches")
+        return "caches";
+    if (rel.startsWith("/Applications") || /\.app$/.test(name))
+        return "apps";
+    if (DEV_NAMES.has(name) || rel.includes("/Library/Developer") || rel.includes("/node_modules/"))
+        return "developer";
+    if (rel.startsWith("~/Downloads") || rel.startsWith("~/.Trash"))
+        return "downloads";
+    if (MEDIA_EXT.test(name) || /^~\/(Movies|Music|Pictures)(\/|$)/.test(rel))
+        return "media";
+    if (/^~\/(Documents|Desktop)(\/|$)/.test(rel))
+        return "documents";
+    if (rel.startsWith("~/Library"))
+        return "appdata";
+    if (/^\/(System|private|usr|bin|sbin|var|opt|cores|Library)(\/|$)/.test(rel))
+        return "system";
+    return isDir ? "mixed" : "documents";
+}
+/** Squarified treemap. `values` must be positive and sorted largest first. */
+export function squarify(values, W, H) {
+    const total = values.reduce((a, b) => a + b, 0);
+    const out = values.map(() => ({ x: 0, y: 0, w: 0, h: 0 }));
+    if (total <= 0)
+        return out;
+    const areas = values.map((v) => (v / total) * W * H);
+    const sum = (row) => row.reduce((a, b) => a + b, 0);
+    const worst = (row, side) => {
+        const s = sum(row);
+        return Math.max((side * side * Math.max(...row)) / (s * s), (s * s) / (side * side * Math.min(...row)));
+    };
+    let x = 0, y = 0, w = W, h = H, i = 0;
+    while (i < areas.length) {
+        const side = Math.min(w, h);
+        const row = [areas[i]];
+        let j = i + 1;
+        while (j < areas.length && worst([...row, areas[j]], side) <= worst(row, side)) {
+            row.push(areas[j]);
+            j++;
+        }
+        const s = sum(row);
+        if (w >= h) {
+            const cw = s / h;
+            let cy = y;
+            row.forEach((a, k) => {
+                const ch = a / cw;
+                out[i + k] = { x, y: cy, w: cw, h: ch };
+                cy += ch;
+            });
+            x += cw;
+            w -= cw;
+        }
+        else {
+            const rh = s / w;
+            let cx = x;
+            row.forEach((a, k) => {
+                const cw = a / rh;
+                out[i + k] = { x: cx, y, w: cw, h: rh };
+                cx += cw;
+            });
+            y += rh;
+            h -= rh;
+        }
+        i = j;
+    }
+    return out;
+}

package/dist/components/Chart.d.ts

@@ -0,0 +1,40 @@
+export interface Series {
+    label: string;
+    /** A CSS colour, normally a `var(--rk-…)`. */
+    color: string;
+    /** One value per time; null leaves a gap. */
+    values: (number | null)[];
+    dashed?: boolean;
+}
+/** Usage colour: below 70% ok, 70–90% warn, 90% and up bad. */
+export declare function levelColor(percent: number): string;
+/** A small inline line for a card. One or two series on a shared scale. */
+export declare function Sparkline({ label, series, max, minTop, height, format, minutes, }: {
+    label: string;
+    series: Series[];
+    /** Top of the scale. Omitted: the largest value, rounded up. */
+    max?: number;
+    /** Smallest top of an automatic scale. */
+    minTop?: number;
+    height?: number;
+    format?: (v: number) => string;
+    /** Only for the accessible summary. */
+    minutes?: number;
+}): import("react").JSX.Element;
+/**
+ * Time on x (the last `rangeMs` ending at the newest sample), value on y.
+ * Hover shows a vertical rule with the time and each series' value.
+ */
+export declare function AreaChart({ label, times, series, rangeMs, max, minTop, format, height, }: {
+    label: string;
+    /** Sample times, oldest first; every series has one value per time. */
+    times: number[];
+    series: Series[];
+    rangeMs: number;
+    /** Fixed top of the scale (100 for percentages). Omitted: the largest value, rounded up. */
+    max?: number;
+    /** Smallest top of an automatic scale. */
+    minTop?: number;
+    format: (v: number) => string;
+    height?: number;
+}): import("react").JSX.Element;

package/dist/components/Chart.js

@@ -0,0 +1,109 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+/** Usage colour: below 70% ok, 70–90% warn, 90% and up bad. */
+export function levelColor(percent) {
+    if (percent >= 90)
+        return "var(--rk-bad)";
+    if (percent >= 70)
+        return "var(--rk-warn)";
+    return "var(--rk-ok)";
+}
+/** Contiguous runs of known points, so a gap in the data is a gap in the line. */
+function runs(points) {
+    const out = [];
+    let run = [];
+    for (const p of points) {
+        if (p)
+            run.push(p);
+        else if (run.length) {
+            out.push(run);
+            run = [];
+        }
+    }
+    if (run.length)
+        out.push(run);
+    return out;
+}
+const fmt = (n) => n.toFixed(1);
+const line = (run) => run.map(([x, y], i) => `${i ? "L" : "M"}${fmt(x)} ${fmt(y)}`).join("");
+const area = (run, h) => `${line(run)}L${fmt(run[run.length - 1][0])} ${h}L${fmt(run[0][0])} ${h}Z`;
+function niceMax(v) {
+    if (v <= 0)
+        return 1;
+    const pow = 10 ** Math.floor(Math.log10(v));
+    const f = v / pow;
+    return (f <= 1 ? 1 : f <= 2 ? 2 : f <= 5 ? 5 : 10) * pow;
+}
+function known(series) {
+    return series.flatMap((s) => s.values.filter((v) => v != null));
+}
+function summary(label, series, format, minutes) {
+    const first = series[0];
+    if (!first)
+        return `${label}: no data yet`;
+    const all = known(series);
+    if (all.length === 0)
+        return `${label}: no data yet`;
+    const parts = series.map((s) => {
+        const v = [...s.values].reverse().find((x) => x != null);
+        return v == null ? null : `${series.length > 1 ? `${s.label} ` : ""}${format(v)}`;
+    });
+    return `${label}: now ${parts.filter(Boolean).join(", ")}; over the last ${minutes} minutes from ${format(Math.min(...all))} to ${format(Math.max(...all))}`;
+}
+/** A small inline line for a card. One or two series on a shared scale. */
+export function Sparkline({ label, series, max, minTop = 0, height = 28, format = (v) => `${Math.round(v)}`, minutes = 10, }) {
+    const W = 200;
+    const top = max ?? niceMax(Math.max(minTop, ...known(series)));
+    const n = Math.max(0, ...series.map((s) => s.values.length));
+    const x = (i) => (n <= 1 ? W : (i / (n - 1)) * W);
+    const y = (v) => 1.5 + (1 - Math.min(Math.max(v / top, 0), 1)) * (height - 3);
+    return (_jsx("svg", { className: "chart-spark", role: "img", "aria-label": summary(label, series, format, minutes), viewBox: `0 0 ${W} ${height}`, preserveAspectRatio: "none", style: { height }, children: series.map((s, si) => {
+            const pts = s.values.map((v, i) => (v == null ? null : [x(i), y(v)]));
+            return runs(pts).map((r, ri) => (_jsxs("g", { style: { color: s.color }, children: [si === 0 && r.length > 1 && _jsx("path", { className: "chart-fill", d: area(r, height) }), _jsx("path", { className: `chart-line${s.dashed ? " chart-dashed" : ""}`, d: line(r) })] }, `${si}-${ri}`)));
+        }) }));
+}
+const timeText = (t, seconds = true) => new Date(t).toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit", ...(seconds ? { second: "2-digit" } : {}) });
+/**
+ * Time on x (the last `rangeMs` ending at the newest sample), value on y.
+ * Hover shows a vertical rule with the time and each series' value.
+ */
+export function AreaChart({ label, times, series, rangeMs, max, minTop = 0, format, height = 120, }) {
+    const [hover, setHover] = useState(null);
+    const W = 600;
+    const end = times.length ? times[times.length - 1] : 0;
+    const from = Math.max(0, times.findIndex((t) => t >= end - rangeMs));
+    const visible = times.slice(from);
+    // With less history than the range, the samples we have fill the whole width.
+    const short = times.length > 0 && times[0] > end - rangeMs;
+    const start = short ? times[0] : end - rangeMs;
+    const span = Math.max(end - start, 1);
+    const shown = series.map((s) => ({ ...s, values: s.values.slice(from) }));
+    const top = max ?? niceMax(Math.max(minTop, ...known(shown)));
+    const x = (t) => ((t - start) / span) * W;
+    const y = (v) => 1.5 + (1 - Math.min(Math.max(v / top, 0), 1)) * (height - 3);
+    const minutes = Math.round(rangeMs / 60_000);
+    const move = (e) => {
+        if (visible.length === 0)
+            return;
+        const rect = e.currentTarget.getBoundingClientRect();
+        if (rect.width <= 0)
+            return;
+        const t = start + ((e.clientX - rect.left) / rect.width) * span;
+        let best = 0;
+        for (let i = 1; i < visible.length; i++) {
+            if (Math.abs(visible[i] - t) < Math.abs(visible[best] - t))
+                best = i;
+        }
+        setHover(best);
+    };
+    const at = hover != null && hover < visible.length ? hover : null;
+    const frac = at == null ? 0 : (visible[at] - start) / span;
+    const tipStyle = { left: `${frac * 100}%`, transform: frac > 0.6 ? "translateX(calc(-100% - 8px))" : "translateX(8px)" };
+    return (_jsxs("div", { className: "chart", children: [_jsxs("div", { className: "chart-row", children: [_jsxs("div", { className: "chart-yaxis", style: { height }, "aria-hidden": "true", children: [_jsx("span", { children: format(top) }), _jsx("span", { children: format(0) })] }), _jsxs("div", { className: "chart-plot", style: { height }, onPointerMove: move, onPointerLeave: () => setHover(null), onPointerCancel: () => setHover(null), children: [_jsxs("svg", { className: "chart-svg", role: "img", "aria-label": summary(label, shown, format, minutes), viewBox: `0 0 ${W} ${height}`, preserveAspectRatio: "none", children: [_jsx("line", { className: "chart-grid", x1: "0", x2: W, y1: y(top), y2: y(top) }), _jsx("line", { className: "chart-grid", x1: "0", x2: W, y1: y(top / 2), y2: y(top / 2) }), _jsx("line", { className: "chart-grid chart-base", x1: "0", x2: W, y1: height - 0.5, y2: height - 0.5 }), shown.map((s, si) => {
+                                        const pts = s.values.map((v, i) => (v == null ? null : [x(visible[i]), y(v)]));
+                                        return runs(pts).map((r, ri) => (_jsxs("g", { style: { color: s.color }, children: [si === 0 && r.length > 1 && _jsx("path", { className: "chart-fill", d: area(r, height) }), _jsx("path", { className: `chart-line${s.dashed ? " chart-dashed" : ""}`, d: line(r) })] }, `${si}-${ri}`)));
+                                    })] }), at != null && (_jsxs(_Fragment, { children: [_jsx("div", { className: "chart-rule", style: { left: `${frac * 100}%` }, "aria-hidden": "true" }), _jsxs("div", { className: "chart-tip", style: tipStyle, "aria-hidden": "true", children: [_jsx("span", { className: "chart-tip-time", children: timeText(visible[at]) }), shown.map((s) => {
+                                                const v = s.values[at];
+                                                return (_jsxs("span", { className: "chart-tip-row", children: [_jsx("i", { style: { background: s.color } }), s.label, ": ", v == null ? "no reading" : format(v)] }, s.label));
+                                            })] })] }))] })] }), _jsxs("div", { className: "chart-axis", "aria-hidden": "true", children: [_jsx("span", { children: short ? `since ${timeText(times[0], false)}` : `${minutes} min ago` }), _jsx("span", { children: "now" })] })] }));
+}

package/dist/env.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="vite/client" />
+
+declare module "*.css";
+declare module "*.svg" {
+  const src: string;
+  export default src;
+}
+declare module "*.png" {
+  const src: string;
+  export default src;
+}
+declare module "*.txt?raw" {
+  const text: string;
+  export default text;
+}
+declare module "*.tsv?raw" {
+  const text: string;
+  export default text;
+}
+declare module "*?url" {
+  const src: string;
+  export default src;
+}
+
+// Build-time switches a host may define (Vite `define`); every read is typeof-guarded.
+declare const __RIGHTKIT_QA__: boolean | undefined;
+declare const __RIGHTKIT_DEMO__: boolean | undefined;
+declare const __RIGHTKIT_MOCK__: boolean | undefined;
+declare const __APP_VERSION__: string | undefined;
+
+interface Window {
+  /** UI QA only: the data source a QA shell selects. */
+  __RIGHTKIT_QA_DATA_SOURCE__?: "engine";
+}
+
+// Host Vite plugin module with the legal documents shown in the first-run gate.
+declare module "virtual:rightkit-legal" {
+  export const LEGAL_DOCUMENTS: readonly { title: string; content: string }[];
+  export const LEGAL_VERSION: string;
+  export const LEGAL_DOCUMENTS_HASH: string;
+  export const LEGAL_RECEIPT_DOCUMENTS: readonly { id: string; role: string; version: string; sha256: string; treatment: string; material: boolean }[];
+}
+
+declare module "@rightkit-host/legal/legal-manifest.json" {
+  const manifest: {
+    documents: Array<{ id: string; role: string; title: string; publicUrl: string; version?: string; sha256?: string; [key: string]: unknown }>;
+    [key: string]: unknown;
+  };
+  export default manifest;
+}
+
+declare module "@rightkit-host/legal/legal-manifest.json?raw" {
+  const text: string;
+  export default text;
+}
+
+declare module "@rightkit-host/src/generated/legal-contract.json" {
+  const contract: { acceptanceVersion: string; materialSha256: string; [key: string]: unknown };
+  export default contract;
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+export * from "./activityLease.js";
+export * from "./api.js";
+export * from "./chart.js";
+export * from "./components/Chart.js";
+export * from "./kept.js";
+export * from "./lib/chatKind.js";
+export * from "./lib/legal.js";
+export * from "./lib/onboardingSettings.js";
+export * from "./lib/qr.js";
+export * from "./lib/rk.js";
+export * from "./metrics.js";
+export * from "./onboarding/flow.js";
+export * from "./onboarding/gate.js";
+export * from "./views/Activity.js";
+export * from "./views/Apps.js";
+export * from "./views/Chat.js";
+export * from "./views/ChromeSnapshots.js";
+export * from "./views/Cleanup.js";
+export * from "./views/DriveHealth.js";
+export * from "./views/Duplicates.js";
+export * from "./views/LauncherSettings.js";
+export * from "./views/NearbySettings.js";
+export * from "./views/Storage.js";
+export * from "./views/settingsKit.js";
+export * from "./views/storageEstimate.js";
+export * from "./visible.js";