@devaccel-labs/app-comments-toolbar 1.1.0 → 1.3.0

package/dist/types/runtime/clarity-model.d.ts

@@ -0,0 +1,260 @@
+/**
+ * The clarity check as the composer runs it (docs/adr/0002-clarity-check.md): what Send does before a new
+ * comment is posted, what the person is shown when a reader would still have to ask something, and what
+ * the comment says when it goes. Every decision is here; `./clarity-ui.tsx` draws it. DOM-free.
+ *
+ * The check is never the reason a comment is lost or late: no mode, mode `off`, a failed or slow request,
+ * or an answer this file cannot read all post the comment exactly as it would have gone without the check.
+ *
+ * The wire types and bounds mirror `packages/contract/src/clarity.ts` and `limits.ts`; the toolbar bundle
+ * does not import the contract package. `tests/clarity-model.spec.ts` holds the two in step.
+ *
+ * Native clients run the same decisions: `../native.ts` exports this file to `@devaccel-labs/app-comments-native`.
+ */
+import type { TicketDraft } from "./ticket-form-model";
+export type ClarityMode = "off" | "advise" | "require";
+export type ClarityGap = "expected" | "actual" | "steps" | "which" | "scope" | "done" | "other";
+/** Who would have to ask: the person making the change, or whoever checks it afterwards. */
+export type ClarityAudience = "developer" | "tester";
+export interface ClarityQuestion {
+    readonly id: string;
+    readonly gap: ClarityGap;
+    /** Absent on a report from before questions said who asks: read it as the developer's. */
+    readonly audience?: ClarityAudience;
+    /** The question, in one sentence. */
+    readonly ask: string;
+    /** Why a reader needs it, in a few words. */
+    readonly why: string;
+}
+export interface ClarityAnswer {
+    readonly questionId: string;
+    readonly ask: string;
+    readonly answer: string;
+}
+export interface ClarityAnswerCheck {
+    readonly questionId: string;
+    readonly status: "answered" | "partial" | "unrelated";
+    readonly note?: string;
+}
+/** The part of the service's report the composer reads. */
+export interface ClarityReport {
+    readonly verdict: "clear" | "needs_detail" | "unchecked";
+    readonly understood: string;
+    /** What the check took as given instead of asking. Absent when it took nothing, or predates the field. */
+    readonly assumed?: readonly string[];
+    readonly questions: readonly ClarityQuestion[];
+    readonly answers: readonly ClarityAnswerCheck[];
+}
+/** The body of `POST /v1/clarity`. */
+export interface ClarityDraft {
+    readonly body: string;
+    readonly url: string;
+    readonly route: string;
+    readonly target: string;
+    readonly attachmentIds: readonly string[];
+    /** As a new comment is posted with them: the role, custom field values by id, a tester's ticket answers. */
+    readonly role?: string | null;
+    readonly fields?: Readonly<Record<string, string>>;
+    readonly ticket?: TicketDraft;
+    readonly asked?: readonly ClarityQuestion[];
+    readonly answers?: readonly ClarityAnswer[];
+}
+export declare const CLARITY_MAX_QUESTIONS = 3;
+export declare const CLARITY_MAX_ASSUMED = 3;
+export declare const CLARITY_MAX_ROUNDS = 2;
+export declare const CLARITY_ANSWER_MAX_LENGTH = 2000;
+export declare const COMMENT_MESSAGE_MAX_LENGTH = 4000;
+/** How long Send waits for the check. The service gives its model eight seconds; past nine the comment goes. */
+export declare const CLARITY_WAIT_MS = 9000;
+/** Every word the check puts on screen or into a comment. About the reader, never about the writer. */
+export declare const CLARITY_WORDS: {
+    /** The panel's name, for a screen reader. */
+    readonly region: "More detail";
+    readonly understood: "What a reader takes from this:";
+    /** Over what the check took as given, and the line under it. The console's inbox uses the same words. */
+    readonly assumed: "Taken as given";
+    readonly assumedNote: "Not asked about. Shown so a wrong one can be put right.";
+    /** The lead when every question is a developer's; `whoWouldAsk` names the reader otherwise. */
+    readonly lead: "A developer would still have to ask:";
+    readonly placeholder: "Add your answer…";
+    readonly hint: "Add a little more so nobody has to guess.";
+    /** After the second look: nothing holds the comment any more. */
+    readonly free: "You can send now. Add more if it helps.";
+    /** `require`, first look, Send pressed with nothing added. */
+    readonly stay: "Answer a question or add to the comment, then send.";
+    readonly sendAsIs: "Send as is";
+    readonly working: "One moment…";
+    /** Beside a question whose answer the service said falls short without saying how. */
+    readonly more: "A reader would still need a little more here.";
+    readonly full: "The comment has no room for more.";
+    /** The line the answers sit under in the posted comment. */
+    readonly detail: "More detail:";
+    readonly question: "Q. ";
+    readonly answer: "A. ";
+};
+/**
+ * The environment's mode as `GET /v1/threads` carries it in `clarity`. Null when the field is missing or is
+ * not a mode: a service that predates the check, which is never asked.
+ */
+export declare function readClarityMode(value: unknown): ClarityMode | null;
+/** Whether a new comment is checked before it is posted. */
+export declare function clarityChecks(mode: ClarityMode | null): mode is "advise" | "require";
+/**
+ * What `POST /v1/clarity` answered, or null when it is not an answer this build can act on. Null posts the
+ * comment: an unreadable answer is the check failing, and the check fails open.
+ */
+export declare function readClarityResponse(payload: unknown): {
+    readonly mode: ClarityMode;
+    readonly report: ClarityReport;
+} | null;
+/** How one check ended: with the service's answer, or without one. */
+export type ClarityOutcome = {
+    readonly kind: "answered";
+    readonly mode: ClarityMode;
+    readonly report: ClarityReport;
+} | {
+    readonly kind: "failed";
+};
+/**
+ * Runs one check and never throws. A rejection (a 404 from a service without the route, any other status,
+ * the network), an answer that cannot be read, or no answer within `waitMs` are all `failed`. The wait is
+ * raced, not only aborted, so a request that ignores its signal still lets Send go on time.
+ */
+export declare function askClarity(run: (signal: AbortSignal) => Promise<unknown>, waitMs?: number): Promise<ClarityOutcome>;
+/** The draft at the moment Send was pressed. */
+export interface ClarityFacts {
+    readonly body: string;
+    /** The page the comment is filed against. */
+    readonly url: string;
+    readonly route: string;
+    /** What it is attached to, in words. */
+    readonly target: string;
+    /** Its uploaded files, by attachment id. */
+    readonly attachmentIds: readonly string[];
+    /**
+     * What it will be posted with besides its words (the role, custom fields and a tester's ticket answers),
+     * exactly as the post sends them, so the check does not ask what one of them already says.
+     */
+    readonly posted?: Pick<ClarityDraft, "role" | "fields" | "ticket">;
+    /**
+     * Its files by their key in the draft. A key outlives a reload (an attachment id does not: a resumed
+     * draft uploads its files again), so this is what says whether the files changed.
+     */
+    readonly fileKeys: readonly string[];
+}
+/**
+ * A draft the check is holding: a reader would still have to ask something. Kept with the draft in storage
+ * (`./draft-model.ts`), so a reload or a minimise brings the questions and the typed answers back.
+ */
+export interface ClarityHold {
+    readonly v: 1;
+    /** Looks the service has taken at this draft that left a question open. */
+    readonly round: 1 | 2;
+    /** The environment's mode when it last looked. */
+    readonly mode: "advise" | "require";
+    readonly understood: string;
+    /** What the last look took as given. Absent when it took nothing. */
+    readonly assumed?: readonly string[];
+    /** Every question asked of this draft, most important first. */
+    readonly questions: readonly ClarityQuestion[];
+    /** The ones still open, by id. */
+    readonly open: readonly string[];
+    /** What was typed under each question, by id. An answer that closed its question is still here. */
+    readonly answers: Readonly<Record<string, string>>;
+    /** What the last look said is still needed, by question id. */
+    readonly notes: Readonly<Record<string, string>>;
+    /** The draft as it was last looked at (`draftMark`). */
+    readonly checked: string;
+}
+/** The draft's own content: its words and its files. Answers are not part of it. */
+export declare function draftMark(facts: Pick<ClarityFacts, "body" | "fileKeys">): string;
+/** The draft and its answers together: what a look that let the comment through was shown. */
+export declare function passMark(facts: Pick<ClarityFacts, "body" | "fileKeys">, hold: ClarityHold | null): string;
+/** The questions still open, in the order they were asked. */
+export declare function openQuestions(hold: ClarityHold): ClarityQuestion[];
+/** `hold` with `text` typed under one of its questions. */
+export declare function withAnswer(hold: ClarityHold, questionId: string, text: string): ClarityHold;
+/**
+ * Whether the comment may be sent with questions still open. In `advise` always; in `require` only once the
+ * service has looked twice, so the first Send with open questions cannot be skipped and the second always can.
+ */
+export declare function canSendAsIs(hold: ClarityHold): boolean;
+/** "send" is the composer's own Send; "as-is" is the panel's "Send as is". */
+export type ClaritySend = "send" | "as-is";
+export type ClarityStep = 
+/** Post now. */
+{
+    readonly kind: "post";
+}
+/** Ask the service first. */
+ | {
+    readonly kind: "check";
+    readonly request: ClarityDraft;
+}
+/** `require`, first look, and nothing was added: the questions stay. */
+ | {
+    readonly kind: "stay";
+};
+/**
+ * What a press of Send does to a new comment.
+ *
+ * - No mode (a service without the check) or `off`: post, and nothing is asked.
+ * - A draft the service already let through, unchanged since: post (a failed post is retried without asking again).
+ * - Not looked at yet: ask.
+ * - Held, and skipping is allowed and was chosen, or the service has looked twice: post.
+ * - Held after the first look: answers go to be judged against their questions; with none, an edited draft is
+ *   looked at afresh; with nothing added, `advise` posts and `require` stays.
+ */
+export declare function clarityStep(input: {
+    readonly mode: ClarityMode | null;
+    readonly hold: ClarityHold | null;
+    readonly draft: ClarityFacts;
+    readonly send: ClaritySend;
+    /** `passMark` of the draft the service last let through, if it has. */
+    readonly passed?: string | null;
+}): ClarityStep;
+/**
+ * The draft's hold after a check, or null when the comment goes: the check failed, the mode is `off`, the
+ * verdict is `clear` or `unchecked`, or it left nothing to ask. A second look at answers opens nothing new:
+ * only questions that were already asked can stay open, whatever the service sends.
+ */
+export declare function clarityAfterCheck(hold: ClarityHold | null, draft: ClarityFacts, request: ClarityDraft, outcome: ClarityOutcome): ClarityHold | null;
+/**
+ * The text the comment is posted with: its own words, then every answered question under "More detail:", as
+ * plain text (the same lines the service's `detailText` writes for an inbox). With no answers it is `body`,
+ * untouched.
+ *
+ * It never passes `COMMENT_MESSAGE_MAX_LENGTH`, and the comment's own words are never cut to make room: an
+ * answer that does not fit whole is shortened and ends in "…", and one with no room left (and any after it)
+ * is left out. A comment already at the limit is posted as it is, with no answers.
+ */
+export declare function clarityBody(body: string, hold: ClarityHold | null): string;
+/**
+ * How long the answer under `questionId` may be, so that what is typed is what is posted: the smaller of the
+ * service's cap for one answer and what is left of the comment's length after its words and the other answers.
+ */
+export declare function answerRoom(body: string, hold: ClarityHold, questionId: string): number;
+/**
+ * What a screen reader is told when questions appear, change or stay. `who` is the reader the lead names
+ * (`whoWouldAsk`); the native package's panel does not pass it yet and keeps "A developer".
+ */
+export declare function clarityAnnouncement(hold: ClarityHold | null, stayed: boolean, who?: string): string;
+/** Who would ask `question`. A question from before questions said so is the developer's. */
+export declare function questionAudience(question: ClarityQuestion): ClarityAudience;
+/** The reader who would ask, as the subject of a sentence. The console's inbox uses the same words. */
+export declare function clarityReader(audience: ClarityAudience): string;
+/** `questions` by who would ask them, the developer's first, leaving out a reader who has none. */
+export declare function clarityGroups(questions: readonly ClarityQuestion[]): Array<{
+    readonly audience: ClarityAudience;
+    readonly questions: ClarityQuestion[];
+}>;
+/**
+ * Who would ask the open questions, as the subject of "… would still have to ask": the one reader when they
+ * are all one reader's, "A reader" when a developer and whoever tests the fix both have some.
+ */
+export declare function whoWouldAsk(questions: readonly ClarityQuestion[]): string;
+/**
+ * `value` as a hold, or null when it is not one this build can show. Storage holds whatever an earlier build
+ * wrote; a hold that does not read whole is dropped, and the draft it came with is resumed without it.
+ */
+export declare function readClarityHold(value: unknown): ClarityHold | null;

