create-safest-tools 0.2.0

package/template/console/reports/controller.ts

@@ -0,0 +1,517 @@
+import { errorMessage, requestJson } from "../lib/http";
+import { getQueueWorkspaceSnapshot, subscribeToQueueWorkspace } from "../queues/store";
+import type { QueueRecord } from "../queues/types";
+import { getShellSnapshot, setShellSnapshot, subscribeToShell } from "../shell/store";
+import { reportEvents } from "./events";
+import { getReportWorkspaceSnapshot, setReportWorkspaceSnapshot } from "./store";
+import type {
+  HumanDecisionInput,
+  PresenceAnalyst,
+  ReportDetailRecord,
+  ReportFilters,
+  ReporterMessageInput,
+  ReportSummary,
+  ReportWorkspaceSnapshot,
+  WorkflowActionRecord,
+  WorkflowRunRecord,
+} from "./types";
+
+interface RawReport {
+  id: string;
+  reference: string;
+  targetType: string;
+  targetReference: string;
+  reasonCode: string;
+  queueId?: string;
+  state: string;
+  priority: number;
+  receivedAt: string;
+  claim?: {
+    reviewerId: string;
+    expiresAt: string;
+    analyst?: { displayName?: string; avatarUrl?: string | null; avatarColor?: string | null };
+  } | null;
+}
+
+interface RawPresenceAnalyst {
+  actorId: string;
+  displayName: string;
+  avatarUrl?: string | null;
+  avatarColor?: string | null;
+  activity: string;
+  activeReportId?: string | null;
+}
+
+interface ReportsResponse { reports?: RawReport[] }
+interface ReportResponse { report: ReportDetailRecord }
+interface TimelineResponse { events?: ReportDetailRecord["timeline"] }
+interface WorkflowRunsResponse { runs?: WorkflowRunRecord[] }
+interface WorkflowActionsResponse { actions?: WorkflowActionRecord[] }
+interface PresenceResponse { analysts?: RawPresenceAnalyst[] }
+
+const defaultFilters = (): ReportFilters => ({ search: "", queueId: "", priority: "", age: "", state: "", sort: "oldest" });
+const initialSnapshot = (): ReportWorkspaceSnapshot => ({
+  loading: true,
+  refreshing: false,
+  error: "",
+  generatedAt: new Date().toISOString(),
+  actorId: "",
+  filters: defaultFilters(),
+  queues: [],
+  reports: [],
+  presence: [],
+  actionCodes: [],
+  permissions: { claimReports: false, messageReporters: false, decideReports: false, readRuns: false },
+  detail: { reportId: null, loading: false, error: "", pendingAction: null, messageMutationVersion: 0, report: null },
+});
+
+let actorId = "";
+let rawReports: RawReport[] = [];
+let rawPresence: RawPresenceAnalyst[] = [];
+let detailRequestVersion = 0;
+let presenceSessionId = crypto.randomUUID();
+let presenceSocket: WebSocket | null = null;
+let presenceReconnectTimer: ReturnType<typeof setTimeout> | null = null;
+let presenceHeartbeatTimer: ReturnType<typeof setInterval> | null = null;
+let presenceRunning = false;
+let started = false;
+
+function readable(value: string): string {
+  const copy = value.replaceAll("_", " ");
+  if (!copy) return "";
+  const sentence = `${copy.charAt(0).toUpperCase()}${copy.slice(1)}`;
+  const acronyms: Record<string, string> = { ai: "AI", api: "API", csv: "CSV", d1: "D1", http: "HTTP", https: "HTTPS", id: "ID", json: "JSON", r2: "R2", sla: "SLA", url: "URL" };
+  return sentence.replace(/\b(ai|api|csv|d1|http|https|id|json|r2|sla|url)\b/giu, (match) => acronyms[match.toLowerCase()] ?? match);
+}
+
+function priorityName(priority: number): "high" | "medium" | "low" {
+  if (priority >= 70) return "high";
+  if (priority >= 40) return "medium";
+  return "low";
+}
+
+function queues(): QueueRecord[] {
+  return getQueueWorkspaceSnapshot().queues;
+}
+
+function visibleReports(filters: ReportFilters): RawReport[] {
+  const query = filters.search.trim().toLowerCase();
+  const now = Date.now();
+  return rawReports.filter((report) => {
+    if (filters.priority && priorityName(report.priority) !== filters.priority) return false;
+    const milliseconds = now - Date.parse(report.receivedAt);
+    if (filters.age === "hour" && milliseconds > 3_600_000) return false;
+    if (filters.age === "day" && milliseconds > 86_400_000) return false;
+    if (filters.age === "older" && milliseconds <= 86_400_000) return false;
+    if (!query) return true;
+    return [report.reference, report.targetReference, report.reasonCode, report.queueId, report.state]
+      .some((value) => String(value || "").toLowerCase().includes(query));
+  }).sort((left, right) => {
+    if (filters.sort === "newest") return Date.parse(right.receivedAt) - Date.parse(left.receivedAt);
+    if (filters.sort === "priority") return right.priority - left.priority || Date.parse(left.receivedAt) - Date.parse(right.receivedAt);
+    return Date.parse(left.receivedAt) - Date.parse(right.receivedAt);
+  });
+}
+
+function reportSummaries(filters: ReportFilters): ReportSummary[] {
+  const session = getShellSnapshot().session;
+  const queueList = queues();
+  return visibleReports(filters).map((report) => ({
+    id: report.id,
+    reference: report.reference,
+    queueId: report.queueId || "",
+    targetType: report.targetType,
+    targetReference: report.targetReference,
+    reasonCode: report.reasonCode,
+    queueName: queueList.find((queue) => queue.id === report.queueId)?.name || readable(report.queueId || "Unassigned"),
+    state: report.state,
+    priority: Number(report.priority || 0),
+    receivedAt: report.receivedAt,
+    owner: report.claim ? {
+      reviewerId: report.claim.reviewerId,
+      mine: report.claim.reviewerId === session?.actor.id,
+      displayName: report.claim.analyst?.displayName || "Unknown analyst",
+      avatarUrl: report.claim.analyst?.avatarUrl || null,
+      avatarColor: report.claim.analyst?.avatarColor || "#315d4d",
+    } : null,
+  }));
+}
+
+function presenceAnalysts(): PresenceAnalyst[] {
+  return rawPresence.map((analyst) => {
+    const report = analyst.activeReportId ? rawReports.find((candidate) => candidate.id === analyst.activeReportId) : null;
+    const activityLabel = report
+      ? `${readable(analyst.activity)} ${report.reference}`
+      : analyst.activeReportId
+        ? `${readable(analyst.activity)} report ${analyst.activeReportId.slice(0, 8)}`
+        : readable(analyst.activity);
+    return {
+      actorId: analyst.actorId,
+      displayName: analyst.displayName,
+      avatarUrl: analyst.avatarUrl || null,
+      avatarColor: analyst.avatarColor || "#315d4d",
+      activity: analyst.activity,
+      activeReportId: analyst.activeReportId || null,
+      activityLabel,
+    };
+  });
+}
+
+function publish(next?: Partial<ReportWorkspaceSnapshot>): void {
+  const current = getReportWorkspaceSnapshot();
+  const shell = getShellSnapshot();
+  const configuration = shell.configuration;
+  const availableQueues = queues().filter((queue) => queue.status !== "archived");
+  const filters = next?.filters || current.filters;
+  const validQueueId = !filters.queueId || availableQueues.some((queue) => queue.id === filters.queueId);
+  const reconciledFilters = validQueueId ? filters : { ...filters, queueId: "" };
+  setReportWorkspaceSnapshot({
+    ...current,
+    ...next,
+    generatedAt: new Date().toISOString(),
+    actorId: shell.session?.actor.id || "",
+    filters: reconciledFilters,
+    queues: availableQueues.map((queue) => ({ id: queue.id, name: queue.name })),
+    reports: reportSummaries(reconciledFilters),
+    presence: presenceAnalysts(),
+    actionCodes: Array.isArray(configuration?.allowed_action_codes) && configuration?.action_delivery_enabled
+      ? configuration.allowed_action_codes
+      : [],
+    permissions: {
+      claimReports: shell.session?.permissions.claimReports === true,
+      messageReporters: shell.session?.permissions.messageReporters === true,
+      decideReports: shell.session?.permissions.decideReports === true,
+      readRuns: shell.session?.permissions.readRuns === true,
+    },
+  });
+}
+
+async function loadReports(): Promise<void> {
+  const session = getShellSnapshot().session;
+  if (!session?.permissions.readReports) {
+    rawReports = [];
+    setShellSnapshot((shell) => ({ ...shell, reportCount: 0 }));
+    publish({ loading: false, refreshing: false, error: "" });
+    return;
+  }
+  const snapshot = getReportWorkspaceSnapshot();
+  publish({ error: "", refreshing: !snapshot.loading });
+  const params = new URLSearchParams({ limit: "100" });
+  if (snapshot.filters.queueId) params.set("queue_id", snapshot.filters.queueId);
+  if (snapshot.filters.state) params.set("state", snapshot.filters.state);
+  try {
+    const response = await requestJson<ReportsResponse>(`/v1/admin/reports?${params}`);
+    rawReports = response.reports || [];
+    setShellSnapshot((shell) => ({
+      ...shell,
+      reportCount: rawReports.filter((report) => !["resolved_by_human", "resolved_by_ai", "closed"].includes(report.state)).length,
+    }));
+  } catch (cause) {
+    publish({ error: errorMessage(cause, "Reports could not be loaded.") });
+  } finally {
+    publish({ loading: false, refreshing: false });
+  }
+}
+
+async function openReport(reportId: string): Promise<void> {
+  const version = ++detailRequestVersion;
+  const snapshot = getReportWorkspaceSnapshot();
+  document.body.classList.add("report-open");
+  publish({
+    detail: {
+      ...snapshot.detail,
+      reportId,
+      loading: true,
+      error: "",
+      report: snapshot.detail.report?.id === reportId ? snapshot.detail.report : null,
+    },
+  });
+  try {
+    const encodedId = encodeURIComponent(reportId);
+    const canReadRuns = getShellSnapshot().session?.permissions.readRuns === true;
+    const [reportResponse, timelineResponse, runsResponse, actionsResponse] = await Promise.all([
+      requestJson<ReportResponse>(`/v1/admin/reports/${encodedId}`),
+      requestJson<TimelineResponse>(`/v1/admin/reports/${encodedId}/timeline?limit=50`).catch(() => ({ events: [] })),
+      canReadRuns ? requestJson<WorkflowRunsResponse>(`/v1/admin/reports/${encodedId}/workflow-runs`).catch(() => ({ runs: [] })) : Promise.resolve({ runs: [] }),
+      requestJson<WorkflowActionsResponse>(`/v1/admin/reports/${encodedId}/actions`).catch(() => ({ actions: [] })),
+    ]);
+    if (version !== detailRequestVersion || getReportWorkspaceSnapshot().detail.reportId !== reportId) return;
+    publish({
+      detail: {
+        ...getReportWorkspaceSnapshot().detail,
+        report: {
+          ...reportResponse.report,
+          timeline: timelineResponse.events || [],
+          workflowRuns: runsResponse.runs || [],
+          workflowActions: actionsResponse.actions || [],
+        },
+      },
+    });
+    sendPresenceActivity();
+  } catch (cause) {
+    if (version !== detailRequestVersion || getReportWorkspaceSnapshot().detail.reportId !== reportId) return;
+    publish({ detail: { ...getReportWorkspaceSnapshot().detail, report: null, error: errorMessage(cause, "The report could not be opened.") } });
+  } finally {
+    if (version === detailRequestVersion && getReportWorkspaceSnapshot().detail.reportId === reportId) {
+      publish({ detail: { ...getReportWorkspaceSnapshot().detail, loading: false } });
+    }
+  }
+}
+
+function closeReport(): void {
+  detailRequestVersion += 1;
+  const messageMutationVersion = getReportWorkspaceSnapshot().detail.messageMutationVersion;
+  document.body.classList.remove("report-open");
+  publish({ detail: { reportId: null, loading: false, error: "", pendingAction: null, messageMutationVersion, report: null } });
+  sendPresenceActivity();
+}
+
+async function claimReport(): Promise<void> {
+  const snapshot = getReportWorkspaceSnapshot();
+  const reportId = snapshot.detail.report?.id;
+  if (!reportId || !snapshot.permissions.claimReports || snapshot.detail.pendingAction) return;
+  publish({ detail: { ...snapshot.detail, error: "", pendingAction: "claim" } });
+  try {
+    await requestJson(`/v1/admin/reports/${encodeURIComponent(reportId)}/claim`, { method: "POST" });
+    await Promise.all([openReport(reportId), loadReports()]);
+  } catch (cause) {
+    publish({ detail: { ...getReportWorkspaceSnapshot().detail, error: errorMessage(cause, "The report could not be claimed.") } });
+  } finally {
+    publish({ detail: { ...getReportWorkspaceSnapshot().detail, pendingAction: null } });
+  }
+}
+
+async function releaseReport(): Promise<void> {
+  const snapshot = getReportWorkspaceSnapshot();
+  const reportId = snapshot.detail.report?.id;
+  if (!reportId || !snapshot.permissions.claimReports || snapshot.detail.pendingAction) return;
+  publish({ detail: { ...snapshot.detail, error: "", pendingAction: "release" } });
+  try {
+    await requestJson(`/v1/admin/reports/${encodeURIComponent(reportId)}/claim`, { method: "DELETE" });
+    await Promise.all([openReport(reportId), loadReports()]);
+  } catch (cause) {
+    publish({ detail: { ...getReportWorkspaceSnapshot().detail, error: errorMessage(cause, "The claim could not be released.") } });
+  } finally {
+    publish({ detail: { ...getReportWorkspaceSnapshot().detail, pendingAction: null } });
+  }
+}
+
+async function sendMessage(input: ReporterMessageInput): Promise<void> {
+  const snapshot = getReportWorkspaceSnapshot();
+  const reportId = snapshot.detail.report?.id;
+  if (!reportId || !snapshot.permissions.messageReporters || snapshot.detail.pendingAction) return;
+  const idempotencyKey = crypto.randomUUID();
+  publish({ detail: { ...snapshot.detail, error: "", pendingAction: "message" } });
+  try {
+    await requestJson(`/v1/admin/reports/${encodeURIComponent(reportId)}/messages`, {
+      method: "POST",
+      headers: { "content-type": "application/json", "idempotency-key": idempotencyKey },
+      body: JSON.stringify({ idempotency_key: idempotencyKey, body: input.body, await_reporter: input.awaitReporter }),
+    });
+    const version = getReportWorkspaceSnapshot().detail.messageMutationVersion + 1;
+    publish({ detail: { ...getReportWorkspaceSnapshot().detail, messageMutationVersion: version } });
+    await Promise.all([openReport(reportId), loadReports()]);
+  } catch (cause) {
+    publish({ detail: { ...getReportWorkspaceSnapshot().detail, error: errorMessage(cause, "The message could not be created.") } });
+  } finally {
+    publish({ detail: { ...getReportWorkspaceSnapshot().detail, pendingAction: null } });
+  }
+}
+
+async function recordDecision(input: HumanDecisionInput): Promise<void> {
+  const snapshot = getReportWorkspaceSnapshot();
+  const reportId = snapshot.detail.report?.id;
+  if (!reportId || !snapshot.permissions.decideReports || snapshot.detail.pendingAction) return;
+  const idempotencyKey = crypto.randomUUID();
+  publish({ detail: { ...snapshot.detail, error: "", pendingAction: "decision" } });
+  try {
+    await requestJson(`/v1/admin/reports/${encodeURIComponent(reportId)}/decisions`, {
+      method: "POST",
+      headers: { "content-type": "application/json", "idempotency-key": idempotencyKey },
+      body: JSON.stringify({
+        idempotency_key: idempotencyKey,
+        decision_code: input.decisionCode,
+        policy_code: input.policyCode,
+        rationale: input.rationale,
+        evidence_references: input.evidenceReferences,
+        reporter_notice: input.reporterNotice,
+        affected_user_notice: input.affectedUserNotice,
+        ...(input.actionCode ? { action_code: input.actionCode } : {}),
+      }),
+    });
+    closeReport();
+    await loadReports();
+  } catch (cause) {
+    publish({ detail: { ...getReportWorkspaceSnapshot().detail, error: errorMessage(cause, "The decision could not be recorded.") } });
+  } finally {
+    publish({ detail: { ...getReportWorkspaceSnapshot().detail, pendingAction: null } });
+  }
+}
+
+function currentPresenceActivity(): { activity: string; reportId: string | null } {
+  const snapshot = getReportWorkspaceSnapshot();
+  const report = snapshot.detail.report;
+  if (!report || !snapshot.detail.reportId) return { activity: "online", reportId: null };
+  const claim = report.claim;
+  const mine = Boolean(claim && claim.reviewerId === getShellSnapshot().session?.actor.id && Date.parse(claim.expiresAt) > Date.now());
+  return { activity: mine ? "editing" : "viewing", reportId: report.id };
+}
+
+async function heartbeatPresence(): Promise<void> {
+  if (!getShellSnapshot().session) return;
+  const current = currentPresenceActivity();
+  try {
+    const response = await requestJson<PresenceResponse>("/v1/admin/presence", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ session_id: presenceSessionId, activity: current.activity, active_report_id: current.reportId }),
+    });
+    rawPresence = response.analysts || [];
+    publish();
+  } catch {
+    // Presence is advisory. Durable claims remain authoritative.
+  }
+}
+
+function sendPresenceActivity(): void {
+  if (!getShellSnapshot().session) return;
+  const current = currentPresenceActivity();
+  if (presenceSocket?.readyState === WebSocket.OPEN) {
+    presenceSocket.send(JSON.stringify(current.reportId
+      ? { type: "focus_report", report_id: current.reportId, editing: current.activity === "editing" }
+      : { type: "blur_report" }));
+  } else {
+    void heartbeatPresence();
+  }
+}
+
+function openPresenceSocket(): void {
+  const session = getShellSnapshot().session;
+  if (!session || presenceSocket) return;
+  const url = new URL("/v1/admin/presence/socket", window.location.href);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("session_id", presenceSessionId);
+  const socket = new WebSocket(url);
+  presenceSocket = socket;
+  socket.addEventListener("open", sendPresenceActivity);
+  socket.addEventListener("message", (event) => {
+    try {
+      const message = JSON.parse(String(event.data)) as { type?: string; analysts?: RawPresenceAnalyst[]; report_id?: string };
+      if (message.type === "presence_snapshot" && Array.isArray(message.analysts)) {
+        rawPresence = message.analysts;
+        publish();
+      }
+      if (message.type === "claim_changed" || message.type === "reports_changed") {
+        void loadReports();
+        const report = getReportWorkspaceSnapshot().detail.report;
+        if (report && (!message.report_id || report.id === message.report_id)) void openReport(report.id);
+      }
+    } catch {
+      // Ignore messages outside the bounded presence protocol.
+    }
+  });
+  socket.addEventListener("close", () => {
+    if (presenceSocket === socket) presenceSocket = null;
+    if (presenceRunning && getShellSnapshot().session) {
+      void heartbeatPresence();
+      if (presenceReconnectTimer) clearTimeout(presenceReconnectTimer);
+      presenceReconnectTimer = setTimeout(openPresenceSocket, 3_000);
+    }
+  });
+  socket.addEventListener("error", () => socket.close());
+}
+
+function stopPresence(): void {
+  presenceRunning = false;
+  if (presenceHeartbeatTimer) clearInterval(presenceHeartbeatTimer);
+  if (presenceReconnectTimer) clearTimeout(presenceReconnectTimer);
+  presenceHeartbeatTimer = null;
+  presenceReconnectTimer = null;
+  const socket = presenceSocket;
+  presenceSocket = null;
+  if (socket && socket.readyState < WebSocket.CLOSING) socket.close(1000, "workspace closed");
+  rawPresence = [];
+}
+
+async function startPresence(): Promise<void> {
+  stopPresence();
+  presenceSessionId = crypto.randomUUID();
+  presenceRunning = true;
+  try {
+    const response = await requestJson<PresenceResponse>("/v1/admin/presence");
+    rawPresence = response.analysts || [];
+  } catch {
+    rawPresence = [];
+  }
+  publish();
+  presenceHeartbeatTimer = setInterval(() => {
+    if (presenceSocket?.readyState === WebSocket.OPEN) {
+      const current = currentPresenceActivity();
+      presenceSocket.send(JSON.stringify({ type: "heartbeat", activity: current.activity, report_id: current.reportId }));
+    } else {
+      void heartbeatPresence();
+    }
+  }, 15_000);
+  openPresenceSocket();
+}
+
+function validFilters(value: unknown): value is ReportFilters {
+  if (!value || typeof value !== "object") return false;
+  const filters = value as Partial<ReportFilters>;
+  return typeof filters.search === "string"
+    && typeof filters.queueId === "string"
+    && ["", "high", "medium", "low"].includes(filters.priority ?? "invalid")
+    && ["", "hour", "day", "older"].includes(filters.age ?? "invalid")
+    && typeof filters.state === "string"
+    && ["oldest", "newest", "priority"].includes(filters.sort ?? "invalid");
+}
+
+export function startReportController(): void {
+  if (started) return;
+  started = true;
+  subscribeToShell(() => {
+    const session = getShellSnapshot().session;
+    const nextActorId = session?.actor.id || "";
+    if (nextActorId === actorId) {
+      publish();
+      return;
+    }
+    actorId = nextActorId;
+    detailRequestVersion += 1;
+    stopPresence();
+    rawReports = [];
+    setShellSnapshot((shell) => ({ ...shell, reportCount: 0 }));
+    document.body.classList.remove("report-open");
+    setReportWorkspaceSnapshot(initialSnapshot());
+    if (session) {
+      void loadReports();
+      void startPresence();
+    }
+  });
+  subscribeToQueueWorkspace(() => publish());
+  window.addEventListener(reportEvents.open, (event) => {
+    if (event instanceof CustomEvent && typeof event.detail?.reportId === "string") void openReport(event.detail.reportId);
+  });
+  window.addEventListener(reportEvents.close, closeReport);
+  window.addEventListener(reportEvents.refresh, () => { void loadReports(); });
+  window.addEventListener(reportEvents.filters, (event) => {
+    if (!(event instanceof CustomEvent) || !validFilters(event.detail?.filters)) return;
+    const previous = getReportWorkspaceSnapshot().filters;
+    const filters = event.detail.filters;
+    publish({ filters });
+    if (filters.queueId !== previous.queueId || filters.state !== previous.state) void loadReports();
+  });
+  window.addEventListener(reportEvents.claim, () => { void claimReport(); });
+  window.addEventListener(reportEvents.release, () => { void releaseReport(); });
+  window.addEventListener(reportEvents.message, (event) => {
+    if (!(event instanceof CustomEvent) || typeof event.detail?.body !== "string" || typeof event.detail?.awaitReporter !== "boolean") return;
+    void sendMessage(event.detail as ReporterMessageInput);
+  });
+  window.addEventListener(reportEvents.decision, (event) => {
+    if (!(event instanceof CustomEvent) || !Array.isArray(event.detail?.evidenceReferences)) return;
+    void recordDecision(event.detail as HumanDecisionInput);
+  });
+  window.addEventListener("keydown", (event) => {
+    if (event.key === "Escape" && getReportWorkspaceSnapshot().detail.reportId) closeReport();
+  });
+}

