@rightkit/social-ui 0.0.0-stage → 0.1.0

package/dist/screens/HookTestsScreen.js

@@ -0,0 +1,54 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Badge, EmptyState, Field, PageShell, SkeletonRows, Table, TableBody, TableCaption, TableCell, TableHead, TableHeaderCell, TableRow } from "@rightkit/react-shell/react";
+import { ScopeSelect } from "../components/ScopeSelect.js";
+import { LoadError, MockBanner } from "../components/Shared.js";
+import { useAsync } from "../hooks/useAsync.js";
+import { groupDigits, instantLabel, } from "../data/index.js";
+import { HOOK_ROLE_LABEL, HOOK_STATE_LABEL } from "./labels.js";
+/** An instant from the engine, in UTC, or the words "Not reported" when the engine holds none. */
+function instantOrNone(utc) {
+    return utc === null ? "Not reported" : instantLabel(utc, "UTC");
+}
+/** The role of one opening. Only a decided set has roles; an open set's openings are not decided. */
+function roleText(opening) {
+    return opening.role === null ? "Not decided" : HOOK_ROLE_LABEL[opening.role];
+}
+export function HookTestsScreen({ source, rev }) {
+    const scopes = useAsync(() => source.listScopes(), [source, rev]);
+    const [picked, setPicked] = useState(null);
+    const scopeList = scopes.value ?? [];
+    const scopeId = scopeList.find((s) => s.id === picked)?.id ?? scopeList[0]?.id ?? null;
+    return (_jsxs(PageShell, { title: "Hook tests", subtitle: "Read only. Variant sets: one body with several openings, each published as a trial reel, and the winner once the set is decided. Nothing here creates a set, binds a job or reads a set.", children: [source.kind === "mock" ? _jsx(MockBanner, {}) : null, scopes.state.status === "error" ? (_jsx(LoadError, { message: "Could not read the channels from the daemon.", onRetry: scopes.reload })) : scopes.value === null ? (_jsx(SkeletonRows, { label: "Loading channels", rows: 2 })) : scopeList.length === 0 || scopeId === null ? (_jsx(EmptyState, { title: "No channels yet", children: _jsx("p", { children: "Hook tests are kept per channel once one is set up." }) })) : (_jsxs(_Fragment, { children: [_jsx(ScopeSelect, { scopes: scopeList, value: scopeId, onChange: (id) => setPicked(id) }), _jsx(HookTestView, { source: source, rev: rev, scopeId: scopeId }, scopeId)] }))] }));
+}
+function HookTestView({ source, rev, scopeId }) {
+    const { state, reload, value } = useAsync(() => source.listHookTests(scopeId), [source, rev, scopeId]);
+    const [picked, setPicked] = useState(null);
+    if (state.status === "error") {
+        return _jsx(LoadError, { message: "Could not read the hook tests from the daemon.", onRetry: reload });
+    }
+    if (value === null)
+        return _jsx(SkeletonRows, { label: "Loading hook tests", rows: 3 });
+    if (value.length === 0) {
+        return (_jsx(EmptyState, { title: "No hook tests yet", children: _jsx("p", { children: "This channel has no hook test. A set is made on the daemon host, not here. This is not an error." }) }));
+    }
+    const selected = value.find((s) => s.id === picked) ?? value[0];
+    return (_jsxs(_Fragment, { children: [_jsxs("section", { "aria-labelledby": "hook-list-title", children: [_jsxs("h2", { id: "hook-list-title", className: "op-section-title", children: ["Hook tests (", value.length, ")"] }), _jsx("div", { className: "op-table-scroll", children: _jsxs(Table, { "aria-labelledby": "hook-list-title", children: [_jsx(TableCaption, { children: "Variant sets in this channel" }), _jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableHeaderCell, { children: "Set" }), _jsx(TableHeaderCell, { children: "Brief" }), _jsx(TableHeaderCell, { children: "State" }), _jsx(TableHeaderCell, { children: "Metric and window" }), _jsx(TableHeaderCell, { align: "end", children: "Openings bound" }), _jsx(TableHeaderCell, { children: "Created (UTC)" })] }) }), _jsx(TableBody, { children: value.map((set) => {
+                                        const badge = HOOK_STATE_LABEL[set.state];
+                                        const bound = set.openings.filter((o) => o.jobId !== null).length;
+                                        return (_jsxs(TableRow, { children: [_jsx(TableCell, { rowHeader: true, className: "op-mono", children: set.id }), _jsx(TableCell, { children: set.briefRef }), _jsx(TableCell, { children: _jsx(Badge, { tone: badge.tone, children: badge.text }) }), _jsxs(TableCell, { children: [set.metric, ", ", set.window] }), _jsxs(TableCell, { numeric: true, children: [bound, " of ", set.openings.length] }), _jsx(TableCell, { className: "op-mono", children: instantLabel(set.createdAtUtc, "UTC") })] }, set.id));
+                                    }) })] }) })] }), _jsxs("section", { "aria-labelledby": "hook-detail-heading", children: [_jsx("h2", { id: "hook-detail-heading", className: "op-section-title", children: "Selected hook test" }), _jsx(Field, { label: "Hook test", children: ({ id, "aria-describedby": describedBy }) => (_jsx("select", { id: id, "aria-describedby": describedBy, className: "op-select", value: selected.id, onChange: (e) => setPicked(e.target.value), children: value.map((set) => (_jsxs("option", { value: set.id, children: [set.briefRef, " (", set.id, ")"] }, set.id))) })) }), _jsx(HookTestDetail, { source: source, rev: rev, scopeId: scopeId, setId: selected.id }, selected.id)] })] }));
+}
+function HookTestDetail({ source, rev, scopeId, setId, }) {
+    const { state, reload } = useAsync(() => source.getHookTest(scopeId, setId), [source, rev, scopeId, setId]);
+    if (state.status === "error") {
+        return _jsx(LoadError, { message: "Could not read this hook test from the daemon.", onRetry: reload });
+    }
+    if (state.status === "loading")
+        return _jsx(SkeletonRows, { label: "Loading the hook test", rows: 3 });
+    const set = state.value;
+    if (set === null)
+        return _jsx("p", { className: "op-hint", children: "This hook test is no longer in this channel." });
+    const badge = HOOK_STATE_LABEL[set.state];
+    return (_jsxs("article", { className: "op-detail", "aria-labelledby": "hook-detail-title", children: [_jsx("h3", { id: "hook-detail-title", className: "op-detail__title", children: set.briefRef }), _jsx("div", { className: "op-badges", children: _jsx(Badge, { tone: badge.tone, children: badge.text }) }), set.state === "open" ? (_jsx("p", { className: "op-hint", children: "This set is open. Each opening is read 24 hours after its job is published. That reading happens on the server, not here. This screen shows the set as it stands and does not read it or decide it." })) : (_jsxs("p", { className: "op-hint", children: ["Decided ", instantOrNone(set.decidedAtUtc), ". Opening ", set.winnerIndex ?? "not recorded", " was promoted and the other openings were archived. Each keeps the number it was compared on, when it was observed and the pull that stored it."] })), _jsxs("dl", { className: "op-dl", children: [_jsx("dt", { children: "Metric and window" }), _jsxs("dd", { children: [set.metric, ", ", set.window] }), _jsx("dt", { children: "Revision" }), _jsx("dd", { children: set.revision }), _jsx("dt", { children: "Created" }), _jsx("dd", { children: instantLabel(set.createdAtUtc, "UTC") }), _jsx("dt", { children: "Last changed" }), _jsx("dd", { children: instantLabel(set.updatedAtUtc, "UTC") })] }), _jsx("h4", { className: "op-section-title", children: "Body" }), _jsx("div", { className: "op-caption", children: set.body }), _jsx("h4", { id: "hook-openings-title", className: "op-section-title", children: "Openings" }), _jsx("div", { className: "op-table-scroll", children: _jsxs(Table, { "aria-labelledby": "hook-openings-title", children: [_jsx(TableCaption, { children: set.state === "open" ? "Openings and their bound jobs" : "Openings with their numbers and lineage" }), _jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableHeaderCell, { children: "Opening" }), _jsx(TableHeaderCell, { children: "Bound job" }), _jsx(TableHeaderCell, { children: "Role" }), _jsxs(TableHeaderCell, { align: "end", children: [set.metric, " value"] }), _jsx(TableHeaderCell, { children: "Observed (UTC)" }), _jsx(TableHeaderCell, { children: "Pull" }), _jsx(TableHeaderCell, { children: "Published (UTC)" })] }) }), _jsx(TableBody, { children: set.openings.map((opening) => (_jsxs(TableRow, { children: [_jsxs(TableCell, { rowHeader: true, children: [opening.index, ". ", opening.text] }), _jsx(TableCell, { className: "op-mono", children: opening.jobId ?? "Not bound yet" }), _jsx(TableCell, { children: roleText(opening) }), _jsx(TableCell, { numeric: true, children: opening.value === null ? "Not read" : groupDigits(opening.value) }), _jsx(TableCell, { className: "op-mono", children: instantOrNone(opening.observedAtUtc) }), _jsx(TableCell, { className: "op-mono", children: opening.pullId ?? "None" }), _jsx(TableCell, { className: "op-mono", children: instantOrNone(opening.publishedAtUtc) })] }, opening.index))) })] }) })] }));
+}