package/dist/types/runtime/clarity-ui.d.ts

@@ -0,0 +1,62 @@
+import { type KeyboardEvent as ReactKeyboardEvent } from "react";
+import { type ClarityFacts, type ClarityHold, type ClarityMode, type ClaritySend } from "./clarity-model.js";
+import type { DictationDeps } from "./dictation-engine.js";
+import type { Session } from "./session.js";
+/** What Send does next: post this text, or wait (the questions are on screen). */
+export type ClaritySent = {
+    readonly post: true;
+    readonly body: string;
+} | {
+    readonly post: false;
+};
+export type ClarityControl = ReturnType<typeof useClarity>;
+/**
+ * The clarity check for one composer (`./clarity-model.ts` decides; this holds the state). `send` is what the
+ * composer's submit asks before it posts a new comment. It always resolves, within the model's wait, and
+ * never rejects: when the check can't answer, the comment is posted as it would have been without it.
+ */
+export declare function useClarity(session: Session | null, member: string | null, mode: ClarityMode | null): {
+    hold: ClarityHold | null;
+    /** The service is being asked: Send shows it is working. */
+    checking: boolean;
+    stayed: boolean;
+    arrived: number;
+    /** An answer is still being dictated: sending now would lose words. */
+    dictating: boolean;
+    send: (facts: ClarityFacts, how: ClaritySend) => Promise<ClaritySent>;
+    takeSend: () => ClaritySend;
+    chooseAsIs: () => void;
+    answer: (questionId: string, text: string) => void;
+    noteDictating: (questionId: string, on: boolean) => void;
+    reset: () => void;
+    restore: (found: ClarityHold | null) => void;
+};
+type AnswerKeys = (event: ReactKeyboardEvent<HTMLTextAreaElement>) => void;
+type Voice = {
+    readonly transcribe: DictationDeps["transcribe"];
+    /** People who may be named, so they are spelled right. */
+    readonly names: readonly string[];
+    readonly onNote: (note: string) => void;
+    /** Dictation can't start now (a post or a screen recording is running). */
+    readonly off: boolean;
+};
+/**
+ * What the composer shows under the comment while the check holds it: what a reader takes from the comment,
+ * what the check took as given, each open question with why a reader needs it and its own answer box, grouped
+ * by who would ask when a developer and whoever tests the fix both would, and "Send as is" when skipping is
+ * allowed. Focus goes to the first question when they arrive, and a polite live region says they are there.
+ *
+ * Renders nothing at all where the service has no check, so nothing about those composers changes.
+ */
+export declare function ClarityQuestions({ clarity, mode, body, busy, voice, onKeyDown, }: {
+    clarity: ClarityControl;
+    mode: ClarityMode | null;
+    /** The comment's text as it stands, for how much room each answer has. */
+    body: string;
+    /** A post or a check is running. */
+    busy: boolean;
+    voice: Voice;
+    /** The comment box's own key rules (Cmd+Enter sends), so the answer boxes follow them. */
+    onKeyDown: AnswerKeys;
+}): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/runtime/client.d.ts

