@rightkit/social-ui 0.0.0-stage → 0.1.0

package/dist/data/types.js

@@ -0,0 +1,3 @@
+// Operator data model. These types are the contract the screens render. The daemon owns every
+// value here; the desktop only displays it and sends intents back through DataSource.
+export {};

package/dist/env.d.ts

@@ -0,0 +1,59 @@
+/// <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";
+}
+
+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;
+}
+
+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 }[];
+}

package/dist/hooks/useAsync.d.ts

@@ -0,0 +1,19 @@
+export type AsyncState<T> = {
+    status: "loading";
+} | {
+    status: "ready";
+    value: T;
+} | {
+    status: "error";
+    message: string;
+};
+/**
+ * Runs `load` whenever `deps` change or `reload` is called. Stale responses are dropped so a
+ * slow earlier read cannot overwrite a newer one.
+ */
+export declare function useAsync<T>(load: () => Promise<T>, deps: readonly unknown[]): {
+    state: AsyncState<T>;
+    reload: () => void;
+    /** Current value, or the last good value while a reload runs. Null before the first success. */
+    value: T | null;
+};

package/dist/hooks/useAsync.js

@@ -0,0 +1,25 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+/**
+ * Runs `load` whenever `deps` change or `reload` is called. Stale responses are dropped so a
+ * slow earlier read cannot overwrite a newer one.
+ */
+export function useAsync(load, deps) {
+    const [state, setState] = useState({ status: "loading" });
+    const [tick, setTick] = useState(0);
+    const lastGood = useRef(null);
+    useEffect(() => {
+        if (state.status === "ready")
+            lastGood.current = state.value;
+    }, [state]);
+    useEffect(() => {
+        let live = true;
+        setState({ status: "loading" });
+        load().then((value) => live && setState({ status: "ready", value }), (error) => live && setState({ status: "error", message: error instanceof Error ? error.message : "Unknown error" }));
+        return () => {
+            live = false;
+        };
+        // The caller owns the dependency list; `load` is re-created on every render by design.
+    }, [...deps, tick]);
+    const reload = useCallback(() => setTick((t) => t + 1), []);
+    return { state, reload, value: state.status === "ready" ? state.value : lastGood.current };
+}

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+export * from "./appName.js";
+export * from "./components/ScopeSelect.js";
+export * from "./components/Shared.js";
+export * from "./data/derive.js";
+export * from "./data/draftRules.js";
+export * from "./data/engine/engineDataSource.js";
+export * from "./data/engine/errors.js";
+export * from "./data/engine/mapping.js";
+export * from "./data/engine/protocol.js";
+export * from "./data/mock/devSource.js";
+export * from "./data/mock/fixtures-analytics.js";
+export * from "./data/mock/fixtures-briefs.js";
+export * from "./data/mock/fixtures-content.js";
+export * from "./data/mock/fixtures-digests.js";
+export * from "./data/mock/fixtures-drafts.js";
+export * from "./data/mock/fixtures-gate.js";
+export * from "./data/mock/fixtures-hooks.js";
+export * from "./data/mock/fixtures-inbox.js";
+export * from "./data/mock/fixtures-links.js";
+export * from "./data/mock/fixtures-memory.js";
+export * from "./data/mock/fixtures-ops.js";
+export * from "./data/mock/fixtures-optimise.js";
+export * from "./data/mock/fixtures-pacing.js";
+export * from "./data/mock/fixtures-publish.js";
+export * from "./data/mock/fixtures-store.js";
+export * from "./data/mock/fixtures-variants.js";
+export * from "./data/mock/fixtures.js";
+export * from "./data/mock/mockDataSource.js";
+export * from "./data/money.js";
+export * from "./data/platforms.js";
+export * from "./data/time.js";
+export * from "./data/types.js";
+export * from "./hooks/useAsync.js";
+export * from "./lib/host.js";
+export * from "./lib/shell.js";
+export * from "./screens/AccountsScreen.js";
+export * from "./screens/AnalyticsScreen.js";
+export * from "./screens/ApprovalsScreen.js";
+export * from "./screens/BriefsScreen.js";
+export * from "./screens/CalendarScreen.js";
+export * from "./screens/CampaignsScreen.js";
+export * from "./screens/ChannelMemoryScreen.js";
+export * from "./screens/ContentScreen.js";
+export * from "./screens/DigestsScreen.js";
+export * from "./screens/DraftsScreen.js";
+export * from "./screens/FailuresScreen.js";
+export * from "./screens/HookTestsScreen.js";
+export * from "./screens/InboxScreen.js";
+export * from "./screens/LinksScreen.js";
+export * from "./screens/PacingScreen.js";
+export * from "./screens/PublishJobsScreen.js";
+export * from "./screens/SuggestionsScreen.js";
+export * from "./screens/TextGateScreen.js";
+export * from "./screens/ThreadsScreen.js";
+export * from "./screens/TypedBriefsScreen.js";
+export * from "./screens/labels.js";