package/dist/screens/InboxScreen.d.ts

@@ -0,0 +1,12 @@
+import { type DataSource } from "../data/index.js";
+interface Props {
+    source: DataSource;
+    rev: number;
+}
+/**
+ * The inbox of the signed webhook events. Every text, id and time in an event was written by the sender. The
+ * screen renders each one as a React text child: never as markup, a link, an attribute or a class. Keys are the
+ * engine's event ids. Nothing here sends a reply, marks an event or changes its state.
+ */
+export declare function InboxScreen({ source, rev }: Props): import("react").JSX.Element;
+export {};

package/dist/screens/InboxScreen.js

@@ -0,0 +1,76 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Badge, Button, EmptyState, PageShell, SkeletonRows, Table, TableBody, TableCaption, TableCell, TableHead, TableHeaderCell, TableRow } from "@rightkit/react-shell/react";
+import { ScopeSelect } from "../components/ScopeSelect.js";
+import { LoadError, MockBanner } from "../components/Shared.js";
+import { useAsync } from "../hooks/useAsync.js";
+import { groupDigits, instantLabel, } from "../data/index.js";
+import { inboxKindText, inboxStateText, platformName } from "./labels.js";
+import { hostAppName } from "../appName.js";
+/**
+ * The inbox of the signed webhook events. Every text, id and time in an event was written by the sender. The
+ * screen renders each one as a React text child: never as markup, a link, an attribute or a class. Keys are the
+ * engine's event ids. Nothing here sends a reply, marks an event or changes its state.
+ */
+export function InboxScreen({ source, rev }) {
+    const scopes = useAsync(() => source.listScopes(), [source, rev]);
+    const stats = useAsync(() => source.inboxStats(), [source, rev]);
+    const [picked, setPicked] = useState(null);
+    const scopeList = scopes.value ?? [];
+    const scopeId = scopeList.find((s) => s.id === picked)?.id ?? scopeList[0]?.id ?? null;
+    return (_jsxs(PageShell, { title: "Inbox", subtitle: "Read only. The signed webhook events the daemon stored for one channel account, newest first, and the events no account matched. Nothing here replies, marks, ignores or handles an event.", children: [source.kind === "mock" ? _jsx(MockBanner, {}) : null, _jsxs("p", { className: "op-hint", children: ["Event text is shown exactly as received, as plain text. ", hostAppName(), " sends no reply from this screen."] }), scopes.state.status === "error" ? (_jsx(LoadError, { message: "Could not read the channels from the daemon.", onRetry: scopes.reload })) : scopes.value === null ? (_jsx(SkeletonRows, { label: "Loading channels", rows: 2 })) : scopeList.length === 0 || scopeId === null ? (_jsx(EmptyState, { title: "No channels yet", children: _jsx("p", { children: "The inbox is kept per channel once one is set up." }) })) : (_jsxs(_Fragment, { children: [_jsx(ScopeSelect, { scopes: scopeList, value: scopeId, onChange: (id) => setPicked(id) }), stats.state.status === "error" ? (_jsx(LoadError, { message: "Could not read the inbox counts from the daemon.", onRetry: stats.reload })) : stats.value === null ? (_jsx(SkeletonRows, { label: "Loading the inbox counts", rows: 1 })) : (_jsx(InboxCounts, { stats: stats.value, scopeId: scopeId })), _jsx(EventSection, { source: source, rev: rev, scopeId: scopeId, headingId: "inbox-scope-title", title: "Events of this channel", caption: "Webhook events bound to this channel account, newest first", emptyText: "Nothing has arrived for this channel yet." }, `scope:${scopeId}`)] })), _jsx(EventSection, { source: source, rev: rev, scopeId: null, headingId: "inbox-unmatched-title", title: "Not matched to an account", caption: "Webhook events no stored account matched, newest first", emptyText: "No event is waiting here: every stored event matched an account." }, "unmatched")] }));
+}
+/** The counts of the whole store, and this channel's counts by kind and state as stored. Counts are never rates. */
+function InboxCounts({ stats, scopeId }) {
+    const channelGroups = stats.groups.filter((row) => !("readable" in row) && row.scopeId === scopeId);
+    const unreadableGroups = stats.groups.filter((row) => "readable" in row).length;
+    return (_jsxs("section", { "aria-labelledby": "inbox-counts-title", children: [_jsx("h2", { id: "inbox-counts-title", className: "op-section-title", children: "Counts" }), _jsxs("p", { className: "op-count", children: ["Whole store, all channels: ", groupDigits(String(stats.totalEvents)), " events stored,", " ", groupDigits(String(stats.unmatchedEvents)), " not matched to an account."] }), _jsxs("p", { className: "op-count", children: ["Deliveries stored: ", groupDigits(String(stats.deliveriesParsed)), " read,", " ", groupDigits(String(stats.deliveriesUnparseable)), " could not be read."] }), _jsxs("p", { className: "op-count", children: ["Deliveries refused for a bad signature (whole store): ", groupDigits(String(stats.refusedTotal)), "."] }), _jsx("p", { className: "op-hint", children: "The refusal count is not kept per channel. A refused delivery is never stored, so it adds no event." }), channelGroups.length === 0 ? (_jsx("p", { className: "op-hint", children: "No event is counted for this channel." })) : (_jsx("div", { className: "op-table-scroll", children: _jsxs(Table, { "aria-labelledby": "inbox-counts-title", children: [_jsx(TableCaption, { children: "Events of this channel by kind and state, as stored" }), _jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableHeaderCell, { children: "Kind" }), _jsx(TableHeaderCell, { children: "State" }), _jsx(TableHeaderCell, { align: "end", children: "Count" })] }) }), _jsx(TableBody, { children: channelGroups.map((group, index) => (_jsxs(TableRow, { children: [_jsx(TableCell, { rowHeader: true, children: inboxKindText(group.kind) }), _jsx(TableCell, { children: inboxStateText(group.state).text }), _jsx(TableCell, { numeric: true, className: "op-mono", children: groupDigits(String(group.count)) })] }, `count:${index}`))) })] }) })), unreadableGroups === 0 ? null : (_jsxs("p", { className: "op-hint", children: [groupDigits(String(unreadableGroups)), " count row", unreadableGroups === 1 ? " could" : "s could", " not be read, and ", unreadableGroups === 1 ? "is" : "are", " not in the table above."] }))] }));
+}
+/** One list of events: a channel account's, or the unmatched ones. Each keeps its own selection. */
+function EventSection({ source, rev, scopeId, headingId, title, caption, emptyText, }) {
+    const listing = useAsync(() => source.listInbox(scopeId), [source, rev, scopeId]);
+    const [picked, setPicked] = useState(null);
+    if (listing.state.status === "error") {
+        return (_jsxs("section", { "aria-labelledby": headingId, children: [_jsx("h2", { id: headingId, className: "op-section-title", children: title }), _jsx(LoadError, { message: "Could not read these events from the daemon.", onRetry: listing.reload })] }));
+    }
+    if (listing.state.status === "loading") {
+        return (_jsxs("section", { "aria-labelledby": headingId, children: [_jsx("h2", { id: headingId, className: "op-section-title", children: title }), _jsx(SkeletonRows, { label: "Loading the events", rows: 3 })] }));
+    }
+    const { rows, moreAvailable } = listing.state.value;
+    if (rows.length === 0) {
+        return (_jsxs("section", { "aria-labelledby": headingId, children: [_jsx("h2", { id: headingId, className: "op-section-title", children: title }), _jsx(EmptyState, { title: "No events yet", children: _jsx("p", { children: emptyText }) })] }));
+    }
+    const selected = rows.find((row) => row.readable === true && row.eventId === picked) ?? null;
+    return (_jsxs("section", { "aria-labelledby": headingId, children: [_jsxs("h2", { id: headingId, className: "op-section-title", children: [title, " (", groupDigits(String(rows.length)), ")"] }), moreAvailable ? (_jsx("p", { className: "op-hint", children: "Only the newest page is loaded here. Older events exist and are not shown on this screen." })) : null, _jsx("div", { className: "op-table-scroll", children: _jsxs(Table, { "aria-labelledby": headingId, children: [_jsx(TableCaption, { children: caption }), _jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableHeaderCell, { children: "Received (UTC)" }), _jsx(TableHeaderCell, { children: "Platform" }), _jsx(TableHeaderCell, { children: "Kind" }), _jsx(TableHeaderCell, { children: "Sender id, as given" }), _jsx(TableHeaderCell, { children: "Text, as received" }), _jsx(TableHeaderCell, { children: "Event time, as given" }), _jsx(TableHeaderCell, { children: "State" }), _jsx(TableHeaderCell, { children: "Marks" }), _jsx(TableHeaderCell, { children: "Raw item" })] }) }), _jsx(TableBody, { children: rows.map((row, index) => row.readable === true ? (_jsx(EventRow, { event: row, selected: selected?.eventId === row.eventId, onSelect: () => setPicked(row.eventId) }, `event:${row.eventId}`)) : (_jsx(UnreadableTableRow, { row: row }, `unreadable:${index}`))) })] }) }), _jsx("p", { role: "status", "aria-live": "polite", className: "op-hint", children: selected === null ? "" : `Showing the raw item of event ${selected.eventId}.` }), selected === null ? null : (_jsx(RawItem, { source: source, rev: rev, scopeId: scopeId, eventId: selected.eventId, idPrefix: headingId }, selected.eventId))] }));
+}
+function EventRow({ event, selected, onSelect }) {
+    const state = inboxStateText(event.state);
+    return (_jsxs(TableRow, { children: [_jsx(TableCell, { rowHeader: true, className: "op-mono", children: instantLabel(event.receivedAtUtc, "UTC") }), _jsx(TableCell, { children: platformName(event.platform) }), _jsx(TableCell, { children: inboxKindText(event.kind) }), _jsx(TableCell, { className: "op-mono", children: event.senderId ?? "No sender id given" }), _jsx(TableCell, { children: event.text === null ? "No text in this event" : _jsx("span", { className: "op-inbox__text", children: event.text }) }), _jsx(TableCell, { className: "op-mono", children: event.eventTimeAsGiven ?? "Not given" }), _jsxs(TableCell, { children: [_jsx(Badge, { tone: state.tone, children: state.text }), event.stateBy !== null && event.stateAtUtc !== null ? (_jsxs("div", { children: ["Set by ", event.stateBy, " at ", instantLabel(event.stateAtUtc, "UTC")] })) : null, event.stateNote === "" ? null : _jsxs("div", { children: ["Note: ", event.stateNote] })] }), _jsxs(TableCell, { children: [event.unmatched ? (_jsxs("p", { children: [_jsx("span", { className: "op-mark", children: "Not matched" }), " ", unmatchedText(event.unmatchedReason)] })) : null, event.oversize ? (_jsxs("p", { children: [_jsx("span", { className: "op-mark", children: "Cut" }), " A field was cut to its bound. The raw item keeps all of it."] })) : null, event.unmatched || event.oversize ? null : _jsx("p", { children: "None" })] }), _jsx(TableCell, { children: _jsx(Button, { size: "sm", variant: "secondary", "aria-pressed": selected, "aria-label": `Show the raw item of event ${event.eventId}`, onClick: onSelect, children: selected ? "Showing" : "Show" }) })] }));
+}
+/** A row the desktop cannot read: shown with its reason and its raw JSON, never dropped. */
+function UnreadableTableRow({ row }) {
+    return (_jsx(TableRow, { children: _jsxs(TableCell, { colSpan: 9, children: [_jsxs("p", { children: ["This row could not be read: ", row.reason, ". It is kept here with its raw JSON."] }), _jsx("pre", { className: "op-raw", tabIndex: 0, "aria-label": "Raw JSON of a row that could not be read", children: row.rawJson })] }) }));
+}
+/** The raw item of the selected event, as the daemon kept it: untrusted text in a read-only, wrapping block. */
+function RawItem({ source, rev, scopeId, eventId, idPrefix, }) {
+    const raw = useAsync(() => source.getInboxEvent(scopeId, eventId), [source, rev, scopeId, eventId]);
+    const titleId = `${idPrefix}-raw`;
+    if (raw.state.status === "error") {
+        return _jsx(LoadError, { message: "Could not read the raw item from the daemon.", onRetry: raw.reload });
+    }
+    if (raw.state.status === "loading") {
+        return _jsx(SkeletonRows, { label: "Loading the raw item", rows: 2 });
+    }
+    const item = raw.state.value;
+    if (item === null)
+        return _jsx("p", { className: "op-hint", children: "No raw item is stored for this event in this channel." });
+    return (_jsxs("section", { "aria-labelledby": titleId, children: [_jsx("h3", { id: titleId, className: "op-section-title", children: "Raw item, as received" }), _jsx("p", { className: "op-hint", children: "Written by the sender. Shown as plain text in a read-only block. Nothing in it is a link or markup." }), _jsx("pre", { className: "op-raw", tabIndex: 0, "aria-labelledby": titleId, children: item.rawJson })] }));
+}
+function unmatchedText(reason) {
+    if (reason === "no_account")
+        return "No stored account has this recipient id.";
+    if (reason === "ambiguous_account") {
+        return "More than one stored account has this recipient id, so none was chosen.";
+    }
+    return reason === null ? "Reason not stated." : `Reason as stored: ${reason}`;
+}