@@ -1,141 +1,15 @@
-import type { Anchor } from "../core/index.js";
+/**
+ * The comment service client for the web toolbar: the DOM-free API (`./api.ts`) plus what only a browser page
+ * has — `localStorage` member tokens, and the sign-in window's relay back to this page.
+ */
+import { type MsfHandoff } from "./api.js";
 import { type Session } from "./session.js";
-export type Mentioned = {
-    id: string;
-    name: string;
-};
-/** Where a page screenshot was taken. */
-export type Capture = {
-    url: string;
-    viewport?: {
-        width: number;
-        height: number;
-    };
-    browser?: string;
-};
-export type Attachment = {
-    id: string;
-    name: string;
-    contentType: string;
-    size: number;
-    url: string;
-    capture?: Capture;
-};
-/** An earlier version of a message. `createdAt` is when that version was written. */
-export type Revision = {
-    body: string;
-    mentions?: Mentioned[];
-    createdAt: string;
-};
-export type CommentMessage = {
-    id: string;
-    body: string;
-    author: string;
-    /** Missing on messages written before author ids were stored. */
-    authorId?: string | null;
-    createdAt: string;
-    editedAt?: string | null;
-    mentions?: Mentioned[];
-    attachments?: Attachment[];
-    /** Earlier versions, oldest first. The current body is the version after the last one. */
-    revisions?: Revision[];
-};
-export type Member = {
-    id: string;
-    name: string;
-    email: string;
-};
-export type Delivery = {
-    emailed: Mentioned[];
-    skipped: Array<Mentioned & {
-        reason: "rate_limited" | "muted" | "disabled" | string;
-    }>;
-};
-export type Profile = {
-    name: string;
-    email: string | null;
-    mentionEmails: boolean;
-};
-export type PostExtras = {
-    mentions?: string[];
-    screenshot?: string | null;
-    attachments?: string[];
-};
-export type FieldDef = {
-    id: string;
-    label: string;
-};
-export type FieldValue = FieldDef & {
-    value: string;
-};
-export type Settings = {
-    roles: {
-        enabled: boolean;
-        options: string[];
-    };
-    fields: {
-        enabled: boolean;
-        items: FieldDef[];
-    };
-};
-/** Role and custom field values for a new or edited comment, keyed by field id. */
-export type Details = {
-    role: string | null;
-    fields: Record<string, string>;
-};
-export type Thread = {
-    id: string;
-    /** The environment the comment was left in. Differs from the session's for comments from a linked environment. */
-    environment?: string;
-    route: string;
-    /** The page the comment was left on, including query and hash. */
-    url: string;
-    role: string | null;
-    fields: FieldValue[];
-    anchor: Anchor;
-    status: "open" | "resolved";
-    createdBy: string;
-    createdAt: string;
-    updatedAt: string;
-    messages: CommentMessage[];
-    /** Set when the team turned this comment into a support ticket in MyStatusFlow. */
-    ticket?: TicketBadge;
-};
-/** A comment's support ticket, as the commenter sees it: number and status only. */
-export type TicketBadge = {
-    number: string;
-    status: string;
-    label: string;
-};
-export declare class ApiError extends Error {
-    readonly status: number;
-    readonly code: string;
-    constructor(status: number, code: string, message: string);
-}
-export declare function storageKey(session: Pick<Session, "apiUrl" | "project" | "environment">): string;
-/** The team passphrase, kept on this device after unlocking with it so it can be shared from the dashboard. */
-export declare function passphraseKey(session: Pick<Session, "apiUrl" | "project" | "environment">): string;
+export * from "./api.js";
 /**
  * When the comment service moves to a new URL, the saved sign-in is under the old URL's key. Copy the newest current
  * one for this project and environment to the new key, and leave the old key in place so going back also works.
  */
 export declare function adoptStoredMember(session: Pick<Session, "apiUrl" | "project" | "environment">, storage?: Storage): void;