package/dist/index.js

@@ -0,0 +1,58 @@
+// 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 "./appName.js";
+export * from "./components/ScopeSelect.js";
+export * from "./components/Shared.js";
+export * from "./data/derive.js";
+export * from "./data/draftRules.js";
+export * from "./data/engine/engineDataSource.js";
+export * from "./data/engine/errors.js";
+export * from "./data/engine/mapping.js";
+export * from "./data/engine/protocol.js";
+export * from "./data/mock/devSource.js";
+export * from "./data/mock/fixtures-analytics.js";
+export * from "./data/mock/fixtures-briefs.js";
+export * from "./data/mock/fixtures-content.js";
+export * from "./data/mock/fixtures-digests.js";
+export * from "./data/mock/fixtures-drafts.js";
+export * from "./data/mock/fixtures-gate.js";
+export * from "./data/mock/fixtures-hooks.js";
+export * from "./data/mock/fixtures-inbox.js";
+export * from "./data/mock/fixtures-links.js";
+export * from "./data/mock/fixtures-memory.js";
+export * from "./data/mock/fixtures-ops.js";
+export * from "./data/mock/fixtures-optimise.js";
+export * from "./data/mock/fixtures-pacing.js";
+export * from "./data/mock/fixtures-publish.js";
+export * from "./data/mock/fixtures-store.js";
+export * from "./data/mock/fixtures-variants.js";
+export * from "./data/mock/fixtures.js";
+export * from "./data/mock/mockDataSource.js";
+export * from "./data/money.js";
+export * from "./data/platforms.js";
+export * from "./data/time.js";
+export * from "./data/types.js";
+export * from "./hooks/useAsync.js";
+export * from "./lib/host.js";
+export * from "./lib/shell.js";
+export * from "./screens/AccountsScreen.js";
+export * from "./screens/AnalyticsScreen.js";
+export * from "./screens/ApprovalsScreen.js";
+export * from "./screens/BriefsScreen.js";
+export * from "./screens/CalendarScreen.js";
+export * from "./screens/CampaignsScreen.js";
+export * from "./screens/ChannelMemoryScreen.js";
+export * from "./screens/ContentScreen.js";
+export * from "./screens/DigestsScreen.js";
+export * from "./screens/DraftsScreen.js";
+export * from "./screens/FailuresScreen.js";
+export * from "./screens/HookTestsScreen.js";
+export * from "./screens/InboxScreen.js";
+export * from "./screens/LinksScreen.js";
+export * from "./screens/PacingScreen.js";
+export * from "./screens/PublishJobsScreen.js";
+export * from "./screens/SuggestionsScreen.js";
+export * from "./screens/TextGateScreen.js";
+export * from "./screens/ThreadsScreen.js";
+export * from "./screens/TypedBriefsScreen.js";
+export * from "./screens/labels.js";

package/dist/lib/host.d.ts

@@ -0,0 +1,21 @@
+import { isTauri } from "@rightkit/platform-ui";
+import { type EngineCallError } from "@rightkit/tauri-shell";
+export { isTauri };
+export declare function invoke<T>(command: string, args?: Record<string, unknown>): Promise<T>;
+/**
+ * The typed rejection `engine.callTagged` returns (`@rightkit/tauri-shell` 0.1.2 `EngineCallError`): `origin` is
+ * `supervisor` when the call was refused before the engine ran, `engine` for the engine's own reply.
+ */
+export type { EngineCallError };
+export type EngineCallResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: EngineCallError;
+};
+/**
+ * One engine method through the shell (`shell.engine.callTagged`, the owner's typed wrapper). Never throws: a refused
+ * method, an engine error or a missing shell all come back as `{ ok: false, error }`.
+ */
+export declare function engineCall<T>(method: string, params: Record<string, unknown>): Promise<EngineCallResult<T>>;

package/dist/lib/host.js