package/dist/screens/LinksScreen.d.ts

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

package/dist/screens/LinksScreen.js

@@ -0,0 +1,52 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Button, EmptyState, PageShell, SkeletonRows, Table, TableBody, TableCaption, TableCell, TableHead, TableHeaderCell, TableRow } from "@rightkit/react-shell/react";
+import { ScopeSelect } from "../components/ScopeSelect.js";
+import { LoadError, MockBanner } from "../components/Shared.js";
+import { useAsync } from "../hooks/useAsync.js";
+import { shell } from "../lib/shell.js";
+import { groupDigits, instantLabel } from "../data/index.js";
+import { platformName } from "./labels.js";
+import { hostAppName } from "../appName.js";
+export function LinksScreen({ source, rev }) {
+    const scopes = useAsync(() => source.listScopes(), [source, rev]);
+    const [picked, setPicked] = useState(null);
+    const scopeList = scopes.value ?? [];
+    const scopeId = scopeList.find((s) => s.id === picked)?.id ?? scopeList[0]?.id ?? null;
+    return (_jsxs(PageShell, { title: "Links", subtitle: "Read only. The tracked links of one channel: each destination, its UTM parts and full tagged URL, the campaign and the post it belongs to, and the visit counts the daemon holds. Nothing here cuts a link, records a visit or redirects a visitor.", children: [source.kind === "mock" ? _jsx(MockBanner, {}) : null, scopes.state.status === "error" ? (_jsx(LoadError, { message: "Could not read the channels from the daemon.", onRetry: scopes.reload })) : scopes.value === null ? (_jsx(SkeletonRows, { label: "Loading channels", rows: 2 })) : scopeList.length === 0 || scopeId === null ? (_jsx(EmptyState, { title: "No channels yet", children: _jsx("p", { children: "Links are kept per channel once one is set up." }) })) : (_jsxs(_Fragment, { children: [_jsx(ScopeSelect, { scopes: scopeList, value: scopeId, onChange: (id) => setPicked(id) }), _jsx(LinksView, { source: source, rev: rev, scopeId: scopeId }, scopeId)] }))] }));
+}
+function LinksView({ source, rev, scopeId }) {
+    const links = useAsync(() => source.listChannelLinks(scopeId), [source, rev, scopeId]);
+    const [notice, setNotice] = useState("");
+    const copy = async (text, what) => {
+        try {
+            await shell.clipboard.write({ text });
+            setNotice(`Copied ${what}.`);
+        }
+        catch {
+            setNotice(`Copying ${what} failed. Select the text and copy it by hand.`);
+        }
+    };
+    if (links.state.status === "error") {
+        return _jsx(LoadError, { message: "Could not read the tracked links from the daemon.", onRetry: links.reload });
+    }
+    if (links.value === null)
+        return _jsx(SkeletonRows, { label: "Loading the tracked links", rows: 3 });
+    const rows = links.value;
+    if (rows.length === 0) {
+        return (_jsx(EmptyState, { title: "No links yet", children: _jsx("p", { children: "Nothing is wrong: no links have been recorded for this channel yet. Links are cut on the daemon host, not here." }) }));
+    }
+    return (_jsxs(_Fragment, { children: [_jsxs("p", { className: "op-hint", children: [hostAppName(), " records links; it does not count clicks here. A link is a string: nothing serves it or redirects a visitor. Visit counts are the plain numbers the daemon has recorded, shown exactly as stored. The engine gives a count no time and no source of its own, so each row says so. Nothing here computes a rate, a total or a ranking."] }), _jsx("p", { role: "status", "aria-live": "polite", className: "op-hint", children: notice }), _jsxs("section", { "aria-labelledby": "links-list-title", children: [_jsxs("h2", { id: "links-list-title", className: "op-section-title", children: ["Tracked links (", groupDigits(String(rows.length)), ")"] }), _jsx("div", { className: "op-table-scroll", children: _jsxs(Table, { "aria-labelledby": "links-list-title", children: [_jsx(TableCaption, { children: "Tracked links in this channel, by campaign, variant, platform and link id" }), _jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableHeaderCell, { children: "Link" }), _jsx(TableHeaderCell, { children: "Campaign" }), _jsx(TableHeaderCell, { children: "Post (calendar entry)" }), _jsx(TableHeaderCell, { children: "Destination" }), _jsx(TableHeaderCell, { children: "UTM parts" }), _jsx(TableHeaderCell, { children: "Full tagged URL" }), _jsx(TableHeaderCell, { children: "State" }), _jsx(TableHeaderCell, { children: "Created (UTC)" }), _jsx(TableHeaderCell, { children: "Last changed" }), _jsx(TableHeaderCell, { align: "end", children: "Visits recorded" })] }) }), _jsx(TableBody, { children: rows.map((row) => (_jsx(LinkRow, { row: row, copy: copy }, `link:${row.link.scopeId}:${row.link.id}`))) })] }) })] })] }));
+}
+/** One link. Each URL is text with its own Copy button; neither is an anchor, so nothing opens from here. */
+function LinkRow({ row, copy }) {
+    const { link } = row;
+    const label = `${platformName(link.platform)}, variant ${link.variantId}, link ${link.id}`;
+    const utmParts = [
+        ["utm_source", link.utmSource],
+        ["utm_medium", link.utmMedium],
+        ["utm_campaign", link.utmCampaign],
+        ["utm_content", link.utmContent],
+    ];
+    return (_jsxs(TableRow, { children: [_jsxs(TableCell, { rowHeader: true, children: [_jsx("div", { className: "op-mono", children: link.id }), _jsxs("div", { children: [platformName(link.platform), ", variant ", _jsx("span", { className: "op-mono", children: link.variantId })] })] }), _jsxs(TableCell, { children: [_jsx("div", { children: row.campaignName }), _jsx("div", { className: "op-mono", children: link.campaignId })] }), _jsx(TableCell, { className: "op-mono", children: link.calendarEntryId ?? "No calendar entry attached" }), _jsxs(TableCell, { children: [_jsx("div", { className: "op-mono", children: link.destination }), _jsx(Button, { size: "sm", variant: "secondary", "aria-label": `Copy the destination of ${label}`, onClick: () => copy(link.destination, `the destination of ${label}`), children: "Copy" })] }), _jsx(TableCell, { children: _jsx("ul", { className: "op-id-list", children: utmParts.map(([name, value]) => (_jsxs("li", { className: "op-mono", children: [name, ": ", value] }, name))) }) }), _jsxs(TableCell, { children: [_jsx("div", { className: "op-mono", children: link.finalUrl }), _jsx(Button, { size: "sm", variant: "secondary", "aria-label": `Copy the full tagged URL of ${label}`, onClick: () => copy(link.finalUrl, `the full tagged URL of ${label}`), children: "Copy" })] }), _jsx(TableCell, { children: "Stored. Links are never edited, so there is no later state." }), _jsx(TableCell, { className: "op-mono", children: instantLabel(link.createdAtUtc, "UTC") }), _jsx(TableCell, { children: "Never: a link is not edited after it is created." }), _jsxs(TableCell, { numeric: true, children: [_jsx("span", { className: "op-mono", children: row.visits ?? "Not read" }), _jsx("div", { className: "op-hint", children: "Source: link.attribution, the recorded visit count. Time: not stated by the engine." })] })] }));
+}