-export declare function memberIsCurrent(token: string): boolean;
-/** Sign in with the team passphrase, or with an invite link token instead. */
-export declare function unlock(session: Session, displayName: string, email: string, secret: {
-    passphrase: string;
-} | {
-    invite: string;
-}): Promise<string>;
-/** How people can sign in here. Services that predate MyStatusFlow sign-in answer 404: passphrase only. */
-export type SignInOptions = {
-    passphrase: boolean;
-    msf: {
-        authorizeUrl: string;
-        label: string;
-    } | null;
-};
-export declare function signInOptions(session: Session): Promise<SignInOptions>;
 /**
  * An OAuth 2.0 authorization request with PKCE (S256). The verifier never leaves this page. The sign-in window
  * comes back to `returnTo` (this page, on this origin) with the code, so a code only ever reaches the app it
@@ -146,19 +20,6 @@ export declare function msfAuthorization(authorizeUrl: string, returnTo: string)
     state: string;
     verifier: string;
 }>;
-/** Trades the authorization code for a member token. */
-export declare function finishMsfSignIn(session: Session, input: {
-    state: string;
-    verifier: string;
-    code: string;
-}): Promise<string>;
-/** What the sign-in window hands back to the app (a code, or an error such as access_denied). */
-export type MsfHandoff = {
-    state: string;
-    code?: string;
-    error?: string;
-    at: number;
-};
 /**
  * The sign-in window ends on this app's page with the result in the address hash (when it couldn't message the
  * page that opened it). Pass it to that page through same-origin storage and a broadcast, and clean the address.
@@ -166,55 +27,3 @@ export type MsfHandoff = {
 export declare function relayMsfHandoff(): boolean;
 /** Calls `onHandoff` when a sign-in window hands a result back, by message, broadcast or storage. */
 export declare function listenForMsfHandoff(apiOrigin: string, onHandoff: (handoff: MsfHandoff) => void): () => void;