@@ -0,0 +1,32 @@
+// Single IPC seam to the Tauri shell. There is no browser stand-in: UI behaviour is verified
+// against the real app, never against an in-page mock.
+import { invoke as tauriInvoke } from "@tauri-apps/api/core";
+import { isTauri } from "@rightkit/platform-ui";
+import { asShellError } from "@rightkit/tauri-shell";
+import { shell } from "./shell.js";
+export { isTauri };
+export async function invoke(command, args) {
+    if (!isTauri())
+        throw new Error(`"${command}" needs the Tauri shell; run \`pnpm tauri:dev\``);
+    return tauriInvoke(command, args);
+}
+/** Per-call tag; the shell echoes it on every engine event of that call. */
+let tagCounter = 0;
+/**
+ * One engine method through the shell (`shell.engine.callTagged`, the owner's typed wrapper). Never throws: a refused
+ * method, an engine error or a missing shell all come back as `{ ok: false, error }`.
+ */
+export async function engineCall(method, params) {
+    tagCounter += 1;
+    try {
+        const value = await shell.engine.callTagged(method, params, `postright-ui-${tagCounter}`);
+        return { ok: true, value };
+    }
+    catch (raw) {
+        const e = asShellError(raw);
+        return {
+            ok: false,
+            error: { code: e.code, message: e.message, origin: e.origin === "engine" ? "engine" : "supervisor", ...(e.details !== undefined ? { details: e.details } : {}) },
+        };
+    }
+}

package/dist/lib/shell.d.ts

@@ -0,0 +1,156 @@
+/** The native shell bridge (window controls, external links, menu actions, native theme). */
+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;
+};
+export declare const shellBridge: import("@rightkit/tauri-shell").ShellBridge;

package/dist/lib/shell.js

@@ -0,0 +1,16 @@
+import { createShell } from "@rightkit/tauri-shell";
+/** Created on first use (outside a Tauri webview createShell throws, so importing this package must not call it). */
+function lazy(make) {
+    let value = null;
+    const get = () => (value ??= make());
+    return new Proxy({}, {
+        get: (_t, key) => {
+            const v = Reflect.get(get(), key);
+            return typeof v === "function" ? v.bind(get()) : v;
+        },
+        has: (_t, key) => key in get(),
+    });
+}
+/** The native shell bridge (window controls, external links, menu actions, native theme). */
+export const shell = lazy(() => createShell());
+export const shellBridge = lazy(() => shell.bridge());

package/dist/screens/AccountsScreen.d.ts

@@ -0,0 +1,8 @@
+import { type DataSource } from "../data/index.js";
+interface Props {
+    source: DataSource;
+    rev: number;
+    onChanged: () => void;
+}
+export declare function AccountsScreen({ source, rev, onChanged }: Props): import("react").JSX.Element;
+export {};

package/dist/screens/AccountsScreen.js

