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

package/dist/types/runtime/dictation-engine.d.ts

@@ -0,0 +1,98 @@
+import { type Piece } from "./dictation.js";
+export { voiceRecordingName } from "./dictation-model.js";
+/** A take stops itself after this long. */
+export declare const MAX_TAKE_MS: number;
+export type DictationPhase = "idle" | "starting" | "listening";
+export type DictationState = {
+    phase: DictationPhase;
+    /** Pieces cut and not yet written, including the one being transcribed. */
+    queued: number;
+    /** The first piece that couldn't be transcribed; everything after it waits. */
+    stalled: string | null;
+    /**
+     * Rough words for what was said and isn't written yet (needs `DictationDeps.preview`). Each piece's
+     * part is replaced by its final text when that is written.
+     */
+    preview: string;
+};
+export declare const idleDictation: DictationState;
+export type DictationDeps = {
+    transcribe(wav: Blob, prompt: string, signal: AbortSignal): Promise<string>;
+    /** The context sent with the next piece; read when it is sent, so it includes earlier pieces. */
+    prompt(): string;
+    write(text: string): void;
+    onState(state: DictationState): void;
+    /** Why a take stopped or never started, for the person to read. */
+    note(text: string): void;
+    /** Optional: a quick read of the piece still being spoken, shown as it grows. Failures are ignored. */
+    preview?(wav: Blob, prompt: string, signal: AbortSignal): Promise<string>;
+    /**
+     * Optional: the take as a voice recording, once it ends. Only composers that can attach files give this;
+     * the mic is then recorded alongside the transcription. Not called for a cancelled take.
+     */
+    audio?(file: File): void;
+    /** Whether to hand over the recording, read when the take ends so it can change mid-take. Default: yes. */
+    keepAudio?(): boolean;
+    /**
+     * Optional: a piece's final words with when they were spoken (`Date.now()` at the start of the piece, so a
+     * clip recording meanwhile can place them on its clock). Called right after `write`.
+     */
+    said?(text: string, spokenAt: number): void;
+};
+/** Whether this browser can keep a dictation take as a voice recording. */
+export declare function voiceRecordingSupported(): boolean;
+export declare function dictationSupported(): boolean;
+export declare class Dictation {
+    private state;
+    private capture;
+    private segmenter;
+    private queue;
+    private sending;
+    private stalled;
+    private abort;
+    /** Bumped by `cancel` and by every start, so an awaited step from an older take does nothing. */
+    private take;
+    private previewTimer;
+    private previewing;
+    /** Bumped when a piece is cut, so a preview of the old piece that lands late is dropped. */
+    private previewPiece;
+    private previewedSamples;
+    private live;
+    private readonly onOnline;
+    /** Nothing is wired until `connect`: a take started before then writes nowhere. */
+    private deps;
+    constructor(deps?: DictationDeps);
+    /** Points the take at the latest callbacks; the React hook calls this after every render. */
+    connect(deps: DictationDeps): void;
+    get current(): DictationState;
+    /** Live loudness (0–1), elapsed time and whether the mic seems dead, read by the meter every frame. */
+    meter(): {
+        level: number;
+        elapsedMs: number;
+        silentMic: boolean;
+    };
+    /**
+     * Must be called from the click or key press, so the browser lets the audio start. `recordVoice: false`
+     * skips the voice recording for this take (dictating over a screen recording, which has its own sound).
+     */
+    start({ recordVoice }?: {
+        recordVoice?: boolean;
+    }): Promise<void>;
+    /** Stops the mic. What was said is still sent and written, and the recording handed over. */
+    stop(note?: string | null): void;
+    private endTake;
+    /** Stops everything and drops what wasn't written yet: the box it was writing into is gone. */
+    cancel(): void;
+    /** Tries the held piece again. */
+    retry(): void;
+    /** Drops the held piece and carries on with the rest. */
+    skip(): void;
+    /** Queues a cut piece for transcription. The mic tap calls this; so can a test, without a mic. */
+    enqueue(piece: Piece): void;
+    private drain;
+    private send;
+    private previewText;
+    /** Re-reads the piece still being spoken. Best-effort: a failed or late preview is dropped. */
+    private refreshPreview;
+    private set;
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Dictation's DOM-free parts that native dictation (m4a takes) shares with the web toolbar: the input meter,
+ * placing dictated words into the writing box, the context that helps the transcriber, and voice note names.
+ * Re-exported from `./dictation.ts` and `./dictation-engine.ts`.
+ */
+/**
+ * Where the dictation point moved to after someone edited the text it lives in. An edit wholly before it
+ * shifts it; an edit after it leaves it; an edit across it puts it at the end of the edit.
+ */
+export declare function rebaseAnchor(previous: string, next: string, anchor: number): number;
+/**
+ * `text` written into `value` at `at`, spaced like typing: a space before it unless it starts a line, a
+ * space after it unless punctuation follows, and a capital when it starts a sentence.
+ */
+export declare function insertDictated(value: string, at: number, text: string): {
+    value: string;
+    caret: number;
+};
+/**
+ * Context for Whisper: the people who might be named, then the writing just before the dictation point.
+ * Both help it spell names and keep punctuation consistent across pieces.
+ */
+export declare function dictationPrompt(before: string, names: readonly string[]): string;
+export declare function decibels(samples: Float32Array): number;
+/** 0–1 for a meter: −60 dBFS and below is empty, −12 is full. */
+export declare function meterLevel(db: number): number;
+/** `voice-2026-10-31-13-56-37.webm`, after the screen recordings' `recording-…` names. */
+export declare function voiceRecordingName(at: Date, type: string): string;

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

@@ -0,0 +1,56 @@
+import { type KeyboardEvent as ReactKeyboardEvent } from "react";
+import { Dictation, type DictationDeps, type DictationState } from "./dictation-engine.js";
+type Options = {
+    transcribe: DictationDeps["transcribe"];
+    /** The writing box's text, and how to change it. Dictated words go through the same path as typing. */
+    value: string;
+    onChange: (next: string) => void;
+    /** People who may be named: Whisper spells them right when it knows them. */
+    names: readonly string[];
+    onNote: (note: string) => void;
+    /** The take as a voice file, attached to the box's message. Without it nothing is recorded. */
+    onAudio?: (file: File) => void;
+    /** "Keep voice": whether the recording is attached when the take ends. */
+    keepVoice?: boolean;
+    onKeepVoice?: (keep: boolean) => void;
+    /** Each piece's final words with when they were spoken, for a clip recording meanwhile. */
+    onSaid?: (text: string, spokenAt: number) => void;
+};
+export type DictationControl = ReturnType<typeof useDictation>;
+/**
+ * Dictation into one writing box. Words land where the caret was when dictation started and keep landing
+ * after each other there, even while the person types elsewhere in the box (the point moves with their
+ * edits). The take is cancelled when the box's owner unmounts.
+ */
+export declare function useDictation(options: Options): {
+    engine: Dictation;
+    state: DictationState;
+    start: (box: HTMLTextAreaElement | null, recordVoice?: boolean) => void;
+    toggle: (box: HTMLTextAreaElement | null, recordVoice?: boolean) => void;
+    stop: () => void;
+    cancel: () => void;
+    /** The mic is open or being opened. */
+    listening: boolean;
+    /** Anything still to write: posting now would lose words. */
+    busy: boolean;
+    /** The pill replaces the attach buttons. */
+    shown: boolean;
+    /** The take is recorded too; the pill offers "Keep voice". */
+    recordsVoice: boolean;
+    keepVoice: boolean;
+    setKeepVoice: (keep: boolean) => void | undefined;
+};
+/** ⌘⇧Space / Ctrl+Shift+Space in a writing box starts or stops dictation. */
+export declare function isDictationKey(event: ReactKeyboardEvent<HTMLTextAreaElement>): boolean;
+/**
+ * The mic button, and while dictating the pill that replaces it: stop, live level, time, and what is
+ * happening (listening, writing, or a piece that needs a retry). `field` is the `data-cs-ui` of the box
+ * in the same form that the words go into.
+ */
+export declare function DictateButton({ dictation, field, disabled, compact, }: {
+    dictation: DictationControl;
+    field: string;
+    disabled: boolean;
+    compact?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,66 @@
+/**
+ * Dictation's pure parts (ADR-APPC-010): resample the microphone to 16 kHz, cut the take into pieces at
+ * pauses, write each piece as WAV, and place the words that come back into the writing box. No browser
+ * audio APIs here, so all of it runs under unit tests. `dictation-engine.ts` drives it from a live mic.
+ */
+export declare const SAMPLE_RATE = 16000;
+/** Whisper reads 30 s windows; a piece is cut before that even when nobody pauses. */
+export declare const MAX_PIECE_SECONDS = 28;
+export type Piece = {
+    samples: Float32Array;
+    seconds: number;
+    speechSeconds: number;
+};
+/**
+ * Streaming sample-rate conversion. Downsampling averages every input sample an output sample covers (a
+ * box filter, enough low-pass for speech); upsampling interpolates. State carries across chunks, so the
+ * output is the same however the input is split.
+ */
+export declare class Resampler {
+    readonly from: number;
+    readonly to: number;
+    private readonly step;
+    private rest;
+    private offset;
+    constructor(from: number, to?: number);
+    push(input: Float32Array): Float32Array;
+}
+/**
+ * Cuts 16 kHz audio into pieces at pauses. Speech is a frame louder than the room: a noise floor that falls
+ * fast and rises slowly, plus a margin, never quieter than −55 dBFS. A piece ends after `END_PAUSE` of quiet,
+ * or is cut at `MAX_PIECE_SECONDS`; pieces with almost no speech are dropped, so silence never reaches
+ * Whisper (which turns silence into "Thank you.").
+ */
+export declare class Segmenter {
+    /** Loudness of the newest frame. */
+    lastDb: number;
+    /** Loudest frame so far: −100 means the mic delivered digital silence. */
+    peakDb: number;
+    private floor;
+    private partial;
+    private filled;
+    private preroll;
+    private active;
+    push(samples: Float32Array): Piece[];
+    /** The audio of the piece still being spoken (not yet cut), for a live preview; null between pieces. */
+    pending(): Float32Array | null;
+    /** The piece in progress, when the take ends. */
+    flush(): Piece | null;
+    private frame;
+    private piece;
+}
+/**
+ * 16-bit mono PCM WAV. Quiet takes are raised (up to 8x, to a 0.9 peak) so a far-away mic still reads
+ * clearly; loud ones are left alone.
+ */
+export declare function encodeWav(samples: Float32Array, rate?: number): ArrayBuffer;
+export { decibels, dictationPrompt, insertDictated, meterLevel, rebaseAnchor, voiceRecordingName, } from "./dictation-model.js";
+/**
+ * What to tell someone when the browser won't give us the microphone. A refusal can come from the site
+ * setting, from the operating system, or from a browser that never shows a prompt at all (an app's built-in
+ * browser, or Chrome after the prompt was dismissed a few times); `permission` (from the Permissions API, when
+ * the browser has it) and the error's text tell those apart, because each needs a different fix.
+ */
+export declare function microphoneError(error: unknown, permission?: PermissionState | null, userAgent?: string, 
+/** The page's Permissions-Policy verdict for `microphone`, when the browser exposes it. */
+pageAllows?: boolean | null): "Couldn’t start the microphone." | "Microphone access is blocked for this site. Click the icon left of the address, set Microphone to Allow, then reload." | "No microphone found. Plug one in and try again." | "The microphone is in use by another app, or your system blocked it." | "This app’s built-in browser doesn’t allow the microphone. Open the page in Chrome, Safari or Edge to dictate." | "This browser didn’t let the page ask for the microphone. Allow it for this site from the address bar, or open the page in Chrome, Safari or Edge if you’re in an app’s built-in browser." | "This page’s Permissions-Policy turns the microphone off, so the browser can’t ask for it." | "Your computer blocks this browser from the microphone. Allow it in System Settings → Privacy & Security → Microphone, then try again.";

package/dist/types/runtime/draft-dock.d.ts

@@ -0,0 +1,32 @@
+export type DraftDockMode = "collecting" | "resume";
+/**
+ * Which dock stands in for the bar, if any. An open page draft shows only while it is minimised to collect
+ * captures; with no page draft open, a draft found in storage offers to resume.
+ */
+export declare function draftDockMode(state: {
+    readonly signedIn: boolean;
+    readonly pageDraft: boolean;
+    readonly collecting: boolean;
+    readonly stored: boolean;
+}): DraftDockMode | null;
+/**
+ * The draft, minimised over the live app: a chip in the bar's place (the bar hides) that says what it holds and
+ * takes more captures.
+ * In `resume` mode it offers a draft found in storage after a reload (or from another visit) instead.
+ */
+export declare function DraftDock({ title, pictures, clips, savedAt, mode, note, recording, confirmDiscard, onCapture, onRecord, onOpen, onDiscard, }: {
+    title: string;
+    pictures: number;
+    clips: number;
+    savedAt: number | null;
+    mode: DraftDockMode;
+    /** Something the person should know about this draft (a recording cut short by a reload). */
+    note?: string | undefined;
+    recording: boolean;
+    /** The first Discard press asks; this is true until the second one, or until it times out. */
+    confirmDiscard: boolean;
+    onCapture: () => void;
+    onRecord: () => void;
+    onOpen: () => void;
+    onDiscard: () => void;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,104 @@
+/**
+ * The draft model and store, without a storage engine: the web toolbar keeps drafts in IndexedDB
+ * (`./draft-store.ts`), native clients in files. DOM-free.
+ */
+import type { Anchor } from "../core/index.js";
+import type { Capture, Details } from "./api.js";
+import { type ClarityHold } from "./clarity-model.js";
+import { type ReportKind } from "./kind-model.js";
+import type { MarkupShape } from "./markup-model.js";
+import type { ReplayEvent } from "./replay-model.js";
+import type { TicketValues } from "./ticket-form-model.js";
+/**
+ * A draft that follows the person around the app until it is sent: everything in it is written here as it
+ * changes, so a reload, a crash, a closed laptop or another tab can offer to pick it up. Pictures and clips are
+ * kept as blobs; the browser's own storage (IndexedDB) holds them, and nothing leaves the device from here.
+ */
+export type StoredCapture = {
+    key: string;
+    name: string;
+    type: string;
+    blob: Blob;
+    capture?: Capture | undefined;
+    /** The unmarked original and the shapes flattened into `blob`, when the picture was marked up. */
+    markup?: {
+        blob: Blob;
+        name: string;
+        shapes: MarkupShape[];
+    } | undefined;
+    /** Shapes drawn since the last flatten (or ever), so a reload loses no stroke. */
+    shapes: MarkupShape[];
+};
+export type StoredDraft = {
+    v: 1;
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    /** The page the draft was started on; the comment is filed against it. */
+    href: string;
+    route: string;
+    anchor: Anchor;
+    body: string;
+    details: Details;
+    /** The kind the person chose, when they did. */
+    kind?: ReportKind;
+    ticket: TicketValues;
+    captures: StoredCapture[];
+    /** The capture open on the stage. */
+    selected: string | null;
+    /** Something the person should know when they pick the draft up (a recording cut short by a reload). */
+    note?: string;
+    /** The clarity check's open questions and the answers typed so far, when Send was held for them. */
+    clarity?: ClarityHold;
+};
+/**
+ * A recording while it runs: every chunk so far and what happened on the page, written as they land, so a
+ * reload or a crash mid-take keeps the part that was filmed.
+ */
+export type StoredRecording = {
+    v: 1;
+    draftId: string;
+    mime: string;
+    startedAt: number;
+    url: string;
+    chunks: Blob[];
+    events: ReplayEvent[];
+};
+/** Where drafts are kept: the browser's IndexedDB on the web, files on native, a map in tests. */
+export type DraftBackend = {
+    get(key: string): Promise<unknown>;
+    put(key: string, value: unknown): Promise<void>;
+    remove(key: string): Promise<void>;
+};
+/** Matches the composer's file cap so a recovered clip is not the row a resume drops. */
+export declare const MAX_DRAFT_CAPTURES = 5;
+export declare const MAX_DRAFT_BYTES: number;
+export declare function memoryBackend(): DraftBackend;
+export declare function readStoredDraft(value: unknown): StoredDraft | null;
+/** What the dock and the resume offer say about a draft. */
+export declare function describeDraft(draft: {
+    body: string;
+    captures: Array<{
+        type: string;
+    }>;
+}): {
+    pictures: number;
+    clips: number;
+    title: string;
+};
+export type DraftStore = {
+    /** False when the browser has no IndexedDB, so a reload will not see this write. */
+    readonly durable: boolean;
+    load(): Promise<StoredDraft | null>;
+    save(draft: StoredDraft): Promise<void>;
+    clear(): Promise<void>;
+    loadRecording(): Promise<StoredRecording | null>;
+    saveRecording(recording: StoredRecording): Promise<void>;
+    clearRecording(): Promise<void>;
+};
+/**
+ * One draft per `scope` (API, environment, project, and member). Saves are serialised so a fast burst can't
+ * land out of order. A draft or recording over the byte cap throws; other save failures reject too, and the
+ * toolbar tries again on the next change.
+ */
+export declare function createDraftStore(scope: string, backend: DraftBackend | null): DraftStore;

package/dist/types/runtime/draft-store.d.ts

@@ -0,0 +1,15 @@
+import { type DraftBackend, type DraftStore, type StoredDraft, type StoredRecording } from "./draft-model.js";
+export { MAX_DRAFT_BYTES, MAX_DRAFT_CAPTURES, describeDraft, memoryBackend, readStoredDraft, } from "./draft-model.js";
+export type { DraftBackend, DraftStore, StoredCapture, StoredDraft, StoredRecording, } from "./draft-model.js";
+/** IndexedDB, or null where the browser has none (or refuses it, as in some private windows). */
+export declare function idbBackend(factory?: IDBFactory | undefined): DraftBackend | null;
+/**
+ * `draft` with a recording that was cut off (by a reload, a crash) put in as a clip, with its replay beside it,
+ * and a note saying so. Nothing changes when the recording belongs to another draft.
+ */
+export declare function recoverRecording(draft: StoredDraft, recording: StoredRecording): StoredDraft;
+/**
+ * One draft per `scope` (API, environment, project, and member), in this browser's IndexedDB, or in memory
+ * where there is none.
+ */
+export declare function createDraftStore(scope: string, backend?: DraftBackend | null): DraftStore;

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

@@ -1,5 +1,5 @@
 import type { CommentMessage, Member } from "./client.js";
-export declare function isMine(message: CommentMessage, memberId: string | undefined, memberName: string): boolean;
+export { isMine } from "./thread-model.js";
 export declare function MessageTools({ message, mine, historyOpen, onHistory, onEdit, }: {
     message: CommentMessage;
     mine: boolean;

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

@@ -0,0 +1,16 @@
+/**
+ * The toolbar's typeface. It draws inside other people's pages, on every system, so it brings its own font
+ * instead of taking whichever one the system has: Inter's Latin cut, served beside the runtime
+ * (`scripts/build-toolbar.mjs` copies it there). Until it has loaded, the system's interface font stands in
+ * (`styles.ts`).
+ *
+ * The bytes are fetched like every other request to the service and handed to the page's fonts, rather than
+ * named in an `@font-face` rule: a page's Content-Security-Policy already lets the toolbar reach the service
+ * (`connect-src`), and a font built from bytes needs no `font-src` for it (`docs/integration`'s policy has none).
+ */
+export declare const FONT_FILE = "fonts/inter-latin-wght-normal.woff2";
+export declare const FONT_FAMILY = "Comment Toolbar Inter";
+/** Where the service at `apiUrl` serves the font; null when that is not an address. */
+export declare function fontUrl(apiUrl: string): string | null;
+/** Adds the toolbar's font to the page once; a build that replaced this one finds it already there. */
+export declare function loadFont(apiUrl: string): void;

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

@@ -1,11 +1,40 @@
 import type { Anchor } from "../core/index.js";
-import type { Delivery } from "./client.js";
+import type { Delivery } from "./api.js";
 export declare function initials(name: string): string;
 export declare function colorFor(name: string): string;
 export declare function ago(iso: string): string;
 export declare function targetName(anchor: Anchor): string;
 /** "pending": on this page, but not looked up yet. */
 export type PlacedStatus = "pinned" | "drifted" | "hidden" | "ambiguous" | "unavailable" | "resolved" | "pending";
+/** Where the open pin card sits. A resolved thread leaves the screen. An open pin uses its
+ * current spot, and one that only lost its box for a moment keeps the last spot. */
+export declare function openPinCardSpot(thread: {
+    id: string;
+    status: "open" | "resolved";
+} | undefined, live: {
+    id: string;
+    x: number;
+    y: number;
+} | null, held: {
+    id: string;
+    x: number;
+    y: number;
+} | null): {
+    id: string;
+    x: number;
+    y: number;
+} | null;
+/**
+ * Keep a status the actor just set when a colder thread list still has the previous one.
+ * A list that already shows the painted status drops that pending entry.
+ */
+export declare function paintThreadStatuses<T extends {
+    id: string;
+    status: "open" | "resolved";
+}>(threads: readonly T[], pending: ReadonlyMap<string, "open" | "resolved">): {
+    threads: T[];
+    pending: Map<string, "open" | "resolved">;
+};
 /** Plain-language reason a thread isn't pinned, or null when there's nothing to explain. */
 export declare function statusNote(status: PlacedStatus, anchor: Anchor): {
     text: string;

package/dist/types/runtime/host-watch.d.ts

@@ -0,0 +1,20 @@
+/**
+ * When to ask the host app's session route again, so the toolbar follows a sign-in or a sign-out that did not
+ * load a page. The route is only asked when something a person does could have changed who is signed in: the
+ * page comes back into view or gets the focus, the app navigates (its router, the back button, a hash route),
+ * or the browser restores the page from its back-forward cache. Never on a timer, and never more often than
+ * once per `HOST_CHECK_GAP_MS`: a moment inside the gap is answered at its end.
+ */
+/** The shortest time between two questions to the host's session route. */
+export declare const HOST_CHECK_GAP_MS = 10000;
+/** Dispatched on `window` after the app calls `history.pushState` or `history.replaceState`. */
+export declare const NAVIGATED = "cs-nav";
+/** Makes the app's own `pushState` and `replaceState` dispatch `NAVIGATED`. Once per page, whoever asks. */
+export declare function announceNavigation(): void;
+export type HostWatch = {
+    /** Asks now, whatever the gap: the host said its sign-in changed. */
+    now(): void;
+    stop(): void;
+};
+/** Calls `check` at the moments above. The first one is a gap after this call: the caller has just asked. */
+export declare function watchHost(check: () => void, gap?: number): HostWatch;

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

@@ -11,11 +11,17 @@ export declare const Check: () => import("react/jsx-runtime").JSX.Element;
 export declare const Target: () => import("react/jsx-runtime").JSX.Element;
 export declare const Relink: () => import("react/jsx-runtime").JSX.Element;
 export declare const Undo: () => import("react/jsx-runtime").JSX.Element;
-export declare const Pencil: () => import("react/jsx-runtime").JSX.Element;
+export declare const Pencil: ({ size }: {
+    size?: number;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const Scribble: () => import("react/jsx-runtime").JSX.Element;
 export declare const Cursor: () => import("react/jsx-runtime").JSX.Element;
 export declare const Paperclip: () => import("react/jsx-runtime").JSX.Element;
 export declare const Record: () => import("react/jsx-runtime").JSX.Element;
-export declare const Camera: () => import("react/jsx-runtime").JSX.Element;
+export declare const Mic: () => import("react/jsx-runtime").JSX.Element;
+export declare const Camera: ({ size }: {
+    size?: number;
+}) => import("react/jsx-runtime").JSX.Element;
 export declare const FileIcon: () => import("react/jsx-runtime").JSX.Element;
 export declare const Back: () => import("react/jsx-runtime").JSX.Element;
 export declare const Ellipsis: () => import("react/jsx-runtime").JSX.Element;
@@ -38,3 +44,11 @@ export declare const Search: () => import("react/jsx-runtime").JSX.Element;
 export declare const ZoomOut: () => import("react/jsx-runtime").JSX.Element;
 export declare const ZoomIn: () => import("react/jsx-runtime").JSX.Element;
 export declare const Reply: () => import("react/jsx-runtime").JSX.Element;
+export declare const Markup: () => import("react/jsx-runtime").JSX.Element;
+export declare const Highlighter: () => import("react/jsx-runtime").JSX.Element;
+export declare const ArrowTool: () => import("react/jsx-runtime").JSX.Element;
+export declare const Square: () => import("react/jsx-runtime").JSX.Element;
+export declare const Circle: () => import("react/jsx-runtime").JSX.Element;
+export declare const TextTool: () => import("react/jsx-runtime").JSX.Element;
+export declare const Redo: () => import("react/jsx-runtime").JSX.Element;
+export declare const Trash: () => import("react/jsx-runtime").JSX.Element;

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

@@ -1,2 +1,4 @@
-export { CommentToolbar, type ToolbarSource } from "./loader.js";
+export { CommentToolbar } from "./loader.js";
 export type { ToolbarPosition, ToolbarProps, ToolbarTheme } from "./toolbar.js";
+export { queryCacheSummary, reportToolbarError } from "./debug-context-host.js";
+export type { DebugContextConfig, DebugContextOptions, DebugSignal, HostContext, } from "./debug-context-model.js";

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

@@ -0,0 +1,8 @@
+/** A point in px, and the toolbar's ink colours. DOM-free; shared by sketches and markup. */
+export type Point = {
+    x: number;
+    y: number;
+};
+/** Ink colour, and the halo under it that keeps a stroke readable on dark and busy pages. */
+export declare const INK = "#ff3b30";
+export declare const INK_HALO = "rgba(255, 255, 255, 0.85)";

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

@@ -0,0 +1,14 @@
+/**
+ * What kind of report a new comment is, when the person says: `POST /v1/threads` takes it as `kind`. Left
+ * unsaid, nothing is sent and the service decides with the title. DOM-free.
+ *
+ * The kinds mirror `ClarityKind` in `packages/contract/src/clarity.ts`; the toolbar bundle does not import the
+ * contract package. `tests/kind-composer.spec.tsx` holds the two in step.
+ */
+export type ReportKind = "bug" | "feedback" | "discussion";
+export declare const REPORT_KINDS: readonly {
+    readonly kind: ReportKind;
+    readonly label: string;
+}[];
+/** `value` as a kind, or null: a stored draft holds whatever an older or newer build wrote. */
+export declare function readReportKind(value: unknown): ReportKind | null;

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

@@ -0,0 +1,25 @@
+/**
+ * The live socket's protocol and timing, shared by the web toolbar's `useThreadsSync` (`./sync.ts`) and native
+ * clients: what a message means, the keepalive, the push batch, and the reconnect backoff. DOM-free.
+ */
+export type LiveMessage = {
+    type: "changed";
+} | {
+    type: "build";
+    build: string;
+} | {
+    type: "pong";
+};
+/**
+ * What the worker sent over the live socket: "changed" (threads moved; also anything unrecognised, so an older
+ * worker's pushes still refresh), a build announcement, or the keepalive answer.
+ */
+export declare function parseLiveMessage(data: unknown): LiveMessage;
+/** If the live socket hasn't opened by then, fetch anyway instead of waiting on a slow handshake. */
+export declare const OPEN_WAIT_MS = 2000;
+/** After this many handshakes in a row that never opened (a CSP block, say), retry only every RETRY_LATER_MS. */
+export declare const MAX_QUICK_RETRIES = 4;
+export declare const RETRY_LATER_MS: number;
+export declare const KEEPALIVE_MS = 25000;
+/** Pushes that arrive together cause one refetch. */
+export declare const PUSH_BATCH_MS = 120;

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

@@ -1,14 +1,8 @@
 import type { ToolbarProps } from "./toolbar.js";
-export type ToolbarSource = "latest" | "bundled";
 /**
- * Renders nothing and does nothing during render. Once the page is idle it asks the session route, once per page
- * load, whether comments are on, and only then loads and mounts the toolbar.
+ * Renders nothing and does nothing during render. Once the page is idle it asks the session route whether
+ * comments are on, and only then loads and mounts the toolbar (`./boot.ts`, which the script-tag loader runs
+ * too). While the toolbar is not on the page the route is asked again when a sign-in may have happened
+ * (`./host-watch.ts`); once it is, the toolbar follows the host's sign-in itself.
  */
-export declare function CommentToolbar({ source, sessionPath, pollMs, position, theme, navigate, }: ToolbarProps & {
-    /**
-     * "latest" (default) loads the newest compatible toolbar from the comment service, so fixes ship
-     * without a dependency upgrade, and falls back to the copy in this package if that fails.
-     * "bundled" always uses the copy in this package.
-     */
-    source?: ToolbarSource;
-}): null;
+export declare function CommentToolbar({ sessionPath, pollMs, position, theme, navigate, screen, debugContext, }: ToolbarProps): null;