package/template/console/reports/events.ts

@@ -0,0 +1,42 @@
+import type { HumanDecisionInput, ReportFilters, ReporterMessageInput, ReportWorkspaceSnapshot } from "./types";
+
+export const reportEvents = {
+  state: "safest:reports:state",
+  refresh: "safest:reports:refresh",
+  filters: "safest:reports:filters",
+  open: "safest:reports:open",
+  close: "safest:reports:close",
+  claim: "safest:reports:claim",
+  release: "safest:reports:release",
+  message: "safest:reports:message",
+  decision: "safest:reports:decision",
+} as const;
+
+function dispatch<TDetail>(type: string, detail?: TDetail): void {
+  window.dispatchEvent(detail === undefined ? new Event(type) : new CustomEvent(type, { detail }));
+}
+
+export function dispatchReportRefresh(): void { dispatch(reportEvents.refresh); }
+export function dispatchReportFilters(filters: ReportFilters): void { dispatch(reportEvents.filters, { filters }); }
+export function dispatchOpenReport(reportId: string): void { dispatch(reportEvents.open, { reportId }); }
+export function dispatchCloseReport(): void { dispatch(reportEvents.close); }
+export function dispatchClaimReport(): void { dispatch(reportEvents.claim); }
+export function dispatchReleaseReport(): void { dispatch(reportEvents.release); }
+export function dispatchReporterMessage(input: ReporterMessageInput): void { dispatch(reportEvents.message, input); }
+export function dispatchHumanDecision(input: HumanDecisionInput): void { dispatch(reportEvents.decision, input); }
+
+export function isReportWorkspaceSnapshot(value: unknown): value is ReportWorkspaceSnapshot {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<ReportWorkspaceSnapshot>;
+  return typeof candidate.loading === "boolean"
+    && typeof candidate.refreshing === "boolean"
+    && typeof candidate.error === "string"
+    && typeof candidate.generatedAt === "string"
+    && typeof candidate.filters === "object"
+    && Array.isArray(candidate.queues)
+    && Array.isArray(candidate.reports)
+    && Array.isArray(candidate.presence)
+    && Array.isArray(candidate.actionCodes)
+    && typeof candidate.permissions === "object"
+    && typeof candidate.detail === "object";
+}