-export declare function createInvite(session: Session, memberToken: string): Promise<{
-    invite: string;
-    invitedBy: string;
-    expiresAt: string;
-}>;
-export declare function getProfile(session: Session, memberToken: string): Promise<Profile>;
-export declare function updateProfile(session: Session, memberToken: string, patch: {
-    displayName?: string;
-    email?: string;
-    mentionEmails?: boolean;
-}): Promise<Profile & {
-    token: string;
-}>;
-export declare function uploadAttachment(session: Session, memberToken: string, file: Blob, name: string, environment?: string, capture?: Capture): Promise<Attachment>;
-export declare function listMembers(session: Session, memberToken: string, environment?: string): Promise<Member[]>;
-/** "view": this person may read but not comment. Older services don't send it, which means "edit". */
-export type Access = "edit" | "view";
-export declare function listThreads(session: Session, memberToken: string): Promise<{
-    threads: Thread[];
-    settings: Settings;
-    environment?: string | null;
-    linked?: string[];
-    access?: Access;
-}>;
-/** A socket that says "changed" whenever comments change in this environment or one it links to. */
-export declare function openLive(session: Session, memberToken: string): WebSocket;
-export declare function saveSettings(session: Session, memberToken: string, settings: Settings): Promise<Settings>;
-export declare function createThread(session: Session, memberToken: string, anchor: Anchor, body: string, extras?: PostExtras & Partial<Details> & {
-    url?: string;
-}): Promise<{
-    thread: Thread;
-    delivery?: Delivery;
-}>;
-export declare function replyToThread(session: Session, memberToken: string, threadId: string, body: string, extras?: PostExtras): Promise<{
-    message: CommentMessage;
-    delivery?: Delivery;
-}>;
-export declare function updateThread(session: Session, memberToken: string, threadId: string, patch: {
-    status?: "open" | "resolved";
-    anchor?: Anchor;
-    url?: string;
-} & Partial<Details>): Promise<{
-    id: string;
-}>;
-export declare function editMessage(session: Session, memberToken: string, threadId: string, messageId: string, body: string, mentions: string[]): Promise<{
-    message: {
-        id: string;
-        body: string;
-        editedAt: string | null;
-    };
-    delivery: Delivery | null;
-}>;