@@ -0,0 +1,100 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from "react";
+import { Button, ConfirmDialog, EmptyState, Notice, PageShell, SkeletonRows, Toggle } from "@rightkit/react-shell/react";
+import { AccountChip, LoadError, MockBanner } from "../components/Shared.js";
+import { useAsync } from "../hooks/useAsync.js";
+import { SOCIAL_PLATFORMS, accountOrdinals, dayLabel, instantLabel, } from "../data/index.js";
+import { ENTITLEMENT_LABEL, PLATFORM_LABEL, cooldownText, platformName, tokenText } from "./labels.js";
+import { hostAppName } from "../appName.js";
+const SOURCE_LABEL = {
+    numeric_retry_after: "numeric Retry-After header",
+    dated_retry_after: "dated Retry-After header",
+};
+/** Accounts grouped by venture, then platform in the engine's platform order. Order inside a group is the daemon's list order. */
+function groupAccounts(accounts) {
+    const ventures = new Map();
+    for (const account of accounts) {
+        const venture = ventures.get(account.venture.id) ?? { name: account.venture.name, platforms: new Map() };
+        const list = venture.platforms.get(account.platform) ?? [];
+        list.push(account);
+        venture.platforms.set(account.platform, list);
+        ventures.set(account.venture.id, venture);
+    }
+    return [...ventures.entries()].map(([id, v]) => ({
+        id,
+        name: v.name,
+        platforms: SOCIAL_PLATFORMS.filter((p) => v.platforms.has(p)).map((p) => ({
+            platform: p,
+            accounts: v.platforms.get(p) ?? [],
+        })),
+    }));
+}
+/** Accounts whose platform or state this app does not show yet. Their readiness is not shown. */
+function UnmappedAccounts({ rows }) {
+    return (_jsxs("section", { className: "op-venture", "aria-labelledby": "unmapped-accounts-title", children: [_jsx("h2", { id: "unmapped-accounts-title", className: "op-venture__title", children: "Accounts this app does not show yet" }), _jsx("p", { className: "op-hint", children: "The engine stores these accounts. Their readiness is not shown until this app knows their platform and state." }), _jsx("div", { className: "op-accounts", children: rows.map((row, index) => (_jsxs("article", { className: "op-card op-account", "aria-labelledby": `unmapped-${index}`, children: [_jsxs("h3", { id: `unmapped-${index}`, className: "op-account__title", children: ["Account on ", platformName(row.platform)] }), _jsxs("p", { children: ["Account id: ", _jsx("span", { className: "op-mono", children: row.id })] }), _jsxs("p", { children: ["Reason: ", row.reason] })] }, row.id))) })] }));
+}
+export function AccountsScreen({ source, rev, onChanged }) {
+    const { state, reload } = useAsync(async () => ({
+        accounts: await source.listAccounts(),
+        unmapped: source.unmappedAccounts?.() ?? [],
+    }), [source, rev]);
+    const [pendingId, setPendingId] = useState(null);
+    const [notice, setNotice] = useState(null);
+    const [disconnecting, setDisconnecting] = useState(null);
+    const now = source.nowUtc();
+    const loaded = state.status === "ready" ? state.value : null;
+    const ordinals = useMemo(() => accountOrdinals(loaded?.accounts ?? []), [loaded]);
+    async function setPaused(account, paused, label) {
+        setPendingId(account.id);
+        const result = paused
+            ? await source.pauseAccount(account.id, "Paused from desktop")
+            : await source.resumeAccount(account.id);
+        setPendingId(null);
+        setNotice(result.ok
+            ? {
+                tone: "ok",
+                text: paused ? `Publishing paused for ${label}. Its scheduled posts will not publish.` : `Publishing resumed for ${label}.`,
+            }
+            : { tone: "bad", text: result.error.message });
+        onChanged();
+    }
+    async function disconnect(account, label) {
+        setDisconnecting(null);
+        setPendingId(account.id);
+        const result = await source.disconnectAccount(account.id);
+        setPendingId(null);
+        if (!result.ok) {
+            setNotice({ tone: "bad", text: result.error.message });
+        }
+        else {
+            const { cancelledJobs, keptJobs } = result.value;
+            const cancelled = cancelledJobs === 1 ? "1 queued or waiting post was cancelled." : `${cancelledJobs} queued or waiting posts were cancelled.`;
+            const kept = keptJobs === 0
+                ? ""
+                : ` ${keptJobs} post${keptJobs === 1 ? " may" : "s may"} already be on the platform and ${keptJobs === 1 ? "was" : "were"} left for the daemon to check.`;
+            setNotice({
+                tone: "ok",
+                text: `Disconnected ${label}. ${cancelled}${kept} The data ${hostAppName()} holds is not deleted; see the data deletion page to request that.`,
+            });
+        }
+        onChanged();
+    }
+    return (_jsxs(PageShell, { title: "Accounts", subtitle: "Readiness for each connected account. Token, entitlement and cooldown are shown separately and never merged.", children: [source.kind === "mock" ? _jsx(MockBanner, {}) : null, _jsx("div", { "aria-live": "polite", children: notice ? (_jsx(Notice, { tone: notice.tone, className: "op-notice", children: notice.text })) : null }), state.status === "error" ? (_jsx(LoadError, { message: "Could not read accounts from the daemon.", onRetry: reload })) : loaded === null ? (_jsx(SkeletonRows, { label: "Loading accounts", rows: 3 })) : loaded.accounts.length === 0 && loaded.unmapped.length === 0 ? (_jsx(EmptyState, { title: "No accounts connected", children: _jsx("p", { children: "Connect an account to start publishing. Connection runs through the provider sign-in in the browser." }) })) : (_jsxs(_Fragment, { children: [groupAccounts(loaded.accounts).map((venture) => {
+                        return (_jsxs("section", { className: "op-venture", "aria-labelledby": `venture-${venture.id}`, children: [_jsx("h2", { id: `venture-${venture.id}`, className: "op-venture__title", children: venture.name }), venture.platforms.map((group) => (_jsxs("section", { className: "op-platform", "aria-labelledby": `platform-${venture.id}-${group.platform}`, children: [_jsx("h3", { id: `platform-${venture.id}-${group.platform}`, className: "op-platform__title", children: PLATFORM_LABEL[group.platform] }), _jsx("div", { className: "op-accounts", children: group.accounts.map((account) => {
+                                                const ordinal = ordinals.get(account.id);
+                                                const token = tokenText(account.readiness.token, now);
+                                                const ent = ENTITLEMENT_LABEL[account.readiness.entitlement];
+                                                const paused = account.readiness.paused;
+                                                const until = account.readiness.quotaCooldownUntil;
+                                                const label = `${ordinal?.label ?? "Account"} (${account.handle}, ${PLATFORM_LABEL[account.platform]})`;
+                                                const needsReconnect = account.readiness.token.status !== "valid";
+                                                return (_jsxs("article", { className: `op-card op-account op-band-${account.band}`, "aria-labelledby": `acc-${account.id}`, children: [_jsx("h4", { id: `acc-${account.id}`, className: "op-account__title", children: _jsx(AccountChip, { account: account, ordinal: ordinal, detail: true }) }), _jsxs("dl", { className: "op-dl", children: [_jsx("dt", { children: "Token" }), _jsxs("dd", { children: [_jsx("span", { className: "op-mark", children: token.mark }), " ", token.text] }), _jsx("dt", { children: "Re-authorisation" }), _jsx("dd", { children: account.readiness.reauthNeededBy
+                                                                        ? `Needed by ${dayLabel(account.readiness.reauthNeededBy)}. This platform issues no refresh, so the token cannot renew itself.`
+                                                                        : "Not needed now" }), _jsx("dt", { children: "Entitlement" }), _jsxs("dd", { children: [_jsxs("strong", { children: [ent.text, "."] }), " ", ent.hint] }), _jsx("dt", { children: "Quota cooldown" }), _jsxs("dd", { children: [cooldownText(until, now), until && cooldownText(until, now) !== "Cooldown has ended" ? (_jsxs(_Fragment, { children: [" ", "until ", instantLabel(until, account.timeZone), ". Source: ", SOURCE_LABEL[account.readiness.quotaCooldownSource ?? "numeric_retry_after"], "."] })) : null] }), _jsx("dt", { children: "Publishing" }), _jsx("dd", { children: paused
+                                                                        ? `Paused by ${paused.by} at ${instantLabel(paused.atUtc, account.timeZone)}. Reason: ${paused.reason}.`
+                                                                        : "Running" })] }), _jsxs("div", { className: "op-account__actions", children: [_jsxs("div", { className: "op-pause", children: [_jsx(Toggle, { checked: paused !== null, disabled: pendingId !== null, label: `Pause publishing for ${account.displayName}, ${label}`, onChange: (next) => setPaused(account, next, label) }), _jsxs("p", { className: "op-pause__text", children: [_jsxs("strong", { children: ["Pause publishing for ", account.displayName] }), _jsx("br", {}), paused
+                                                                                    ? "Paused. Its scheduled posts will not publish until you resume."
+                                                                                    : "Running. Its scheduled posts publish at their time."] })] }), account.readiness.token.status !== "revoked" ? (_jsxs(_Fragment, { children: [_jsxs(Button, { variant: "secondary", size: "sm", disabled: pendingId !== null, onClick: () => setDisconnecting({ account, label }), children: ["Disconnect ", PLATFORM_LABEL[account.platform]] }), _jsx("p", { className: "op-hint", children: "Ends the connection and cancels this account's queued and waiting posts. It does not delete data." })] })) : (_jsx("p", { className: "op-hint", children: "Disconnected. Posts for this account are not published until it is connected again." })), needsReconnect ? (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "secondary", size: "sm", disabled: true, children: "Reconnect" }), _jsx("p", { className: "op-hint", children: "Reconnect opens the provider sign-in. It is not available in mock data." })] })) : null] })] }, account.id));
+                                            }) })] }, group.platform)))] }, venture.id));
+                    }), loaded.unmapped.length > 0 ? _jsx(UnmappedAccounts, { rows: loaded.unmapped }) : null] })), disconnecting ? (_jsx(ConfirmDialog, { title: `Disconnect ${disconnecting.account.displayName} on ${PLATFORM_LABEL[disconnecting.account.platform]}?`, description: _jsxs(_Fragment, { children: [_jsxs("span", { className: "op-dialog-line", children: ["Account: ", disconnecting.label, "."] }), _jsxs("span", { className: "op-dialog-line", children: [hostAppName(), " stops using this account. Its queued and waiting posts are cancelled and will not publish."] }), _jsxs("span", { className: "op-dialog-line", children: ["Posts already on the platform stay there, and the data ", hostAppName(), " holds is kept until you request deletion."] })] }), confirmLabel: `Disconnect ${disconnecting.account.handle}`, cancelLabel: "Cancel", onConfirm: () => disconnect(disconnecting.account, disconnecting.label), onCancel: () => setDisconnecting(null) })) : null] }));
+}

package/dist/screens/AnalyticsScreen.d.ts

@@ -0,0 +1,7 @@
+import { type DataSource } from "../data/index.js";
+interface Props {
+    source: DataSource;
+    rev: number;
+}
+export declare function AnalyticsScreen({ source, rev }: Props): import("react").JSX.Element;
+export {};