@rightkit/system-ui 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,28 @@
+// Generated entry: every module whose exports do not collide with an earlier one.
+// Every module is also importable directly by subpath, e.g. `<package>/lib/foo`.
+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";

package/dist/kept.d.ts

@@ -0,0 +1,3 @@
+/** The hub's web view is destroyed on window close, so a view's selection is kept here (best effort). */
+export declare const readKept: <T>(key: string) => T | null;
+export declare const writeKept: (key: string, value: unknown | null) => void;

package/dist/kept.js

@@ -0,0 +1,21 @@
+/** The hub's web view is destroyed on window close, so a view's selection is kept here (best effort). */
+export const readKept = (key) => {
+    try {
+        const raw = localStorage.getItem(key);
+        return raw == null ? null : JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+};
+export const writeKept = (key, value) => {
+    try {
+        if (value == null)
+            localStorage.removeItem(key);
+        else
+            localStorage.setItem(key, JSON.stringify(value));
+    }
+    catch {
+        // Storage unavailable: the selection is lost on close, as before.
+    }
+};

package/dist/lib/chatKind.d.ts

@@ -0,0 +1,4 @@
+/** The chat kinds the host app knows, in the order grouped lists show them. Any other kind is listed after these. */
+export declare const CHAT_KIND_ORDER: readonly string[];
+/** The name a chat kind shows as: Claude, Codex, Muse, or any other kind with its first letter capitalised. */
+export declare function chatKindName(kind: string): string;

package/dist/lib/chatKind.js

@@ -0,0 +1,15 @@
+/** The chat kinds the host app knows, in the order grouped lists show them. Any other kind is listed after these. */
+export const CHAT_KIND_ORDER = ["claude", "codex", "muse"];
+/** The name a chat kind shows as: Claude, Codex, Muse, or any other kind with its first letter capitalised. */
+export function chatKindName(kind) {
+    switch (kind) {
+        case "claude":
+            return "Claude";
+        case "codex":
+            return "Codex";
+        case "muse":
+            return "Muse";
+        default:
+            return kind.charAt(0).toUpperCase() + kind.slice(1);
+    }
+}

package/dist/lib/legal.d.ts

@@ -0,0 +1,26 @@
+import { type LegalStepConfig } from "@rightkit/onboarding";
+/** What the host's `virtual:rightkit-legal` build module provides (@rightkit/legal's Vite plugin). */
+export interface HostLegal {
+    LEGAL_DOCUMENTS: readonly {
+        title: string;
+        content: string;
+    }[];
+    LEGAL_VERSION: string;
+    LEGAL_DOCUMENTS_HASH: string;
+    LEGAL_RECEIPT_DOCUMENTS: readonly {
+        id: string;
+        role: string;
+        version: string;
+        sha256: string;
+        treatment: string;
+        material: boolean;
+    }[];
+}
+export declare let LEGAL_VERSION: string;
+export declare let LEGAL_DOCUMENTS_HASH: string;
+export declare let LEGAL_RECEIPT_DOCUMENTS: HostLegal["LEGAL_RECEIPT_DOCUMENTS"];
+export declare function configureLegal(legal: HostLegal): void;
+/** The agreement on file, read and recorded by the native receipt service, which stamps the time (src-tauri/src/legal.rs). */
+export declare const legalReceipt: import("@rightkit/onboarding").LegalReceiptPort;
+/** The legal gate: suite default policies (rendered at build time), host colours from the shell tokens. */
+export declare const legalStepConfig: () => LegalStepConfig;

package/dist/lib/legal.js

@@ -0,0 +1,39 @@
+import { policyGateDocuments } from "@rightkit/legal-ui";
+import { createNativeLegalReceiptPort } from "@rightkit/onboarding";
+import { invoke } from "@tauri-apps/api/core";
+import { createShell } from "@rightkit/tauri-shell";
+// Set once by the host at startup (configureLegal(await import("virtual:rightkit-legal"))): a published package cannot import a
+// build-time module of the app that installs it. ES module exports are live bindings, so importers see the configured values.
+export let LEGAL_VERSION;
+export let LEGAL_DOCUMENTS_HASH;
+export let LEGAL_RECEIPT_DOCUMENTS = [];
+let documents = [];
+export function configureLegal(legal) {
+    if (!legal || typeof legal.LEGAL_VERSION !== "string" || !Array.isArray(legal.LEGAL_DOCUMENTS)) {
+        throw new TypeError("configureLegal: pass the host's virtual:rightkit-legal module");
+    }
+    LEGAL_VERSION = legal.LEGAL_VERSION;
+    LEGAL_DOCUMENTS_HASH = legal.LEGAL_DOCUMENTS_HASH;
+    LEGAL_RECEIPT_DOCUMENTS = legal.LEGAL_RECEIPT_DOCUMENTS;
+    documents = policyGateDocuments(legal.LEGAL_DOCUMENTS);
+}
+/** The agreement on file, read and recorded by the native receipt service, which stamps the time (src-tauri/src/legal.rs). */
+export const legalReceipt = createNativeLegalReceiptPort({ invoke });
+/** The legal gate: suite default policies (rendered at build time), host colours from the shell tokens. */
+export const legalStepConfig = () => ({
+    appName: "Pulse",
+    trustLine: "Pulse watches your computer's storage and your agent chats locally. Nothing leaves this computer unless you turn a feature on.",
+    documents,
+    agreementStatement: `I have read and agree to the ${documents.map((d) => d.title).join(", ")}.`,
+    theme: {
+        bg: "var(--rk-plane)",
+        surface: "var(--rk-panel)",
+        border: "var(--rk-line-strong)",
+        text: "var(--rk-ink)",
+        muted: "var(--rk-ink-2)",
+        accent: "var(--rk-accent)",
+        accentContrast: "var(--rk-accent-ink)",
+    },
+    // The hub window closes; the notch keeps running (the hub's lifecycle is fixed).
+    onQuit: () => void createShell().window.close().catch(() => undefined),
+});

package/dist/lib/onboardingSettings.d.ts

@@ -0,0 +1,2 @@
+import type { SettingsBackend } from "@rightkit/onboarding";
+export declare const onboardingSettings: SettingsBackend;

package/dist/lib/onboardingSettings.js

@@ -0,0 +1,17 @@
+import { invoke } from "@tauri-apps/api/core";
+// The onboarding's own progress, kept in the hub's `hub-onboarding.json` document (a frontend-owned
+// rightkit-app-settings Document). The notch's settings (docs/settings.md) hold only `onboardingDone`. The legal
+// agreement is not kept here: the native receipt service records it (lib/legal.ts); the shared component only copies
+// that record into `onboarding.state`, and only the one-time carry-over of an older record reads it (src-tauri/src/legal.rs).
+const NAME = "onboarding";
+export const onboardingSettings = {
+    load: () => invoke("hub_document_load", { name: NAME }),
+    patch: async (patch) => {
+        try {
+            return await invoke("hub_document_patch", { name: NAME, patch });
+        }
+        catch {
+            throw new Error("Pulse could not save your setup progress.");
+        }
+    },
+};

package/dist/lib/qr.d.ts

@@ -0,0 +1,9 @@
+/** A small dependency-free QR Code encoder: byte mode, error correction M, versions 1 to 20, mask chosen by penalty.
+ *  The pairing QR holds a public URI of about 250 bytes (version 11). Returns the module matrix (true = dark). */
+/** The module matrix for `text` (UTF-8, byte mode). Throws when it does not fit version 20 at level M. */
+export declare function qrMatrix(text: string): boolean[][];
+/** The matrix as one SVG path (quiet zone of 4 modules), for rendering at any size. */
+export declare function qrSvgPath(matrix: boolean[][]): {
+    path: string;
+    size: number;
+};

package/dist/lib/qr.js

@@ -0,0 +1,286 @@
+/** A small dependency-free QR Code encoder: byte mode, error correction M, versions 1 to 20, mask chosen by penalty.
+ *  The pairing QR holds a public URI of about 250 bytes (version 11). Returns the module matrix (true = dark). */
+const ECC_PER_BLOCK_M = [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26];
+const BLOCKS_M = [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16];
+const MAX_VERSION = 20;
+function rawModules(ver) {
+    let r = (16 * ver + 128) * ver + 64;
+    if (ver >= 2) {
+        const n = Math.floor(ver / 7) + 2;
+        r -= (25 * n - 10) * n - 55;
+        if (ver >= 7)
+            r -= 36;
+    }
+    return r;
+}
+const dataCodewords = (ver) => Math.floor(rawModules(ver) / 8) - ECC_PER_BLOCK_M[ver] * BLOCKS_M[ver];
+// GF(256) arithmetic, polynomial 0x11D.
+const EXP = new Array(512);
+const LOG = new Array(256);
+(() => {
+    let x = 1;
+    for (let i = 0; i < 255; i++) {
+        EXP[i] = x;
+        LOG[x] = i;
+        x <<= 1;
+        if (x & 0x100)
+            x ^= 0x11d;
+    }
+    for (let i = 255; i < 512; i++)
+        EXP[i] = EXP[i - 255];
+})();
+const mul = (a, b) => (a === 0 || b === 0 ? 0 : EXP[LOG[a] + LOG[b]]);
+function generator(degree) {
+    let poly = [1];
+    for (let i = 0; i < degree; i++) {
+        const next = new Array(poly.length + 1).fill(0);
+        for (let j = 0; j < poly.length; j++) {
+            next[j] ^= poly[j];
+            next[j + 1] ^= mul(poly[j], EXP[i]);
+        }
+        poly = next;
+    }
+    return poly;
+}
+function remainder(data, gen) {
+    const rem = new Array(gen.length - 1).fill(0);
+    for (const byte of data) {
+        const factor = byte ^ rem.shift();
+        rem.push(0);
+        for (let i = 0; i < rem.length; i++)
+            rem[i] ^= mul(gen[i + 1], factor);
+    }
+    return rem;
+}
+function interleave(data, ver) {
+    const blocks = BLOCKS_M[ver];
+    const eccLen = ECC_PER_BLOCK_M[ver];
+    const rawCodewords = Math.floor(rawModules(ver) / 8);
+    const shortBlocks = blocks - (rawCodewords % blocks);
+    const shortLen = Math.floor(rawCodewords / blocks);
+    const gen = generator(eccLen);
+    const dataBlocks = [];
+    const eccBlocks = [];
+    for (let i = 0, k = 0; i < blocks; i++) {
+        const len = shortLen - eccLen + (i < shortBlocks ? 0 : 1);
+        const chunk = data.slice(k, k + len);
+        k += len;
+        dataBlocks.push(chunk);
+        eccBlocks.push(remainder(chunk, gen));
+    }
+    const out = [];
+    for (let i = 0; i <= shortLen - eccLen; i++) {
+        dataBlocks.forEach((b) => { if (i < b.length)
+            out.push(b[i]); });
+    }
+    for (let i = 0; i < eccLen; i++)
+        eccBlocks.forEach((b) => out.push(b[i]));
+    return out;
+}
+/** The module matrix for `text` (UTF-8, byte mode). Throws when it does not fit version 20 at level M. */
+export function qrMatrix(text) {
+    const bytes = Array.from(new TextEncoder().encode(text));
+    let ver = 1;
+    for (; ver <= MAX_VERSION; ver++) {
+        const countBits = ver < 10 ? 8 : 16;
+        if (4 + countBits + bytes.length * 8 <= dataCodewords(ver) * 8)
+            break;
+    }
+    if (ver > MAX_VERSION)
+        throw new Error("QR payload is too long");
+    const bits = [];
+    const put = (value, len) => { for (let i = len - 1; i >= 0; i--)
+        bits.push((value >>> i) & 1); };
+    put(0b0100, 4);
+    put(bytes.length, ver < 10 ? 8 : 16);
+    bytes.forEach((b) => put(b, 8));
+    const capacity = dataCodewords(ver) * 8;
+    put(0, Math.min(4, capacity - bits.length));
+    while (bits.length % 8)
+        bits.push(0);
+    for (let pad = 0xec; bits.length < capacity; pad ^= 0xec ^ 0x11)
+        put(pad, 8);
+    const data = [];
+    for (let i = 0; i < bits.length; i += 8)
+        data.push(parseInt(bits.slice(i, i + 8).join(""), 2));
+    const codewords = interleave(data, ver);
+    const size = ver * 4 + 17;
+    const grid = Array.from({ length: size }, () => new Array(size).fill(false));
+    const fn = Array.from({ length: size }, () => new Array(size).fill(false));
+    const set = (x, y, dark) => {
+        if (x < 0 || y < 0 || x >= size || y >= size)
+            return;
+        grid[y][x] = dark;
+        fn[y][x] = true;
+    };
+    for (let i = 0; i < size; i++) {
+        set(6, i, i % 2 === 0);
+        set(i, 6, i % 2 === 0);
+    }
+    const finder = (cx, cy) => {
+        for (let dy = -4; dy <= 4; dy++)
+            for (let dx = -4; dx <= 4; dx++) {
+                const d = Math.max(Math.abs(dx), Math.abs(dy));
+                set(cx + dx, cy + dy, d !== 2 && d !== 4);
+            }
+    };
+    finder(3, 3);
+    finder(size - 4, 3);
+    finder(3, size - 4);
+    if (ver >= 2) {
+        const n = Math.floor(ver / 7) + 2;
+        const step = ver === 32 ? 26 : Math.ceil((ver * 4 + 4) / (n * 2 - 2)) * 2;
+        const pos = [6];
+        for (let p = size - 7; pos.length < n; p -= step)
+            pos.splice(1, 0, p);
+        for (let i = 0; i < n; i++)
+            for (let j = 0; j < n; j++) {
+                if ((i === 0 && j === 0) || (i === 0 && j === n - 1) || (i === n - 1 && j === 0))
+                    continue;
+                for (let dy = -2; dy <= 2; dy++)
+                    for (let dx = -2; dx <= 2; dx++) {
+                        set(pos[i] + dx, pos[j] + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+                    }
+            }
+    }
+    const formatBits = (mask) => {
+        const data = (0b00 << 3) | mask; // level M = 00
+        let rem = data;
+        for (let i = 0; i < 10; i++)
+            rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+        return ((data << 10) | rem) ^ 0x5412;
+    };
+    const drawFormat = (mask) => {
+        const b = formatBits(mask);
+        const bit = (i) => ((b >>> i) & 1) !== 0;
+        for (let i = 0; i <= 5; i++)
+            set(8, i, bit(i));
+        set(8, 7, bit(6));
+        set(8, 8, bit(7));
+        set(7, 8, bit(8));
+        for (let i = 9; i < 15; i++)
+            set(14 - i, 8, bit(i));
+        for (let i = 0; i < 8; i++)
+            set(size - 1 - i, 8, bit(i));
+        for (let i = 8; i < 15; i++)
+            set(8, size - 15 + i, bit(i));
+        set(8, size - 8, true);
+    };
+    drawFormat(0);
+    if (ver >= 7) {
+        let rem = ver;
+        for (let i = 0; i < 12; i++)
+            rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25);
+        const b = (ver << 12) | rem;
+        for (let i = 0; i < 18; i++) {
+            const dark = ((b >>> i) & 1) !== 0;
+            const a = size - 11 + (i % 3);
+            const c = Math.floor(i / 3);
+            set(a, c, dark);
+            set(c, a, dark);
+        }
+    }
+    // Place the data bits in the zigzag, skipping function modules.
+    const total = codewords.length * 8;
+    let k = 0;
+    for (let right = size - 1; right >= 1; right -= 2) {
+        if (right === 6)
+            right = 5;
+        for (let v = 0; v < size; v++)
+            for (let j = 0; j < 2; j++) {
+                const x = right - j;
+                const y = ((right + 1) & 2) === 0 ? size - 1 - v : v;
+                if (!fn[y][x] && k < total) {
+                    grid[y][x] = ((codewords[k >>> 3] >>> (7 - (k & 7))) & 1) !== 0;
+                    k++;
+                }
+            }
+    }
+    const masks = [
+        (x, y) => (x + y) % 2 === 0,
+        (_x, y) => y % 2 === 0,
+        (x) => x % 3 === 0,
+        (x, y) => (x + y) % 3 === 0,
+        (x, y) => (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0,
+        (x, y) => ((x * y) % 2) + ((x * y) % 3) === 0,
+        (x, y) => (((x * y) % 2) + ((x * y) % 3)) % 2 === 0,
+        (x, y) => (((x + y) % 2) + ((x * y) % 3)) % 2 === 0,
+    ];
+    const apply = (mask) => {
+        for (let y = 0; y < size; y++)
+            for (let x = 0; x < size; x++) {
+                if (!fn[y][x] && masks[mask](x, y))
+                    grid[y][x] = !grid[y][x];
+            }
+    };
+    const penalty = () => {
+        let score = 0;
+        const lines = [grid, grid[0].map((_, x) => grid.map((row) => row[x]))];
+        for (const rows of lines) {
+            for (const row of rows) {
+                let run = 1;
+                for (let i = 1; i <= size; i++) {
+                    if (i < size && row[i] === row[i - 1])
+                        run++;
+                    else {
+                        if (run >= 5)
+                            score += run - 2;
+                        run = 1;
+                    }
+                }
+            }
+        }
+        for (let y = 0; y < size - 1; y++)
+            for (let x = 0; x < size - 1; x++) {
+                const c = grid[y][x];
+                if (c === grid[y][x + 1] && c === grid[y + 1][x] && c === grid[y + 1][x + 1])
+                    score += 3;
+            }
+        const pat = [true, false, true, true, true, false, true, false, false, false, false];
+        const rev = [...pat].reverse();
+        for (const rows of lines) {
+            for (const row of rows) {
+                for (let i = 0; i + 11 <= size; i++) {
+                    const win = row.slice(i, i + 11);
+                    if (win.every((v, n) => v === pat[n]) || win.every((v, n) => v === rev[n]))
+                        score += 40;
+                }
+            }
+        }
+        const dark = grid.reduce((n, row) => n + row.filter(Boolean).length, 0);
+        score += Math.floor(Math.abs(dark * 20 - size * size * 10) / (size * size)) * 10;
+        return score;
+    };
+    let best = 0;
+    let bestScore = Infinity;
+    for (let m = 0; m < 8; m++) {
+        apply(m);
+        drawFormat(m);
+        const s = penalty();
+        if (s < bestScore) {
+            bestScore = s;
+            best = m;
+        }
+        apply(m);
+    }
+    apply(best);
+    drawFormat(best);
+    return grid;
+}
+/** The matrix as one SVG path (quiet zone of 4 modules), for rendering at any size. */
+export function qrSvgPath(matrix) {
+    const n = matrix.length;
+    let path = "";
+    matrix.forEach((row, y) => {
+        for (let x = 0; x < n; x++) {
+            if (!row[x])
+                continue;
+            let end = x;
+            while (end + 1 < n && row[end + 1])
+                end++;
+            path += `M${x + 4} ${y + 4}h${end - x + 1}v1h-${end - x + 1}z`;
+            x = end;
+        }
+    });
+    return { path, size: n + 8 };
+}

package/dist/lib/rk.d.ts

@@ -0,0 +1,6 @@
+export declare const native: import("@rightkit/tauri").RightKitTauriClient<unknown, unknown, Record<string, unknown>, unknown>;
+export declare const logs: import("@rightkit/logs").LogsClient;
+/** This install's RightKit device id (not the devicelink pairing identity). */
+export declare const deviceId: () => Promise<string>;
+/** Sends uncaught errors and unhandled rejections to the native crash command, which logs the kind and place only, never the message. */
+export declare function installWebviewLog(): void;

package/dist/lib/rk.js

@@ -0,0 +1,30 @@
+// RightKit's mandatory webview clients over the hub's real Tauri `invoke`:
+//  - `native` (@rightkit/tauri): typed commands for the device id, logs and diagnostics. Licensing is
+//    native and has its own client (`hub/src/lib/license.ts`).
+//  - `logs` (@rightkit/logs): batched structured events to `rightkit_logs_write`, written into the
+//    hub log (`hub.jsonl`) by the native side. Only the fields listed here ever reach disk.
+//    Webview errors go through `installWindowCrashCapture` to `rightkit_crash_window_error`.
+import { invoke } from "@tauri-apps/api/core";
+import { createLogsClient, installWindowCrashCapture } from "@rightkit/logs";
+import { createRightKitTauriClient, standardRightKitDeviceGetOrCreate } from "@rightkit/tauri";
+export const native = createRightKitTauriClient({
+    invoke,
+    deviceGetOrCreate: standardRightKitDeviceGetOrCreate,
+});
+export const logs = createLogsClient({
+    invoke,
+    allowedFields: ["surface", "kind", "name", "source", "line", "count", "code", "duration_ms"],
+});
+/** This install's RightKit device id (not the devicelink pairing identity). */
+export const deviceId = () => native.device.getOrCreate();
+let installed = false;
+/** Sends uncaught errors and unhandled rejections to the native crash command, which logs the kind and place only, never the message. */
+export function installWebviewLog() {
+    if (installed)
+        return;
+    installed = true;
+    installWindowCrashCapture({ invoke });
+    window.addEventListener("pagehide", () => void logs.flush());
+    logs.info("webview_started", { surface: "hub" });
+    void deviceId().catch(() => logs.warn("device_id_unavailable", { surface: "hub" }));
+}

package/dist/metrics.d.ts

@@ -0,0 +1,24 @@
+export interface Sample {
+    /** Unix time, ms. */
+    ts: number;
+    /** Overall CPU, 0–100. */
+    cpu: number;
+    memUsed: number;
+    memTotal: number;
+    swapUsed: number;
+    swapTotal: number;
+    pressure: string | null;
+    /** Bytes per second; null while unread. */
+    netDown: number | null;
+    netUp: number | null;
+}
+export interface Metrics {
+    samples: Sample[];
+    latest: Sample | null;
+}
+/** The last 30 minutes of samples (oldest first) and the newest one. */
+export declare function useMetrics(): Metrics;
+/** Samples from the last `minutes`, measured back from the newest sample. */
+export declare function lastMinutes(samples: Sample[], minutes: number): Sample[];
+export declare const memPercent: (s: Sample) => number;
+export declare const swapPercent: (s: Sample) => number;

package/dist/metrics.js

@@ -0,0 +1,76 @@
+// Live system history for the graphs. The Rust side (metrics_history.rs)
+// samples every 2 s and keeps 30 minutes, even while the window is closed.
+// This module loads that once, then polls only what is new while something
+// is subscribed.
+import { useSyncExternalStore } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { clearVisibleInterval, visibleInterval } from "./visible.js";
+const POLL_MS = 2000;
+const KEEP_MS = 30 * 60 * 1000;
+let state = { samples: [], latest: null };
+const listeners = new Set();
+let timer = null;
+let inFlight = false;
+// Visibility lease: renewed with every visible poll (2 s, ttl 6 s). The engine samples every
+// 2 s while any lease lives and every 10 s otherwise; a hidden hub stops renewing and it lapses.
+const CLIENT_ID = `hub-${Math.random().toString(36).slice(2)}`;
+const LEASE_TTL_MS = 6000;
+function merge(fresh) {
+    if (fresh.length === 0)
+        return;
+    const last = state.latest?.ts ?? 0;
+    const added = fresh.filter((s) => s.ts > last);
+    if (added.length === 0)
+        return;
+    const all = state.samples.concat(added);
+    const cutoff = all[all.length - 1].ts - KEEP_MS;
+    const samples = all.filter((s) => s.ts >= cutoff);
+    state = { samples, latest: samples[samples.length - 1] };
+    listeners.forEach((l) => l());
+}
+async function poll() {
+    if (inFlight)
+        return;
+    inFlight = true;
+    try {
+        // Lease first so the engine's immediate sample is in the read that follows.
+        await invoke("metrics_lease", { client: CLIENT_ID, ttlMs: LEASE_TTL_MS }).catch(() => { });
+        const since = state.latest?.ts;
+        merge(await invoke("metrics_history", { sinceMs: since ?? null }));
+    }
+    catch {
+        // The next tick tries again; the graphs keep what they have.
+    }
+    finally {
+        inFlight = false;
+    }
+}
+function subscribe(listener) {
+    listeners.add(listener);
+    if (listeners.size === 1) {
+        poll();
+        timer = visibleInterval(poll, POLL_MS);
+    }
+    return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0 && timer != null) {
+            clearVisibleInterval(timer);
+            timer = null;
+        }
+    };
+}
+const snapshot = () => state;
+/** The last 30 minutes of samples (oldest first) and the newest one. */
+export function useMetrics() {
+    return useSyncExternalStore(subscribe, snapshot);
+}
+/** Samples from the last `minutes`, measured back from the newest sample. */
+export function lastMinutes(samples, minutes) {
+    if (samples.length === 0)
+        return samples;
+    const cutoff = samples[samples.length - 1].ts - minutes * 60_000;
+    const first = samples.findIndex((s) => s.ts >= cutoff);
+    return first <= 0 ? samples : samples.slice(first);
+}
+export const memPercent = (s) => (s.memTotal > 0 ? (s.memUsed / s.memTotal) * 100 : 0);
+export const swapPercent = (s) => (s.swapTotal > 0 ? (s.swapUsed / s.swapTotal) * 100 : 0);