package/dist/types/runtime/composer-size.d.ts

@@ -0,0 +1,30 @@
+/** The composer's size the person dragged it to. Kept in the toolbar prefs, so every new comment opens at it. */
+export type ComposerSize = {
+    width: number;
+    height: number;
+};
+/** The composer's own width; it never gets narrower than it is by default. */
+export declare const COMPOSER_MIN_WIDTH = 240;
+export declare const COMPOSER_MIN_HEIGHT = 100;
+export declare const COMPOSER_MAX_WIDTH = 720;
+export declare function clampComposerSize(size: ComposerSize, room: {
+    width: number;
+    height: number;
+}): ComposerSize;
+/** A saved size, or nothing when the stored value is missing or malformed. */
+export declare function readComposerSize(value: unknown): ComposerSize | undefined;
+/**
+ * The composer's resize handle, in its bottom-right corner. Dragging right widens it and dragging down makes it
+ * taller (the top stays put); arrow keys do the same in steps; a double-click goes back to the default.
+ */
+export declare function ResizeGrip(props: {
+    room: () => {
+        width: number;
+        height: number;
+    };
+    /** Every step of a drag. */
+    onResize: (size: ComposerSize) => void;
+    /** The drag ended (or a key was pressed) at `size`: save it. Not called for a press that didn't move. */
+    onEnd: (size: ComposerSize) => void;
+    onReset: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/runtime/dashboard.d.ts

@@ -1,14 +1,24 @@
 import { type ReactNode } from "react";
 import type { Member, Thread } from "./client.js";
 import { type PlacedStatus } from "./format.js";
+import type { Here } from "./screen.js";
 import type { Session } from "./session.js";
 type TableRow = {
     thread: Thread;
     status: PlacedStatus;
 };
-export declare function Dashboard({ rows, route, environment, memberName, memberId, roles, members, session, memberToken, envFilter, profile, settingsPane, onClose, onOpen, onRefresh, readOnly, }: {
+/** The dashboard's sections. "inbox" is the Comments section. */
+export type DashboardScreen = "insights" | "inbox" | "profile" | "settings";
+type Screen = DashboardScreen;
+/** Asks an open or opening dashboard to show this thread in Comments. A new `at` asks again. */
+export type DashboardFocus = {
+    threadId: string;
+    at: number;
+};
+export declare function Dashboard({ rows, here, environment, memberName, memberId, roles, members, session, memberToken, envFilter, profile, settingsPane, onClose, onOpen, onReattach, onRefresh, screen, onScreen, focus, readOnly, }: {
     rows: TableRow[];
-    route: string;
+    /** The screen the page is on: "This page" is its threads. */
+    here: Here;
     environment: string;
     memberName: string;
     memberId?: string;
@@ -21,7 +31,12 @@ export declare function Dashboard({ rows, route, environment, memberName, member
     settingsPane: ReactNode;
     onClose: () => void;
     onOpen: (row: TableRow) => void;
+    /** Re-pins a comment from this page that lost its element. */
+    onReattach?: (row: TableRow) => void;
     onRefresh: () => Promise<unknown> | unknown;
+    screen: Screen;
+    onScreen: (screen: Screen) => void;
+    focus?: DashboardFocus | null;
     /** View-only access: no replies and no status changes. */
     readOnly?: boolean;
 }): import("react/jsx-runtime").JSX.Element;