package/template/console/reports/store.ts

@@ -0,0 +1,39 @@
+import { reportEvents, isReportWorkspaceSnapshot } from "./events";
+import type { ReportWorkspaceSnapshot } from "./types";
+
+const subscribers = new Set<() => void>();
+
+let snapshot: ReportWorkspaceSnapshot = {
+  loading: true,
+  refreshing: false,
+  error: "",
+  generatedAt: new Date().toISOString(),
+  actorId: "",
+  filters: { search: "", queueId: "", priority: "", age: "", state: "", sort: "oldest" },
+  queues: [],
+  reports: [],
+  presence: [],
+  actionCodes: [],
+  permissions: { claimReports: false, messageReporters: false, decideReports: false, readRuns: false },
+  detail: { reportId: null, loading: false, error: "", pendingAction: null, messageMutationVersion: 0, report: null },
+};
+
+window.addEventListener(reportEvents.state, (event) => {
+  if (!(event instanceof CustomEvent) || !isReportWorkspaceSnapshot(event.detail)) return;
+  snapshot = event.detail;
+  for (const subscriber of subscribers) subscriber();
+});
+
+export function getReportWorkspaceSnapshot(): ReportWorkspaceSnapshot {
+  return snapshot;
+}
+
+export function setReportWorkspaceSnapshot(next: ReportWorkspaceSnapshot | ((current: ReportWorkspaceSnapshot) => ReportWorkspaceSnapshot)): void {
+  snapshot = typeof next === "function" ? next(snapshot) : next;
+  for (const subscriber of subscribers) subscriber();
+}
+
+export function subscribeToReportWorkspace(callback: () => void): () => void {
+  subscribers.add(callback);
+  return () => subscribers.delete(callback);
+}