@wenathlan/devthink 2.0.12 → 2.0.14

package/dist/views.d.ts

@@ -0,0 +1,579 @@
+/**
+ * The views module of the 1.1.90 consolidation: every correlated variation of the interface surface logic interned in this one file, so the module family carries one surface without duplicate variations.
+ * The correlation is the interface surface family itself: surfaces holds the commandpalette, the taskinput proposals, the onboarding walkthrough and the command bus with the broadcast channel every surface shares; statusviews carries the statusbadge, the done and attention notifications, the recent tray and the stetoast stack; pickerviews scores the element candidates of a picker session with its target halo, page chips and guided tips; tourviews replays the featuretour and localizes the a11ylabels through the locale bundles; evidenceviews renders the shotpanel and the compareviewer pair of the capture evidence; datagrid infers the column types of extraction results with its sorting, filtering, range selection and masked exports; virtlist windows the long lists every surface renders; siteprefs resolves the site profiles, the theme tokens, the locale bundles and the shortcut bindings; quickactions carries the quickaction catalog with its omnibox task parsing and shortcut grammar; and attentionfeed collects, dedupes, ranks and dismisses the attention entries every surface surfaces.
+ * No palette depth, list window, locale set or shortcut is ever hardcoded: every bound stays the user's choice with no engine cap, and no surface action ever bypasses the human review.
+ */
+import type { broadcastchannelkind, broadcastframe, onboardingstate, onboardingstep, paletteentry, palettematch, paletteuserecord, surfaceaction, surfaceroute, taskinputsubmission, uisurface, notificationpayload, recenttrayentry, statusbadgestate, stetoast, guidedtip, pagechipconfirmation, pickercandidate, pickersession, targethalo, a11ylabel, featuretourstop, localebundle, compareviewerpair, shotpanelview, datagridcolumn, datagridrow, datagridview, exportmenudescriptor, virtlistwindow, darklighttokens, siteprofile, shortcutbinding, omniboxtasksubmission, quickaction, attentionentry, attentioncause } from "./types.js";
+/**
+ * Interface surface logic of the 1.1.64 family, part one.
+ * The popup, the sidepanel, the dashboardpage, the optionspage and the onboarding share this pure logic: the commandpalette registers its catalog from every module at startup, lists only the actions the current capability set allows and ranks fuzzy matches over ids, labels and keywords with the recent commands first; the taskinput builds submissions with the active origin and the page outline attached and routes them through the same proposal flow as the api; the onboarding walks its four steps once on first install, replays on demand and writes a single consent scoped event on completion; the command bus routes every surface action through the same policy gates; and the single broadcast channel frames every run state, logstream, session store and settings change the surfaces subscribe to.
+ * No window, limit or ranking depth is ever hardcoded: every bound stays the user's choice with no engine cap, and no surface action ever bypasses the human review.
+ */
+/** The commandpalette catalog registered from every module at startup: each entry routes through the command bus with the permission and session needs it declares. */
+export declare function surfacepalette(): paletteentry[];
+/** Lists only the palette actions the current capability set and session state allow: every command rides its existing permission gate before it lists. */
+export declare function palettecommandsof(entries: paletteentry[], input: {
+    granted: string[];
+    sessionactive: boolean;
+}): paletteentry[];
+/** Ranks the fuzzy palette matches for one query: ids, labels and keywords match while the most recently used commands rank first among equal scores. */
+export declare function palettequery(entries: paletteentry[], input: {
+    text: string;
+    usage: paletteuserecord[];
+    recentwindow?: number;
+}): palettematch[];
+/** Records one commandpalette use: the count grows and the last use time moves so the recent first ranking reads both. */
+export declare function paletteuseafter(usage: paletteuserecord[], command: string, now: number): paletteuserecord[];
+/** Builds one taskinput submission with the active origin and the page outline context attached; an empty text or origin refuses the submission. */
+export declare function taskinputof(input: {
+    text: string;
+    context?: string;
+    origin: string;
+    surface: uisurface;
+    at: number;
+}): taskinputsubmission;
+/** Keeps the taskinput history per profile with the newest entry first; an absent retention window keeps every entry. */
+export declare function taskhistoryafter(history: taskinputsubmission[], entry: taskinputsubmission, retention: number | undefined, now: number): taskinputsubmission[];
+/** The five onboarding steps: the origin grants, the plan review, the run control, the log audit walkthrough of a first run and the optional library walkthrough stop of the 1.1.66 ecosystem family. */
+export declare function onboardingsteps(): onboardingstep[];
+/** Starts the onboarding once on first install or on an explicit replay: a fresh walkthrough begins while an already done state resets. */
+export declare function onboardingstart(previous: onboardingstate | undefined, now: number): onboardingstate;
+/** Completes one onboarding step: the walkthrough records the step and a full completion of every mandatory stop writes exactly one consent scoped event while the optional library stop enriches without blocking. */
+export declare function onboardingcomplete(state: onboardingstate, stepid: string, now: number): {
+    state: onboardingstate;
+    consentevent?: string;
+};
+/** Builds one broadcast frame of the single surface channel: every run state, logstream, session store and settings change rides the same channel. */
+export declare function broadcastframeof(input: {
+    channel: broadcastchannelkind;
+    surface: uisurface | "background";
+    summary: string;
+    at: number;
+}): broadcastframe;
+/** Maps one audit kind onto the broadcast channel its frame rides: run control kinds carry run state, session store kinds carry session updates and the rest streams as logstream frames. */
+export declare function broadcastchannelof(kind: string): broadcastchannelkind;
+/** Routes one surface action through the command bus: every action rides the same policy gates before it dispatches and the verdict names the gate that decided. */
+export declare function busrouteaction(action: surfaceaction, input: {
+    sessionactive: boolean;
+    granted: string[];
+    planreviewed: boolean;
+    planstate: string;
+    text?: string;
+    origin?: string;
+}): surfaceroute;
+/** The terminal command registry the cli grows: the palette definitions the extension registers share this registry, so one command catalog drives the surfaces and the cli with no drift between them. */
+export declare function clicommands(palette: paletteentry[]): Array<{
+    id: string;
+    label: string;
+    keywords: string[];
+    surface: string;
+    terminal: boolean;
+}>;
+/** The fixed keyboard focus order of the review dialog of the 2.0.2 final polish (roadmap rc.2 item 34): the keyboard reads the step summary first, then walks the approve, revise and reject controls, so the review dialog answers one predictable sequence instead of the tab order the markup happens to carry. */
+export declare const reviewdialogorder: readonly ("readsummary" | "approve" | "revise" | "reject")[];
+/** Computes the ordered tabindex sequence of the review dialog controls: every control of the fixed order earns its tabindex in sequence starting at one while the first control names the focus target the dialog moves focus to when it opens; a control list that repeats or empties a control refuses because a focus order that loses a control hides it from the keyboard. */
+export declare function focusorderof(controls?: readonly string[]): {
+    order: Array<{
+        control: string;
+        tabindex: number;
+    }>;
+    focusfirst: string;
+};
+/**
+ * Statusbadge, notification, recenttray and stetoast logic of the 1.1.65 family.
+ * The user stays informed without watching: the statusbadge derives its idle, running, waiting and attention states from the run state and counts the waiting gates when attention is needed on the toolbar icon; notifydone fires on run completion with a deep link to the runsummary while notifyattention fires on gate waits, phishguard blocks and deferrals with a deep link to the exact waiting step and every notification respects the os do not disturb state and shows page content only after its consent; the recenttray lists the latest runs in the popup with resume for halted runs and reopen for completed ones; and the stetoasts confirm step completion with kind and duration, stacking with a bounded live count and a history view.
+ * No depth or live count is ever hardcoded: the recenttray depth and the toast live count stay user choices with no engine cap, and no notification ever bypasses the content consent.
+ */
+/** Derives the statusbadge state of the toolbar icon from the run state: idle with no run, running while the approved plan executes, waiting while a gate holds and attention when waiting gates count above zero. */
+export declare function statusbadgeof(input: {
+    planstate?: "pending" | "approved" | "rejected" | "cancelled" | "expired";
+    waitingcount: number;
+    runid?: string;
+}): statusbadgestate;
+/** Renders the toolbar badge text of one statusbadge state: attention names its waiting gate count, running marks the live run and idle clears the badge. */
+export declare function badgetextof(state: statusbadgestate): string;
+/** Names the badge color of one statusbadge state so the outline color follows the run state. */
+export declare function badgecolorof(state: statusbadgestate): string;
+/** Pluralizes one counted noun of the notification texts: english and the shipped pt bundle both keep the singular at exactly one while zero and counts above one take the plural — english appends the s while portuguese nouns ending in ão take the ões shape — with the portuguese nouns the notifications name carrying their bundle words so the localized plurals of the 2.0.2 final polish (roadmap rc.2 item 36) read "1 step", "3 steps", "1 etapa", "3 etapas" and "2 execuções" from the same rule. */
+export declare function pluralize(count: number, noun: string, language?: string): string;
+/** Renders one counted noun as its localized count label: the number beside its correctly pluralized noun — "1 step", "3 steps", "1 capture", "4 captures" — so every notification body that carries a count reads its own grammar instead of a hardcoded plural. */
+export declare function countlabel(count: number, noun: string, language?: string): string;
+/** Builds the notifydone payload of a completed run: the plain language title and body with the deep link to the runsummary; the body never carries page content so no consent is needed, and an absent summary falls back to the counted steps and captures the run recorded, pluralized through the countlabel grammar so one step reads "1 step" while three read "3 steps". */
+export declare function notifydoneof(input: {
+    runid: string;
+    origin: string;
+    summary: string;
+    steps?: number;
+    captures?: number;
+    language?: string;
+    at: number;
+}): notificationpayload;
+/** Builds the notifyattention payload of a gate wait, a phishguard block or a deferral: the deep link opens the exact waiting step of the run; a body that carries page content needs its consent before it builds, and an optional waiting gate count appends its pluralized count so "1 gate waits" never reads "1 gates wait". */
+export declare function notifyattentionof(input: {
+    runid: string;
+    stepid: string;
+    cause: "gatewait" | "phishguard" | "deferral";
+    reason: string;
+    waitinggates?: number;
+    language?: string;
+    content?: boolean;
+    consent?: boolean;
+    at: number;
+}): notificationpayload;
+/** Applies the os do not disturb state to one notification: a quiet os suppresses the toast while the deep link stays in the history for the user to open. */
+export declare function notificationrespectsdnd(payload: notificationpayload, dnd: boolean): {
+    show: boolean;
+    reason: string;
+};
+/** Builds one recenttray entry: the run id, the origin, the outcome, the title and the time; a halted run offers resume while a completed run offers reopen. */
+export declare function recenttrayentryof(input: {
+    runid: string;
+    origin: string;
+    outcome: "running" | "completed" | "halted" | "failed";
+    title: string;
+    at: number;
+}): recenttrayentry;
+/** Appends one recenttray entry with the newest first: the user configured depth keeps the latest runs while an absent depth keeps every run. */
+export declare function recenttrayafter(entries: recenttrayentry[], entry: recenttrayentry, depth: number | undefined): recenttrayentry[];
+/** Lists the actions one recenttray entry offers: resume for a halted run and reopen for a completed or failed one. */
+export declare function recenttrayactions(entry: recenttrayentry): string[];
+/** Builds one stetoast: the step completion confirmation with the step kind and its duration in milliseconds. */
+export declare function stetoastof(input: {
+    stepid: string;
+    kind: string;
+    durationms: number;
+    at: number;
+}): stetoast;
+/** Stacks one steteoast with a bounded live count: the live stack keeps the newest toasts inside the user configured bound while the full history stays queryable; an absent bound keeps every toast live. */
+export declare function stetoaststackafter(toasts: stetoast[], toast: stetoast, livecount: number | undefined): {
+    live: stetoast[];
+    history: stetoast[];
+};
+/** Reads the toast history newest first for the history view. */
+export declare function stetoasthistory(toasts: stetoast[]): stetoast[];
+/**
+ * Pickeroverlay, targethalo, guidedtips and pagechips logic of the 1.1.65 family.
+ * Selection and inline review live here: the pickeroverlay starts from the sidepanel, lists the element candidates of the granted origin with stability scored selectors and locks one candidate for the proposed step; the targethalo outlines the active target element during a run with its color following the step state; the guidedtips explain the selector choice during picker sessions and dismiss and recall from the optionspage; and the pagechips render inline confirmations anchored to the target element with approve and reject actions whose resolutions write to the immutable log exactly like stepapprove.
+ * No candidate count or scoring depth is ever hardcoded: every bound stays the user's choice, and no picker read or pagechip resolution ever bypasses the human review.
+ */
+/** Scores one element candidate for selector stability: an id selector scores highest, stable attribute and role selectors score next, a unique text anchor lifts the score and positional selectors score lowest. */
+export declare function stabilityscoreof(input: {
+    selector: string;
+    hasid: boolean;
+    hasstableattributes: boolean;
+    hasrole: boolean;
+    textunique: boolean;
+}): number;
+/** Builds one picker candidate with its stability score and the plain language reason the score stands. */
+export declare function pickercandidateof(input: {
+    selector: string;
+    text?: string;
+    role?: string;
+    hasid: boolean;
+    hasstableattributes: boolean;
+    hasrole: boolean;
+    textunique: boolean;
+}): pickercandidate;
+/** Starts one pickeroverlay session from the sidepanel: the origin grants gate the reads and the candidates rank by their stability score. */
+export declare function pickersessionstart(input: {
+    origin: string;
+    granted: string[];
+    candidates: pickercandidate[];
+    at: number;
+}): pickersession;
+/** Ranks the picker candidates by their stability score with the most stable selector first. */
+export declare function rankcandidates(candidates: pickercandidate[]): pickercandidate[];
+/** Locks one picker candidate for the proposed step: the locked session carries the step id and the chosen selector while a second lock on the same session refuses. */
+export declare function lockcandidate(session: pickersession, candidateindex: number, stepid: string): pickersession;
+/** Builds one targethalo geometry descriptor: the step it outlines, the target selector, the pixel rect and the step state that colors the outline. */
+export declare function haloof(input: {
+    stepid: string;
+    selector: string;
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    state: targethalo["state"];
+}): targethalo;
+/** Colors the targethalo outline by step state: pending stays gray, running blue, waiting amber, done green, failed red and halted dark. */
+export declare function halocolorof(state: targethalo["state"]): string;
+/** The guidedtips content bound to picker sessions: each tip explains one selector choice with its surface and its picker step. */
+export declare function guidedtips(): guidedtip[];
+/** Dismisses one guidedtip: the dismissed tip never shows again on its own while the optionspage recalls every dismissed tip on demand. */
+export declare function guidedtipdismiss(tips: guidedtip[], dismissed: string[], tipid: string): string[];
+/** Recalls every dismissed guidedtip: the recall clears the dismissed list so the tips show again. */
+export declare function guidedtiprecall(dismissed: string[]): string[];
+/** Builds one pagechip confirmation anchored to the target element of a gated step: the chip renders inline on the page with its approve and reject actions. */
+export declare function pagechipof(input: {
+    stepid: string;
+    selector: string;
+    origin: string;
+    at: number;
+}): pagechipconfirmation;
+/** Resolves one pagechip with its approve or reject action: the resolution carries its human surface and writes to the immutable log exactly like a stepapprove resolution. */
+export declare function pagechipresolve(chip: pagechipconfirmation, resolution: "approve" | "reject", surface: uisurface | "background", at: number): {
+    chip: pagechipconfirmation;
+    logevent: {
+        kind: "review";
+        summary: string;
+        stepid: string;
+    };
+};
+/**
+ * Featuretour and a11ylabels logic of the 1.1.65 family.
+ * The interface teaches itself here: the featuretour replays the onboarding walkthrough on demand and adds its own stops for the datagrid, the compareviewer and the pickeroverlay with the surface and the focus of every stop; and the a11ylabels name every control across the popup, the sidepanel, the dashboardpage and the optionspage with role, name, state and value for screen readers, following the language of the interface.
+ * No stop count or label set is ever hardcoded: every tour and label reads the same locale bundles, and no tour stop ever bypasses the human review.
+ */
+/** The featuretour stops: the onboarding walkthrough replays on demand while the added stops walk the datagrid, the compareviewer and the pickeroverlay with their surface and focus. */
+export declare function featuretourstops(): featuretourstop[];
+/** Orders the featuretour stops by their stop order for the replay. */
+export declare function featuretourordered(stops: featuretourstop[]): featuretourstop[];
+/** The stop of the featuretour at one position for the replay walkthrough. */
+export declare function featuretourstopat(stops: featuretourstop[], position: number): featuretourstop | undefined;
+/** Builds one a11ylabel: the control, its role, its accessible name and its optional state and value for screen readers. */
+export declare function a11ylabelof(input: {
+    control: string;
+    role: a11ylabel["role"];
+    name: string;
+    state?: string;
+    value?: string;
+}): a11ylabel;
+/** The a11ylabels of one surface: every control across the popup, the sidepanel, the dashboardpage and the optionspage carries its role, name, state and value. */
+export declare function a11ylabelsfor(surface: uisurface): a11ylabel[];
+/** Localizes one a11ylabel through the locale bundles: the accessible name resolves in the language of the interface with the english fallback so every control keeps a spoken name. */
+export declare function a11ylabellocalized(label: a11ylabel, bundles: localebundle[], language: string): a11ylabel;
+/** Localizes every a11ylabel of one surface so screen readers follow the language of the interface. */
+export declare function a11ylabelslocalizedfor(surface: uisurface, bundles: localebundle[], language: string): a11ylabel[];
+/**
+ * Shotpanel and compareviewer logic of the 1.1.65 family.
+ * Evidence views live here: the shotpanel previews the capture of every step with its capture provenance and redaction verdicts and zooms and pans the large stitched captures; the compareviewer pairs the before and after captures of every executed write step and overlays the two captures with a slider so the user sees exactly what the step changed.
+ * No zoom factor, pan step or pixel ceiling is ever hardcoded: every view stays a user choice, and no capture of an ungranted origin ever opens in the panel.
+ */
+/** Builds one shotpanel view: the step, the run, the capture id, the capture provenance, the redaction verdicts and the zoom and pan the user set; the capture origin must hold a granted origin. */
+export declare function shotpanelof(input: {
+    stepid: string;
+    runid: string;
+    captureid: string;
+    provenance: "viewport" | "fullpage" | "element" | "region";
+    origin: string;
+    granted: string[];
+    redactions?: Array<{
+        region: string;
+        verdict: string;
+    }>;
+    at: number;
+}): shotpanelview;
+/** Zooms one shotpanel view: the factor multiplies the current zoom while a non positive zoom refuses the change. */
+export declare function shotpanelzoom(view: shotpanelview, factor: number): shotpanelview;
+/** Pans one shotpanel view: the offsets move the viewport over the large stitched capture so the user inspects any region. */
+export declare function shotpanelpan(view: shotpanelview, offset: {
+    x: number;
+    y: number;
+}): shotpanelview;
+/** Builds one compareviewer pair: the step, the before capture, the after capture and the slider that starts at the middle so the overlay splits the two captures. */
+export declare function comparepairof(input: {
+    stepid: string;
+    beforecaptureid: string;
+    aftercaptureid: string;
+}): compareviewerpair;
+/** Moves the compareviewer slider: the value stays between zero and one hundred so the overlay splits the before and after captures at the user chosen position. */
+export declare function overlayslider(pair: compareviewerpair, value: number): compareviewerpair;
+/** Pairs the before and after captures of every executed write step: only a step that changed page or browser state earns a pair, and each pair names its step. */
+export declare function comparepairsforsteps(steps: Array<{
+    stepid: string;
+    risk: "read" | "interaction" | "sensitive";
+    writeexecuted: boolean;
+}>, captures: Record<string, {
+    beforecaptureid?: string;
+    aftercaptureid?: string;
+}>): compareviewerpair[];
+/**
+ * Datagrid and exportmenu logic of the 1.1.65 family.
+ * The extraction half of the interface lives here: a datagrid view arranges the extraction result of one run into columns and rows with the column types inferred from the values themselves, sorts and filters rows locally inside the surface, and selects a row range so a partial export ships only what the user chose; the exportmenu offers csv, json and clipboard formats scoped to the selection, one step or the whole run and writes masked values only, honoring the maskinputs verdicts of every sensitive field shape so no clear value ever leaves the grid.
+ * No row count, column count or byte ceiling is ever hardcoded: every bound stays the user's choice with no engine cap, and no export path ever bypasses the mask verdicts.
+ */
+/** Infers one column type from its observed values: numbers, booleans and iso dates infer their type while every other shape stays text; an all empty column infers empty. */
+export declare function infercolumntype(values: string[]): datagridcolumn["type"];
+/** Builds the inferred columns of one extraction result: every field of every row becomes one column with its type inferred from the observed values. */
+export declare function datagridcolumnsof(rows: Array<Record<string, string>>): datagridcolumn[];
+/** Builds one datagrid view of an extraction result: the title, the origin it ran on, the run it belongs to, the inferred columns and the rows with their original order as index. */
+export declare function datagridof(input: {
+    title: string;
+    origin: string;
+    runid: string;
+    rows: Array<Record<string, string>>;
+    at: number;
+}): datagridview;
+/** Sorts the datagrid rows locally by one column: text sorts lexicographically while numbers, booleans and dates sort by their parsed value; an absent direction keeps the original order. */
+export declare function sortdatagridrows(view: datagridview, input: {
+    field: string;
+    direction: "ascending" | "descending";
+}): datagridview;
+/** Filters the datagrid rows locally by one text query: a row stays when any column value contains the query; an empty query keeps every row. */
+export declare function filterdatagridrows(view: datagridview, text: string): datagridview;
+/** Selects one inclusive row range for a partial export: the rows inside the range carry their selected mark while the rest clears. */
+export declare function selectrowrange(view: datagridview, from: number, to: number): datagridview;
+/** The rows one export ships: a selection scope keeps the selected rows only while the step and run scopes ship every row of the grid. */
+export declare function exportrowsof(view: datagridview, scope: exportmenudescriptor["scope"]): datagridrow[];
+/** Builds the exportmenu descriptors of one datagrid: the csv, json and clipboard formats scoped to the selection, one step or the whole run. */
+export declare function exportmenudescriptors(): exportmenudescriptor[];
+/** Masks one field value when the mask verdicts name it: a masked value never renders in the clear while every other value ships as extracted. */
+export declare function maskedvalueof(value: string, field: string, maskverdicts: Record<string, string>): {
+    value: string;
+    masked: boolean;
+};
+/** Renders the export payload of one datagrid view: csv writes the header row and every shipping row, json writes the typed records and the clipboard format writes the csv text for the clipboard. */
+export declare function exportdatagrid(view: datagridview, descriptor: exportmenudescriptor, maskverdicts?: Record<string, string>): {
+    format: exportmenudescriptor["format"];
+    scope: exportmenudescriptor["scope"];
+    destination: exportmenudescriptor["destination"];
+    text: string;
+    rows: number;
+    maskedfields: string[];
+};
+/**
+ * Virtlist logic of the 1.1.68 family.
+ * Long lists render through a virtualized window in every surface: the window keeps the visible row range, the measured height map holds the row heights the measurement pass records, and the row nodes recycle during scroll instead of rebuilding.
+ * The row window stays the user's choice: an absent window renders every row, and no engine default ever caps a list.
+ */
+/** Builds the initial virtlist window of one surface at scroll top: the window starts at row zero, spans the user configured row count or every row when the user set none, and the height map starts empty. */
+export declare function openvirtlist(input: {
+    surface: string;
+    total: number;
+    rows?: number;
+}): virtlistwindow;
+/** Moves one virtlist window to a scroll offset: the window keeps its span, clamps inside the row range and recycles the rows the previous window rendered when they stay inside the new range. */
+export declare function scrollvirtlist(window: virtlistwindow, start: number, rows?: number): virtlistwindow;
+/** Measures the row heights of one virtlist window: the height map records the measured height of every rendered row while the rows outside the window keep their last measurement. */
+export declare function measurevirtlistrows(window: virtlistwindow, measurements: Record<string, number>): virtlistwindow;
+/** Reads the row slice one virtlist window renders: only the rows inside the window travel to the surface while the full list stays in memory. */
+export declare function virtlistrows<T>(window: virtlistwindow, rows: T[]): T[];
+/** Reads the estimated height of one virtlist window from its height map: measured rows count their measurement while unmeasured rows count the estimate the caller supplies because no engine default exists. */
+export declare function virtlistheight(window: virtlistwindow, estimate: number): {
+    measured: number;
+    estimate: number;
+    total: number;
+};
+/** Reads the render savings of one virtlist window: the rows the surface avoided rendering beside the recycled nodes the scroll reused. */
+export declare function virtlistsavings(window: virtlistwindow): {
+    rendered: number;
+    skipped: number;
+    recycled: number;
+};
+/** Builds the height map key of one row so the per surface height maps the memory stores stay stable across scrolls. */
+export declare function heightmapkey(surface: string, row: number): string;
+/** Builds the per surface height map record the memory stores for reuse: the surface, its measured heights and the time of the measurement pass. */
+export declare function heightmaprecord(input: {
+    surface: string;
+    heights: Record<string, number>;
+    now: number;
+}): {
+    surface: string;
+    heights: Record<string, number>;
+    at: number;
+};
+/**
+ * Siteprofiles, darklight themes and locale logic of the 1.1.65 family.
+ * The surface rounds out here: siteprofiles store the per site interface preferences (the theme, the shortcutkeys and the default view) beside the originprofiles policy preferences and activate automatically on their origin; the darklight theme follows the os preference with a manual override while its tokens cover every surface including the dashboardpage; and the locale bundles ship the interface strings of every supported language with an english fallback for missing strings and per language date, number and duration formatting.
+ * No theme, language or profile is ever forced: every preference stays the user's choice, and no siteprofile ever adjusts a policy gate.
+ */
+/** Builds one siteprofile: the origin, the theme, the shortcutkeys, the default view and the update time; the origin must hold an https shape because the profile extends the originprofiles family. */
+export declare function siteprofileof(input: {
+    origin: string;
+    theme?: siteprofile["theme"];
+    shortcuts?: shortcutbinding[];
+    defaultview?: string;
+    at: number;
+}): siteprofile;
+/** Tests whether one siteprofile activates on the given origin: the profile applies automatically when its origin matches the active origin exactly. */
+export declare function siteprofileactive(profile: siteprofile, origin: string): boolean;
+/** Resolves the effective siteprofile of one origin: the stored profile applies when its origin matches while an absent profile returns undefined and the global preferences keep governing. */
+export declare function siteprofilefor(profiles: siteprofile[], origin: string): siteprofile | undefined;
+/** The darklight theme tokens of one mode: every surface, including the dashboardpage, reads the same token names so the theme covers the whole interface. */
+export declare function darklighttokensof(mode: darklighttokens["mode"]): darklighttokens;
+/** Resolves the effective appearance: the siteprofile theme wins on its origin, the manual user override wins next and the os preference governs when no override exists, with the source naming which layer decided. */
+export declare function resolveappearance(input: {
+    ospreference: "dark" | "light";
+    useroverride?: "dark" | "light" | "system";
+    siteprofile?: siteprofile;
+}): darklighttokens;
+/** Applies one token set to a surface document: every custom property of the theme lands on the root element so every surface, including the dashboardpage, renders with the same tokens. */
+export declare function applytheme(documentroot: {
+    style: {
+        setProperty(name: string, value: string): void;
+    };
+}, tokens: darklighttokens): void;
+/** The high contrast token set of the 2.0.2 final polish (roadmap rc.2 item 35): the same token names the darklight family resolves, retuned so every reading token reaches at least 4.5:1 against its surface and the accent and border reach at least 3:1 under the WCAG relative luminance arithmetic — pure black surfaces with white ink and whitened signal colors in the dark mode, a white surface with black ink and deepened signal colors in the light mode — while the default darklight sets stay untouched beside it. */
+export declare function highcontrasttokens(mode: darklighttokens["mode"]): darklighttokens;
+/** Resolves the effective token set under the contrast preference of the 2.0.2 final polish: the default preference keeps the darklight tokens exactly as the family resolved them while the high preference swaps in the high contrast set of the same mode, so the preference never moves the dark or light mode itself. */
+export declare function contrasttokensof(input: {
+    mode: darklighttokens["mode"];
+    contrast: "default" | "high";
+}): darklighttokens;
+/** Applies the resolved tokens with their contrast variant to one surface document: the --theme-* custom properties land on the document root the darklight family already writes while the body carries its data-contrast attribute, so a high contrast surface renders from the same rules and names its variant for the assistive surface. */
+export declare function applycontrasttheme(documentroot: {
+    style: {
+        setProperty(name: string, value: string): void;
+    };
+}, body: {
+    setAttribute(name: string, value: string): void;
+}, tokens: darklighttokens, contrast: "default" | "high"): void;
+/** The dashboard panel width bounds of the 2.0.2 final polish (roadmap rc.2 item 37): every resizable panel column keeps at least the readable minimum while no column passes the shared maximum, and a known viewport keeps the sibling column its minimum too. */
+export declare const panelwidthbounds: Readonly<{
+    minimum: number;
+    maximum: number;
+}>;
+/** Clamps one dashboard panel width inside the bounds: the floor keeps the column readable, the ceiling holds the shared maximum, and a viewport the caller supplies narrows the ceiling so the sibling column never loses its own minimum. */
+export declare function clamppanelwidth(width: number, viewport?: number | undefined): number;
+/** Parses the persisted panelwidths preferences of the dashboard columns from the layout seam shape: the "left=480" row resolves into the clamped left width while an absent or malformed row keeps the shipped default split. */
+export declare function panelwidthsof(raw: string | undefined, viewport?: number | undefined): {
+    left: number;
+};
+/** Serializes the panelwidths preferences into the layout seam shape: the "left=480" row the per surface preferences persist, one clamped width per named column. */
+export declare function panelwidthslayout(widths: {
+    left: number;
+}): string;
+/** Applies one resize move to the panelwidths state: the pointer delta moves the left column width by its pixels, the clamp holds the bounds and the answer names whether the move clamped, so the drag stops pushing the column past its readable edge. */
+export declare function resizepanel(input: {
+    widths: {
+        left: number;
+    };
+    delta: number;
+    viewport?: number | undefined;
+}): {
+    widths: {
+        left: number;
+    };
+    clamped: boolean;
+};
+/** The shipped locale bundles of the supported languages: every bundle carries the interface strings of its language with english as the fallback base. */
+export declare function localebundles(): localebundle[];
+/** Resolves one interface string in the requested language: a missing string falls back to the english bundle so no control ever renders an empty label. */
+export declare function localestring(bundles: localebundle[], language: string, key: string): string;
+/** The languages the shipped bundles cover. */
+export declare function supportedlanguages(bundles: localebundle[]): string[];
+/** Formats one date, number or duration value per language: dates render with the locale order, numbers with the locale separators and durations as minutes and seconds. */
+export declare function localeformat(input: {
+    language: string;
+    value: number;
+    kind: "date" | "number" | "duration";
+}): string;
+/**
+ * Quickactions, shortcutkeys and omniboxtask logic of the 1.1.65 family.
+ * The path to a run shortens here: quickactions bind the context menu entries of the active tab (extract page, capture shot, run recent and open dashboardpage) behind the origin allowlist of the clicked tab so only permitted actions surface; shortcutkeys bind run, pause, resume, cancelrun and the commandpalette to user editable key combinations that route through the same commandpalette gates; and the omniboxtask parses the keyword text into a taskinput submission that lands in the standard proposal flow with its review intact.
+ * No binding is ever forced: every shortcut stays user editable in the optionspage, and no quickaction, shortcut or omnibox entry ever bypasses the human review.
+ */
+/** The quickaction catalog bound to the context menu entries of the active tab: extract page, capture shot, run recent and open dashboardpage. */
+export declare function quickactioncatalog(): quickaction[];
+/** Lists only the quickactions the active origin permits: every entry rides the origin allowlist of the clicked tab before it registers. */
+export declare function quickactionsfor(catalog: quickaction[], input: {
+    origin: string;
+    granted: string[];
+    sessionactive: boolean;
+    grantedcapabilities?: string[];
+}): quickaction[];
+/** The default shortcutkeys bindings: run, pause, resume, cancelrun and the commandpalette open from every surface; every binding stays user editable. */
+export declare function shortcutdefaults(): shortcutbinding[];
+/** Parses one shortcut text such as ctrl+. into its key and modifiers: an empty text refuses the binding. */
+export declare function parseshortcut(text: string): {
+    key: string;
+    modifiers: string[];
+};
+/** Formats one shortcut binding as its display text with the modifiers first. */
+export declare function shortcuttext(binding: shortcutbinding): string;
+/** Edits one shortcut binding: the user chosen combination replaces the binding while an unknown command refuses the edit. */
+export declare function shortcutbindingafter(bindings: shortcutbinding[], command: string, text: string): shortcutbinding[];
+/** Matches one pressed key and modifier set against the bindings: the first command whose combination matches wins, and the palette command matches from every surface. */
+export declare function shortcutcommandof(bindings: shortcutbinding[], input: {
+    key: string;
+    modifiers: string[];
+    surface: uisurface;
+}): string | undefined;
+/** Confirms one bound command rides the commandpalette catalog with its gates intact: a shortcut may only trigger a command the palette action gate lists for the current capability set and session state. */
+export declare function shortcutdispatchable(command: string, entries: paletteentry[], input: {
+    granted: string[];
+    sessionactive: boolean;
+}): boolean;
+/** Parses one omnibox keyword text into an omniboxtask submission: the text after the keyword becomes the natural language goal of the active origin while an empty text refuses the submission. */
+export declare function parseomniboxtask(input: {
+    text: string;
+    origin: string;
+    at: number;
+}): omniboxtasksubmission;
+/** Lands one omniboxtask submission in the standard proposal flow: the submission becomes a taskinput of the omnibox surface that routes through the same proposal and review gates as the api. */
+export declare function omniboxtasktotaskinput(submission: omniboxtasksubmission): taskinputsubmission;
+/**
+ * Attentionfeed logic of the 1.1.66 family.
+ * Everything that needs a human lands in one feed: gate waits, phishguard blocks, deferrals and failures each collect as one entry with its cause, its run and gate refs and its deep link to the exact waiting surface, repeated causes per run deduplicate while the first occurrence keeps its time, the severity of the cause ranks the feed, and the retention window of the store stays the user's choice.
+ * The feed never resolves anything on its own: a deep link opens the waiting surface and the human resolves the cause exactly as before.
+ */
+/** Reads the severity rank of one attention cause: a gate wait and a phishguard block hold the run for a human, a deferral waits its window and a failure needs the reviewed retry. */
+export declare function attentionseverityof(cause: attentioncause): "critical" | "warning" | "info";
+/** Builds the deep link of one attention cause: the link opens the exact surface that resolves the cause. */
+export declare function attentiondeeplinkof(cause: attentioncause, runid: string, gateref?: string): string;
+/** Builds one attention entry from its source: the cause, the run ref, the gate ref when the run waits at a gate, the summary in plain language and the deep link. */
+export declare function attentionentryof(input: {
+    cause: attentioncause;
+    runid: string;
+    origin: string;
+    summary: string;
+    gateref?: string;
+    at: number;
+}): attentionentry;
+/** Collects the attention entries of one pass: the gate waits the progress recorded, the phishguard blocks, the deferred events and the failed steps each feed one entry. */
+export declare function collectattention(input: {
+    gatewaits?: Array<{
+        runid: string;
+        stepid: string;
+        gateid: string;
+        kind: string;
+        origin: string;
+        waitedms: number;
+    }>;
+    phishblocks?: Array<{
+        runid: string;
+        origin: string;
+        matchedorigin: string;
+        reason: string;
+    }>;
+    deferrals?: Array<{
+        runid: string;
+        origin: string;
+        reason: string;
+    }>;
+    failures?: Array<{
+        runid: string;
+        stepid: string;
+        origin: string;
+        message: string;
+    }>;
+    now: number;
+}): attentionentry[];
+/** Deduplicates repeated causes per run: the first occurrence of one cause inside one run keeps its entry and its time while every later occurrence drops. */
+export declare function dedupeattention(entries: attentionentry[]): attentionentry[];
+/** Ranks the attention entries by cause severity first and time second: critical gate waits and phishguard blocks stand above warnings and failures. */
+export declare function rankattention(entries: attentionentry[]): attentionentry[];
+/** Reads the count of attention entries the statusbadge surfaces. */
+export declare function attentioncountof(entries: attentionentry[]): number;
+/** Dismisses one attention entry by its id: the dismissal only removes the feed row, the waiting cause keeps its own resolution path. */
+export declare function dismissattention(entries: attentionentry[], id: string): attentionentry[];
+/** Prunes the attention entries past their retention window: an absent window keeps every entry while the pruned ids return for the audit note. */
+export declare function pruneattention(entries: attentionentry[], retention: number | undefined, now: number): {
+    kept: attentionentry[];
+    pruned: string[];
+};
+/** Renders the attention entries as system notifications: one content free payload per entry with its deep link, so no page content consent is needed. */
+export declare function attentionnotifications(entries: attentionentry[], now: number): Array<{
+    id: string;
+    kind: "done" | "attention";
+    title: string;
+    body: string;
+    deeplink: string;
+    runid?: string;
+    stepid?: string;
+    content: boolean;
+    at: number;
+}>;
+//# sourceMappingURL=views.d.ts.map