package/dist/screens/PacingScreen.d.ts

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

package/dist/screens/PacingScreen.js

@@ -0,0 +1,88 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Badge, EmptyState, PageShell, SkeletonRows, Table, TableBody, TableCaption, TableCell, TableHead, TableHeaderCell, TableRow } from "@rightkit/react-shell/react";
+import { ScopeSelect } from "../components/ScopeSelect.js";
+import { LoadError, MockBanner } from "../components/Shared.js";
+import { useAsync } from "../hooks/useAsync.js";
+import { groupDigits, instantLabel, } from "../data/index.js";
+import { PACING_REASON_LABEL, PUBLISH_STATE_LABEL, platformName } from "./labels.js";
+import { hostAppName } from "../appName.js";
+export function PacingScreen({ source, rev }) {
+    const scopes = useAsync(() => source.listScopes(), [source, rev]);
+    const [picked, setPicked] = useState(null);
+    const scopeList = scopes.value ?? [];
+    const scopeId = scopeList.find((s) => s.id === picked)?.id ?? scopeList[0]?.id ?? null;
+    return (_jsxs(PageShell, { title: "Pacing", subtitle: "Read only. What the daemon's publish pacing lets run now on one channel, every job that may not run with its reason and the earliest time it could, and each account's pacing as stored. Nothing here queues, runs, pauses or changes a limit.", children: [source.kind === "mock" ? _jsx(MockBanner, {}) : null, scopes.state.status === "error" ? (_jsx(LoadError, { message: "Could not read the channels from the daemon.", onRetry: scopes.reload })) : scopes.value === null ? (_jsx(SkeletonRows, { label: "Loading channels", rows: 2 })) : scopeList.length === 0 || scopeId === null ? (_jsx(EmptyState, { title: "No channels yet", children: _jsx("p", { children: "Publish pacing is kept per channel once one is set up." }) })) : (_jsxs(_Fragment, { children: [_jsx(ScopeSelect, { scopes: scopeList, value: scopeId, onChange: (id) => setPicked(id) }), _jsxs("p", { className: "op-hint", children: ["The default gap between posts and the default count per UTC day are ", hostAppName(), "'s own caution. They are not platform limits. A limit is set on the server by a person, not here."] }), _jsx(PacingView, { source: source, rev: rev, scopeId: scopeId, scopes: scopeList }, scopeId)] }))] }));
+}
+function PacingView({ source, rev, scopeId, scopes, }) {
+    const view = useAsync(() => source.listPublishNext(scopeId), [source, rev, scopeId]);
+    if (view.state.status === "error") {
+        return _jsx(LoadError, { message: "Could not read the publish pacing from the daemon.", onRetry: view.reload });
+    }
+    if (view.state.status === "loading") {
+        return _jsx(SkeletonRows, { label: "Loading the publish pacing", rows: 3 });
+    }
+    const data = view.state.value;
+    const total = data.ready.length + data.blocked.length + data.inProgress.length;
+    if (total === 0) {
+        return (_jsx(EmptyState, { title: "Nothing is queued", children: _jsx("p", { children: "Nothing is queued for this channel." }) }));
+    }
+    return (_jsxs(_Fragment, { children: [_jsxs("p", { role: "status", "aria-live": "polite", className: "op-hint", children: ["Decided at ", instantLabel(data.nowUtc, "UTC"), " by the daemon's clock."] }), _jsxs("section", { "aria-labelledby": "pacing-ready-title", children: [_jsxs("h2", { id: "pacing-ready-title", className: "op-section-title", children: ["May run now (", groupDigits(String(data.readyTotal)), ")"] }), data.ready.length === 0 ? (_jsx("p", { className: "op-hint", children: "No job may run now on this channel." })) : (_jsx("div", { className: "op-table-scroll", children: _jsxs(Table, { "aria-labelledby": "pacing-ready-title", children: [_jsx(TableCaption, { children: "Jobs that may run now, at most one per account, earliest scheduled time first" }), _jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableHeaderCell, { children: "Platform and remote account" }), _jsx(TableHeaderCell, { children: "Channel account" }), _jsx(TableHeaderCell, { children: "Job" }), _jsx(TableHeaderCell, { children: "Calendar entry" }), _jsx(TableHeaderCell, { children: "State" }), _jsx(TableHeaderCell, { children: "Phase" }), _jsx(TableHeaderCell, { children: "Scheduled (UTC)" })] }) }), _jsx(TableBody, { children: data.ready.map((row, index) => row.readable === true ? (_jsx(JobRow, { job: row, scopes: scopes }, `ready:${row.jobId}`)) : (_jsx(UnreadableJobRow, { row: row, colSpan: 7 }, `ready-unreadable:${index}`))) })] }) }))] }), _jsxs("section", { "aria-labelledby": "pacing-blocked-title", children: [_jsxs("h2", { id: "pacing-blocked-title", className: "op-section-title", children: ["May not run now (", groupDigits(String(data.blocked.length)), ")"] }), _jsx("p", { className: "op-hint", children: "Where a job waits behind another job on its account, the earliest time shown is a lower bound, not a promise. A job with no time given needs a person or a check first." }), data.blocked.length === 0 ? (_jsx("p", { className: "op-hint", children: "No job is held back." })) : (_jsx("div", { className: "op-table-scroll", children: _jsxs(Table, { "aria-labelledby": "pacing-blocked-title", children: [_jsx(TableCaption, { children: "Jobs that may not run now, with the reason in words, the other reasons, and the earliest run time" }), _jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableHeaderCell, { children: "Platform and remote account" }), _jsx(TableHeaderCell, { children: "Channel account" }), _jsx(TableHeaderCell, { children: "Job" }), _jsx(TableHeaderCell, { children: "State" }), _jsx(TableHeaderCell, { children: "Reason" }), _jsx(TableHeaderCell, { children: "Other reasons that apply" }), _jsx(TableHeaderCell, { children: "Earliest run (UTC)" }), _jsx(TableHeaderCell, { children: "Detail, as given" }), _jsx(TableHeaderCell, { children: "Behind job" })] }) }), _jsx(TableBody, { children: data.blocked.map((row, index) => row.readable === true ? (_jsx(BlockedRow, { job: row, scopes: scopes }, `blocked:${row.jobId}`)) : (_jsx(UnreadableJobRow, { row: row, colSpan: 9 }, `blocked-unreadable:${index}`))) })] }) }))] }), _jsxs("section", { "aria-labelledby": "pacing-progress-title", children: [_jsxs("h2", { id: "pacing-progress-title", className: "op-section-title", children: ["In progress (", groupDigits(String(data.inProgress.length)), ")"] }), _jsx("p", { className: "op-hint", children: "A job already past its create is in progress. Pacing does not hold it back; the daemon continues it." }), data.inProgress.length === 0 ? (_jsx("p", { className: "op-hint", children: "No job is in progress on this channel." })) : (_jsx("div", { className: "op-table-scroll", children: _jsxs(Table, { "aria-labelledby": "pacing-progress-title", children: [_jsx(TableCaption, { children: "Jobs in progress on this channel" }), _jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableHeaderCell, { children: "Platform and remote account" }), _jsx(TableHeaderCell, { children: "Channel account" }), _jsx(TableHeaderCell, { children: "Job" }), _jsx(TableHeaderCell, { children: "Calendar entry" }), _jsx(TableHeaderCell, { children: "State" }), _jsx(TableHeaderCell, { children: "Phase" }), _jsx(TableHeaderCell, { children: "Scheduled (UTC)" })] }) }), _jsx(TableBody, { children: data.inProgress.map((row, index) => row.readable === true ? (_jsx(JobRow, { job: row, scopes: scopes }, `progress:${row.jobId}`)) : (_jsx(UnreadableJobRow, { row: row, colSpan: 7 }, `progress-unreadable:${index}`))) })] }) }))] }), _jsx(AccountsSection, { accounts: accountsOf(data), source: source, rev: rev, scopes: scopes, nowUtc: data.nowUtc })] }));
+}
+function scopeLabelOf(scopes, scopeId) {
+    return scopes.find((s) => s.id === scopeId)?.label ?? "Not in the channel list";
+}
+function JobRow({ job, scopes }) {
+    const state = PUBLISH_STATE_LABEL[job.state];
+    return (_jsxs(TableRow, { children: [_jsxs(TableCell, { rowHeader: true, children: [_jsx("div", { children: platformName(job.platform) }), _jsx("div", { className: "op-mono", children: job.remoteAccount })] }), _jsx(TableCell, { children: scopeLabelOf(scopes, job.scopeId) }), _jsx(TableCell, { className: "op-mono", children: job.jobId }), _jsx(TableCell, { className: "op-mono", children: job.entryId }), _jsx(TableCell, { children: _jsx(Badge, { tone: state.tone, children: state.text }) }), _jsx(TableCell, { className: "op-mono", children: job.phase }), _jsx(TableCell, { className: "op-mono", children: instantLabel(job.scheduledAtUtc, "UTC") })] }));
+}
+function BlockedRow({ job, scopes }) {
+    const state = PUBLISH_STATE_LABEL[job.state];
+    const others = job.reasons.filter((reason) => reason !== job.reason);
+    return (_jsxs(TableRow, { children: [_jsxs(TableCell, { rowHeader: true, children: [_jsx("div", { children: platformName(job.platform) }), _jsx("div", { className: "op-mono", children: job.remoteAccount })] }), _jsx(TableCell, { children: scopeLabelOf(scopes, job.scopeId) }), _jsx(TableCell, { className: "op-mono", children: job.jobId }), _jsx(TableCell, { children: _jsx(Badge, { tone: state.tone, children: state.text }) }), _jsx(TableCell, { children: PACING_REASON_LABEL[job.reason] }), _jsx(TableCell, { children: others.length === 0 ? "None" : others.map((reason) => PACING_REASON_LABEL[reason]).join("; ") }), _jsx(TableCell, { className: "op-mono", children: job.untilUtc === null ? "Not given" : instantLabel(job.untilUtc, "UTC") }), _jsx(TableCell, { children: job.detail }), _jsx(TableCell, { className: "op-mono", children: job.behindJobId ?? "None" })] }));
+}
+/** A row the desktop cannot read: shown with its reason and its raw JSON, never dropped. */
+function UnreadableJobRow({ row, colSpan }) {
+    return (_jsx(TableRow, { children: _jsxs(TableCell, { colSpan: colSpan, children: [_jsxs("p", { children: ["This row could not be read: ", row.reason, ". It is kept here with its raw JSON."] }), _jsx("pre", { className: "op-raw", tabIndex: 0, "aria-label": "Raw JSON of a row that could not be read", children: row.rawJson })] }) }));
+}
+/** Each distinct account the jobs name, once, in the order the daemon lists its jobs. */
+function accountsOf(view) {
+    const rows = [...view.ready, ...view.inProgress, ...view.blocked];
+    const accounts = new Map();
+    for (const row of rows) {
+        if (row.readable !== true)
+            continue;
+        const id = JSON.stringify([row.scopeId, row.platform, row.remoteAccount]);
+        if (!accounts.has(id)) {
+            accounts.set(id, {
+                key: row.jobId,
+                scopeId: row.scopeId,
+                platform: row.platform,
+                remoteAccount: row.remoteAccount,
+            });
+        }
+    }
+    return [...accounts.values()];
+}
+function AccountsSection({ accounts, source, rev, scopes, nowUtc, }) {
+    return (_jsxs("section", { "aria-labelledby": "pacing-accounts-title", children: [_jsxs("h2", { id: "pacing-accounts-title", className: "op-section-title", children: ["Pacing per account (", groupDigits(String(accounts.length)), ")"] }), _jsxs("p", { className: "op-hint", children: ["Each account shows the limits in force. \"Defaults\" means no limit was stored for it, so ", hostAppName(), "'s own caution applies. \"Stored\" means a person set it on the server. This screen changes nothing."] }), _jsx("p", { className: "op-hint", children: "An account with no queued, waiting or running job is not listed here. The daemon names an account's remote id only in its jobs." }), accounts.length === 0 ? _jsx("p", { className: "op-hint", children: "No account has a job to show pacing for." }) : null, accounts.map((account) => (_jsx(AccountPacing, { source: source, rev: rev, account: account, scopes: scopes, nowUtc: nowUtc }, account.key)))] }));
+}
+/** One account's pacing. Its own read: a failed read shows for this account only, and the other accounts still show. */
+function AccountPacing({ source, rev, account, scopes, nowUtc, }) {
+    const quota = useAsync(() => source.getPublishQuota(account.scopeId, account.platform, account.remoteAccount), [source, rev, account.scopeId, account.platform, account.remoteAccount]);
+    const name = `${platformName(account.platform)} account ${account.remoteAccount}`;
+    if (quota.state.status === "error") {
+        return _jsx(LoadError, { message: `Could not read the pacing of the ${name} from the daemon.`, onRetry: quota.reload });
+    }
+    if (quota.state.status === "loading") {
+        return _jsx(SkeletonRows, { label: `Loading the pacing of the ${name}`, rows: 2 });
+    }
+    const q = quota.state.value;
+    const now = Date.parse(nowUtc);
+    const limitsText = q.optedIn ? "Stored by a person on the server" : `${hostAppName()} defaults: no limit stored`;
+    return (_jsxs("div", { children: [_jsxs("p", { className: "op-hint", children: ["Channel account: ", scopeLabelOf(scopes, account.scopeId)] }), _jsx("div", { className: "op-table-scroll", children: _jsxs(Table, { "aria-label": `Pacing of the ${name}, as stored`, children: [_jsxs(TableCaption, { children: ["Pacing of the ", name, ", as stored"] }), _jsxs(TableBody, { children: [_jsxs(TableRow, { children: [_jsx(TableCell, { rowHeader: true, children: "Limits in force" }), _jsx(TableCell, { children: limitsText })] }), _jsxs(TableRow, { children: [_jsx(TableCell, { rowHeader: true, children: "Gap between two creates" }), _jsxs(TableCell, { className: "op-mono", children: [q.minGapSecs, " seconds", q.optedIn ? `. ${hostAppName()} default: ${q.defaultMinGapSecs} seconds.` : " (the default)"] })] }), _jsxs(TableRow, { children: [_jsx(TableCell, { rowHeader: true, children: "Creates per UTC day" }), _jsxs(TableCell, { className: "op-mono", children: [q.maxPerDay, q.optedIn ? `. ${hostAppName()} default: ${q.defaultMaxPerDay}.` : " (the default)"] })] }), _jsxs(TableRow, { children: [_jsx(TableCell, { rowHeader: true, children: "Paused until" }), _jsx(TableCell, { children: q.pausedUntilUtc === null
+                                                ? "Not paused"
+                                                : `${instantLabel(q.pausedUntilUtc, "UTC")}, ${Date.parse(q.pausedUntilUtc) > now ? "in force" : "ended"}` })] }), _jsxs(TableRow, { children: [_jsx(TableCell, { rowHeader: true, children: "Last create (UTC)" }), _jsx(TableCell, { className: "op-mono", children: q.lastCreateAtUtc === null ? "None recorded" : instantLabel(q.lastCreateAtUtc, "UTC") })] }), _jsxs(TableRow, { children: [_jsx(TableCell, { rowHeader: true, children: "Creates today (UTC day)" }), _jsxs(TableCell, { className: "op-mono", children: [q.createsToday, ". The count restarts ", instantLabel(q.dayResetsAtUtc, "UTC"), "."] })] }), _jsxs(TableRow, { children: [_jsx(TableCell, { rowHeader: true, children: "Platform wait" }), _jsxs(TableCell, { children: [q.rateLimitedUntilUtc === null
+                                                    ? "None recorded"
+                                                    : `Until ${instantLabel(q.rateLimitedUntilUtc, "UTC")}, ${Date.parse(q.rateLimitedUntilUtc) > now ? "in force" : "ended"}`, q.rateLimitedAtUtc === null ? null : ` The signal was seen ${instantLabel(q.rateLimitedAtUtc, "UTC")}.`] })] })] })] }) })] }));
+}