package/dist/onboarding/flow.d.ts

@@ -0,0 +1,31 @@
+export declare const FLOW_KEY = "pulseFlow";
+export declare const FLOW_VERSION = 1;
+export type Draft = Record<string, boolean | string>;
+export interface Commit {
+    /** `writing` was saved before the first write: a window that finds it after a restart treats it as unfinished. */
+    status: "idle" | "writing" | "partial" | "done";
+    /** Setting key to why its write was not confirmed. */
+    failed: Record<string, string>;
+}
+export interface Flow {
+    version: typeof FLOW_VERSION;
+    /** A first run starts every switch on; a re-run starts from the current values. Fixed when the flow is made. */
+    first: boolean;
+    draft: Draft;
+    /** Permission ids the user chose to decide later. */
+    deferred: string[];
+    commit: Commit;
+}
+export declare const freshFlow: (first: boolean) => Flow;
+export declare function loadFlow(): Promise<Flow | null>;
+export declare function saveFlow(flow: Flow): Promise<void>;
+type SettingValue = boolean | string;
+export declare function readSettings(): Promise<Record<string, unknown> | null>;
+/** One confirmed write: the notch's typed answer, or, when it has not answered yet, its published state. */
+export declare function writeSetting(key: string, value: SettingValue): Promise<string | null>;
+/**
+ * Writes each `[key, value]` that the notch does not already hold, one at a time, and returns the keys whose write was
+ * not confirmed. Nothing is assumed: the next call reads the published state again, so a retry repeats only what failed.
+ */
+export declare function writeAll(plan: [string, SettingValue][]): Promise<Record<string, string>>;
+export {};