package/dist/screens/PublishJobsScreen.d.ts

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

package/dist/screens/PublishJobsScreen.js

@@ -0,0 +1,66 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Badge, Button, EmptyState, PageShell, SkeletonRows, Table, TableBody, TableCaption, TableCell, TableHead, TableHeaderCell, TableRow } from "@rightkit/react-shell/react";
+import { ScopeSelect } from "../components/ScopeSelect.js";
+import { LoadError, MockBanner } from "../components/Shared.js";
+import { useAsync } from "../hooks/useAsync.js";
+import { shell } from "../lib/shell.js";
+import { groupDigits, instantLabel, } from "../data/index.js";
+import { PUBLISH_RESOLUTION_LABEL, PUBLISH_STATE_LABEL, platformName } from "./labels.js";
+import { hostAppName } from "../appName.js";
+/** The plain explanation shown above every outcome_unknown job. The wording is fixed. */
+const OUTCOME_UNKNOWN_TEXT = `The platform may or may not have received the post. ${hostAppName()} will not send it again by itself. A person must look at the account on the platform, then record what they saw with the publish.resolve_unknown command on the server. This screen cannot change a job.`;
+export function PublishJobsScreen({ source, rev }) {
+    const scopes = useAsync(() => source.listScopes(), [source, rev]);
+    const [picked, setPicked] = useState(null);
+    const scopeList = scopes.value ?? [];
+    const scopeId = scopeList.find((s) => s.id === picked)?.id ?? scopeList[0]?.id ?? null;
+    return (_jsxs(PageShell, { title: "Publish jobs", subtitle: "Read only. Every publish job of one channel, newest first: its platform, calendar entry, state, phase, attempts, next attempt, remote post and last error. Jobs whose outcome is unknown are listed first. Nothing here queues, steps, checks, cancels or resolves a job.", children: [source.kind === "mock" ? _jsx(MockBanner, {}) : null, scopes.state.status === "error" ? (_jsx(LoadError, { message: "Could not read the channels from the daemon.", onRetry: scopes.reload })) : scopes.value === null ? (_jsx(SkeletonRows, { label: "Loading channels", rows: 2 })) : scopeList.length === 0 || scopeId === null ? (_jsx(EmptyState, { title: "No channels yet", children: _jsx("p", { children: "Publish jobs are kept per channel once one is set up." }) })) : (_jsxs(_Fragment, { children: [_jsx(ScopeSelect, { scopes: scopeList, value: scopeId, onChange: (id) => setPicked(id) }), _jsx(PublishJobsView, { source: source, rev: rev, scopeId: scopeId }, scopeId)] }))] }));
+}
+function PublishJobsView({ source, rev, scopeId }) {
+    const jobs = useAsync(() => source.listPublishJobs(scopeId), [source, rev, scopeId]);
+    const [notice, setNotice] = useState("");
+    const copy = async (text, what) => {
+        try {
+            await shell.clipboard.write({ text });
+            setNotice(`Copied ${what}.`);
+        }
+        catch {
+            setNotice(`Copying ${what} failed. Select the text and copy it by hand.`);
+        }
+    };
+    if (jobs.state.status === "error") {
+        return _jsx(LoadError, { message: "Could not read the publish jobs from the daemon.", onRetry: jobs.reload });
+    }
+    if (jobs.state.status === "loading") {
+        return _jsx(SkeletonRows, { label: "Loading the publish jobs", rows: 3 });
+    }
+    const rows = jobs.state.value;
+    if (rows.length === 0) {
+        return (_jsx(EmptyState, { title: "No publish jobs yet", children: _jsx("p", { children: "Nothing has been queued for publishing on this channel yet." }) }));
+    }
+    const unknown = rows.filter((job) => job.state === "outcome_unknown");
+    const others = rows.filter((job) => job.state !== "outcome_unknown");
+    return (_jsxs(_Fragment, { children: [_jsx("p", { className: "op-hint", children: "The daemon publishes; this screen shows only what it stored. Each value is shown exactly as stored. Nothing is sent to a platform from here." }), _jsx("p", { role: "status", "aria-live": "polite", className: "op-hint", children: notice }), _jsxs("section", { "aria-labelledby": "publish-unknown-title", children: [_jsxs("h2", { id: "publish-unknown-title", className: "op-section-title", children: ["Outcome unknown (", groupDigits(String(unknown.length)), ")"] }), _jsx("p", { className: "op-hint", children: OUTCOME_UNKNOWN_TEXT }), unknown.length === 0 ? (_jsx("p", { className: "op-hint", children: "No job has an unknown outcome." })) : (_jsx(JobTable, { caption: "Publish jobs whose outcome is unknown, newest first", labelledBy: "publish-unknown-title", rows: unknown, copy: copy }))] }), _jsxs("section", { "aria-labelledby": "publish-other-title", children: [_jsxs("h2", { id: "publish-other-title", className: "op-section-title", children: ["Other publish jobs (", groupDigits(String(others.length)), ")"] }), others.length === 0 ? (_jsx("p", { className: "op-hint", children: "No other publish job." })) : (_jsx(JobTable, { caption: "Publish jobs of this channel, newest first", labelledBy: "publish-other-title", rows: others, copy: copy }))] })] }));
+}
+function JobTable({ caption, labelledBy, rows, copy, }) {
+    return (_jsx("div", { className: "op-table-scroll", children: _jsxs(Table, { "aria-labelledby": labelledBy, children: [_jsx(TableCaption, { children: caption }), _jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableHeaderCell, { children: "Job and platform" }), _jsx(TableHeaderCell, { children: "Calendar entry" }), _jsx(TableHeaderCell, { children: "State" }), _jsx(TableHeaderCell, { children: "Phase" }), _jsx(TableHeaderCell, { align: "end", children: "Attempts" }), _jsx(TableHeaderCell, { children: "Next attempt (UTC)" }), _jsx(TableHeaderCell, { children: "Remote post and link" }), _jsx(TableHeaderCell, { children: "Last error" }), _jsx(TableHeaderCell, { children: "Resolved by a person" })] }) }), _jsx(TableBody, { children: rows.map((job) => (_jsx(JobRow, { job: job, copy: copy }, `job:${job.jobId}`))) })] }) }));
+}
+function JobRow({ job, copy }) {
+    const state = PUBLISH_STATE_LABEL[job.state];
+    const what = `${platformName(job.platform)} job ${job.jobId}`;
+    const link = job.permalink;
+    return (_jsxs(TableRow, { children: [_jsxs(TableCell, { rowHeader: true, children: [_jsx("div", { children: platformName(job.platform) }), _jsx("div", { className: "op-mono", children: job.jobId })] }), _jsxs(TableCell, { children: [_jsx("div", { className: "op-mono", children: job.entryId }), _jsxs("div", { children: ["Entry revision ", job.entryRevision] })] }), _jsx(TableCell, { children: _jsx(Badge, { tone: state.tone, children: state.text }) }), _jsx(TableCell, { className: "op-mono", children: job.phase }), _jsx(TableCell, { numeric: true, className: "op-mono", children: job.attempts }), _jsx(TableCell, { className: "op-mono", children: nextAttemptText(job) }), _jsxs(TableCell, { children: [job.remotePostId === null ? (_jsx("div", { children: "No remote post id." })) : (_jsxs("div", { children: ["Post id: ", _jsx("span", { className: "op-mono", children: job.remotePostId })] })), link === null ? (_jsx("div", { children: "No platform link." })) : (_jsxs(_Fragment, { children: [_jsx("div", { className: "op-mono", children: link }), _jsx(Button, { size: "sm", variant: "secondary", "aria-label": `Copy the permalink of ${what}`, onClick: () => copy(link, `the permalink of ${what}`), children: "Copy" })] }))] }), _jsx(TableCell, { children: job.errorCode === null ? ("No error recorded") : (_jsxs(_Fragment, { children: [_jsx("div", { className: "op-mono", children: job.errorCode }), _jsx("div", { children: job.errorMessage ?? "No message given." })] })) }), _jsx(TableCell, { children: job.resolution === null ? "Not resolved by a person" : _jsx(ResolutionView, { resolution: job.resolution }) })] }));
+}
+/** Who resolved an unknown job, when, what they decided, their note, and whether the remote id was typed by hand. */
+function ResolutionView({ resolution }) {
+    return (_jsxs("div", { children: [_jsxs("div", { children: ["Recorded by ", resolution.resolvedBy, " at ", instantLabel(resolution.resolvedAtUtc, "UTC")] }), _jsxs("div", { children: ["Decision: ", PUBLISH_RESOLUTION_LABEL[resolution.decision]] }), _jsxs("div", { children: ["Note: ", resolution.note] }), resolution.remoteIdEnteredByHand ? (_jsxs("div", { children: [_jsx("span", { className: "op-mark", children: "Entered by hand" }), " The remote id was typed by a person. The platform did not return it."] })) : null] }));
+}
+/** The next attempt only while the job waits. Any other state says it is not waiting. */
+function nextAttemptText(job) {
+    if (job.state !== "waiting")
+        return "Not waiting";
+    return job.nextAttemptAtUtc === null
+        ? "Waiting. The next attempt time is not reported."
+        : instantLabel(job.nextAttemptAtUtc, "UTC");
+}

package/dist/screens/SuggestionsScreen.d.ts

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

package/dist/screens/SuggestionsScreen.js

@@ -0,0 +1,94 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Badge, Button, EmptyState, Notice, PageShell, SkeletonRows } from "@rightkit/react-shell/react";
+import { ScopeSelect } from "../components/ScopeSelect.js";
+import { LoadError, MockBanner } from "../components/Shared.js";
+import { useAsync } from "../hooks/useAsync.js";
+import { groupDigits, instantLabel, } from "../data/index.js";
+import { OPTIMISE_STATE_LABEL, platformName } from "./labels.js";
+const SECTIONS = [
+    { state: "proposed", title: "Waiting for your decision", empty: "No suggestion is waiting for a decision." },
+    { state: "accepted", title: "Accepted", empty: "No suggestion has been accepted." },
+    { state: "dismissed", title: "Dismissed", empty: "No suggestion has been dismissed." },
+];
+/** Identifiers in the engine contain characters DOM ids do not allow here; keep letters, digits, "_" and "-". */
+function domId(raw) {
+    return raw.replace(/[^A-Za-z0-9_-]/g, "_");
+}
+export function SuggestionsScreen({ source, rev, onChanged }) {
+    const scopes = useAsync(() => source.listScopes(), [source, rev]);
+    const [picked, setPicked] = useState(null);
+    const [notice, setNotice] = useState(null);
+    const scopeList = scopes.value ?? [];
+    const scopeId = scopeList.find((s) => s.id === picked)?.id ?? scopeList[0]?.id ?? null;
+    return (_jsxs(PageShell, { title: "Suggestions", subtitle: "Calendar changes proposed from stored analytics. Accepting one creates a draft calendar entry. Nothing is approved or published.", children: [source.kind === "mock" ? _jsx(MockBanner, {}) : null, _jsx("p", { className: "op-hint", children: "A draft entry describes the suggestion. Write its real caption on the calendar, then approve it there." }), scopes.state.status === "error" ? (_jsx(LoadError, { message: "Could not read the channels from the daemon.", onRetry: scopes.reload })) : scopes.value === null ? (_jsx(SkeletonRows, { label: "Loading channels", rows: 2 })) : scopeList.length === 0 || scopeId === null ? (_jsx(EmptyState, { title: "No channels yet", children: _jsx("p", { children: "Suggestions appear for a channel once one is set up." }) })) : (_jsxs(_Fragment, { children: [_jsx(ScopeSelect, { scopes: scopeList, value: scopeId, onChange: (id) => {
+                            setPicked(id);
+                            setNotice(null);
+                        } }), notice ? (_jsx(Notice, { tone: notice.tone, className: "op-notice", children: notice.text })) : null, _jsx(ProposalList, { source: source, rev: rev, scopeId: scopeId, onChanged: onChanged, onNotice: setNotice }, scopeId)] }))] }));
+}
+function ProposalList({ source, rev, scopeId, onChanged, onNotice, }) {
+    const { state, reload, value } = useAsync(() => source.listProposals(scopeId), [source, rev, scopeId]);
+    if (state.status === "error") {
+        return _jsx(LoadError, { message: "Could not read suggestions from the daemon.", onRetry: reload });
+    }
+    if (value === null)
+        return _jsx(SkeletonRows, { label: "Loading suggestions", rows: 3 });
+    if (value.length === 0) {
+        return (_jsx(EmptyState, { title: "Not enough evidence yet", children: _jsx("p", { children: "This channel has no suggestion yet. A suggestion needs more published posts with stored analytics before the rule can compare them. This is not an error." }) }));
+    }
+    return (_jsx(_Fragment, { children: SECTIONS.map((section) => {
+            const items = value.filter((proposal) => proposal.state === section.state);
+            return (_jsxs("section", { className: "op-drafts-section", "aria-labelledby": `suggestions-${section.state}`, children: [_jsxs("h2", { id: `suggestions-${section.state}`, className: "op-section-title", children: [section.title, " (", items.length, ")"] }), items.length === 0 ? (_jsx("p", { className: "op-hint", children: section.empty })) : (_jsx("div", { className: "op-drafts", children: items.map((proposal) => (_jsx(ProposalCard, { proposal: proposal, scopeId: scopeId, source: source, onChanged: onChanged, onNotice: onNotice }, proposal.id))) }))] }, section.state));
+        }) }));
+}
+function ProposalCard({ proposal, scopeId, source, onChanged, onNotice, }) {
+    const [busy, setBusy] = useState(false);
+    const [whyOpen, setWhyOpen] = useState(false);
+    const id = domId(proposal.id);
+    const badge = OPTIMISE_STATE_LABEL[proposal.state];
+    async function decide(action) {
+        setBusy(true);
+        const result = action === "accept"
+            ? await source.acceptProposal(scopeId, proposal.id, proposal.revision)
+            : await source.dismissProposal(scopeId, proposal.id, proposal.revision);
+        setBusy(false);
+        if (result.ok) {
+            onNotice(action === "accept"
+                ? {
+                    tone: "ok",
+                    text: `Draft calendar entry created: ${result.value.calendarEntryId ?? "(no id returned)"}. It still needs a real caption and approval before it can be scheduled or published.`,
+                }
+                : { tone: "ok", text: "Dismissed. No calendar entry was created." });
+            onChanged();
+            return;
+        }
+        if (result.error.code === "revision_conflict") {
+            onNotice({
+                tone: "bad",
+                text: "This suggestion changed after the list was read. Nothing was changed, and the list has been reloaded. Check it and decide again.",
+            });
+            onChanged();
+            return;
+        }
+        onNotice({ tone: "bad", text: result.error.message });
+    }
+    return (_jsxs("article", { className: "op-card op-draft", "aria-labelledby": `proposal-${id}`, children: [_jsxs("h3", { id: `proposal-${id}`, className: "op-draft__title", children: [platformName(proposal.platform), ": remake a top-decile post"] }), _jsx("div", { className: "op-badges", children: _jsx(Badge, { tone: badge.tone, children: badge.text }) }), _jsxs("dl", { className: "op-dl", children: [_jsx("dt", { children: "Rule" }), _jsx("dd", { children: "Remake a post that is in the top decile for its channel." }), _jsx("dt", { children: "Source post" }), _jsx("dd", { className: "op-mono", children: proposal.sourceJobId }), _jsx("dt", { children: "Metric and window" }), _jsxs("dd", { children: [proposal.metric, ", ", proposal.window] }), _jsx("dt", { children: "Value against threshold" }), _jsxs("dd", { children: [groupDigits(proposal.value), " against a threshold of ", groupDigits(proposal.threshold), ". A post wins when its value is at least the threshold."] }), _jsx("dt", { children: "Sample" }), _jsxs("dd", { children: [proposal.sampleSize, " published posts. The top decile holds ", proposal.decileSize, "."] }), _jsx("dt", { children: "Observed" }), _jsx("dd", { children: instantLabel(proposal.observedAtUtc, "UTC") }), _jsx("dt", { children: "Due" }), _jsx("dd", { children: instantLabel(proposal.dueAtUtc, "UTC") }), proposal.decidedAtUtc ? (_jsxs(_Fragment, { children: [_jsx("dt", { children: "Decided" }), _jsxs("dd", { children: [instantLabel(proposal.decidedAtUtc, "UTC"), proposal.decisionNote ? `. Note: ${proposal.decisionNote}` : ""] })] })) : null, proposal.calendarEntryId ? (_jsxs(_Fragment, { children: [_jsx("dt", { children: "Draft calendar entry" }), _jsx("dd", { className: "op-mono", children: proposal.calendarEntryId })] })) : null] }), _jsxs("details", { onToggle: (e) => setWhyOpen(e.currentTarget.open), children: [_jsx("summary", { children: "Why this was suggested" }), whyOpen ? _jsx(WhyDetail, { source: source, scopeId: scopeId, proposalId: proposal.id }) : null] }), proposal.state === "proposed" ? (_jsxs("div", { className: "op-decide__buttons", children: [_jsx(Button, { variant: "primary", disabled: busy, onClick: () => decide("accept"), children: "Accept" }), _jsx(Button, { variant: "secondary", disabled: busy, onClick: () => decide("dismiss"), children: "Dismiss" })] })) : null] }));
+}
+/** The lineage of one suggestion, read when its "why" opens. Loads once per open. */
+function WhyDetail({ source, scopeId, proposalId }) {
+    const { state, reload } = useAsync(() => source.getProposal(scopeId, proposalId), [source, scopeId, proposalId]);
+    if (state.status === "error") {
+        return _jsx(LoadError, { message: "Could not read the lineage for this suggestion.", onRetry: reload });
+    }
+    if (state.status === "loading")
+        return _jsx("p", { className: "op-hint", children: "Loading the lineage." });
+    const detail = state.value;
+    if (detail === null)
+        return _jsx("p", { className: "op-hint", children: "This suggestion is no longer in this channel." });
+    return (_jsxs("dl", { className: "op-dl", children: [_jsx("dt", { children: "Published posts compared" }), _jsx("dd", { children: _jsx(IdList, { ids: detail.lineageJobIds }) }), _jsx("dt", { children: "Analytics pulls compared" }), _jsx("dd", { children: _jsx(IdList, { ids: detail.lineagePullIds }) })] }));
+}
+function IdList({ ids }) {
+    if (ids.length === 0)
+        return _jsx(_Fragment, { children: "None recorded." });
+    return (_jsx("ul", { className: "op-id-list", children: ids.map((id) => (_jsx("li", { className: "op-mono", children: id }, id))) }));
+}

package/dist/screens/TextGateScreen.d.ts

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