@alfadocs/ui-kit 1.47.1 → 1.48.0

package/dist/components/task-editor/index.js

@@ -0,0 +1,6 @@
+import { T as o, t as r } from "../../_chunks/task-editor-DlvTwAfv.js";
+export {
+  o as TaskEditor,
+  r as taskEditorAgent
+};
+//# sourceMappingURL=index.js.map

package/dist/components/task-editor/task-editor.agent.d.ts

@@ -0,0 +1,4 @@
+import type { AgentAdapter } from '../../agent/types';
+import type { TaskEditorHandle } from './task-editor';
+export declare const taskEditorAgent: AgentAdapter<TaskEditorHandle>;
+//# sourceMappingURL=task-editor.agent.d.ts.map

package/dist/components/task-editor/task-editor.d.ts

@@ -0,0 +1,240 @@
+/**
+ * TaskEditor: the published form for one task (platform `DoctorReminder`).
+ * It creates, edits, completes and deletes a task through host seams, and
+ * takes every list, label and seam as a prop, so a host builds it without
+ * any calendar context. The calendar's own task route renders it through a
+ * thin adapter.
+ *
+ * A note is the only field every host needs, beside ONE optional
+ * counterpart: a patient, a company or an operator, never two, because the
+ * platform refuses a task with "More than one counterpart is set". A host
+ * that supplies `taskTypes` also gets a required Type select, and one that
+ * supplies `assignees` an optional "Assigned to" (a practice user, not the
+ * operator). A missing list or seam WITHHOLDS the control it backs; it never
+ * renders that control disabled.
+ *
+ * Two layouts: `variant="panel"` fills a rail tool panel with its own header,
+ * scroll body and pinned footer; `variant="subview"` IS a PanelSubview, for a
+ * form stacked over a list such as TasksPanel.
+ *
+ * DOM hooks: `data-component="task-editor"` with `data-variant`,
+ * `data-status` and `data-component-id`; the footer actions carry
+ * `data-action` "cancel-task", "save-task" and "delete-task", and a failed
+ * load's Retry carries "retry-load". In the subview the marker sits on the
+ * body, so the PanelSubview section repeats `data-component-id`,
+ * `data-variant` and `data-status`: `[data-component-id="…"]` reaches the
+ * heading and the footer in both variants.
+ */
+import { type HTMLAttributes } from 'react';
+import type { PatientIdentity } from '../_shared/patient-identity';
+/**
+ * A task as the editor loads and saves it: platform `DoctorReminder`. At
+ * most ONE counterpart (patient, company or operator); the platform refuses
+ * a task naming two. `note` is required here though the platform allows an
+ * empty one. There is no title, priority or duration: the platform has none.
+ */
+export interface TaskEditorTask {
+    id: string;
+    /** An instant as ISO 8601 (platform `date`). The editor emits
+     *  `toISOString()`, so UTC with a `Z`. Parse it with `new Date()`, never by
+     *  slicing; a zone-less value reads as local time. */
+    dateIso: string;
+    /** The task text (platform `note`). Required here, though the platform
+     *  allows an empty one. Never exposed through the agent. */
+    note: string;
+    /** The clinician the task concerns: platform `doctorOperator`, an id from
+     *  `operators`. NOT the assignee. Exclusive with `patientId` and
+     *  `companyId`. */
+    operatorId?: string;
+    /** The patient the task concerns: platform `doctorPatient` (column
+     *  `patientId`). Exclusive with `companyId` and `operatorId`. */
+    patientId?: string;
+    /** Platform `doctorCompany`, an id from `companies`. Exclusive with
+     *  `patientId` and `operatorId`. */
+    companyId?: string;
+    /** An opaque token from `taskTypes`, round-tripped untouched. Without
+     *  `taskTypes` the Type field is withheld and a new task sends none; a
+     *  stored one is still re-sent. */
+    typeId?: string;
+    /** The practice USER the task is assigned to: platform `practiceUser`, an
+     *  id from `assignees`. Independent of the counterpart. Absent or '':
+     *  nobody. */
+    assigneeId?: string;
+    /** Platform `done`. */
+    done: boolean;
+}
+/** What `onCreateTask` receives and what an edit save re-sends IN FULL,
+ *  never a patch. `done` carries the last value the host CONFIRMED, never an
+ *  optimistic or rolled-back toggle. */
+export type TaskEditorDraft = Omit<TaskEditorTask, 'id' | 'done'> & {
+    done?: boolean;
+};
+/** One row of a host list. `label` is the host's own string, already
+ *  translated. `id` is opaque, unique in its list, never '' and never
+ *  'none' (reserved for "Nobody"). */
+export interface TaskEditorOption {
+    id: string;
+    label: string;
+}
+/** A task type. `custom` (practice-defined) only groups the Type select,
+ *  and only when the list mixes custom and standard types. */
+export interface TaskEditorTaskType extends TaskEditorOption {
+    custom?: boolean;
+}
+/** A patient as the picker needs one: an id and a display name.
+ *  `CalendarPatient` satisfies it. */
+export type TaskEditorPatient = PatientIdentity;
+/** Host patient typeahead. Called 250 ms after typing stops, for non-blank
+ *  trimmed queries only. Abort a superseded call through `signal`. The
+ *  host's order is kept, so matches by phone or number stay. Reject on
+ *  failure (the picker offers Retry); `[]` is a successful search with no
+ *  match. The same contract as `CalendarData.searchPatients`. */
+export type TaskEditorSearchPatients = (query: string, options: {
+    signal: AbortSignal;
+}) => Promise<readonly TaskEditorPatient[]>;
+/** Where the form is. 'error': the load failed, with Retry. 'locked': edit
+ *  mode without `taskId` or `loadTask`, never a blank savable form.
+ *  'withheld': the privacy notice covers an existing task. */
+export type TaskEditorStatus = 'loading' | 'ready' | 'error' | 'locked' | 'withheld';
+/** The one counterpart choice ("Concerns"). */
+export type TaskEditorAbout = 'nobody' | 'patient' | 'company' | 'operator';
+/** The draft as the agent reads it: identifiers and structure, never the
+ *  note body. Counterpart ids are what Save would send. */
+export interface TaskEditorDraftState {
+    mode: 'create' | 'edit';
+    dateIso: string | null;
+    about: TaskEditorAbout;
+    patientId: string | null;
+    companyId: string | null;
+    operatorId: string | null;
+    typeId: string | null;
+    assigneeId: string | null;
+    /** The last CONFIRMED done value. */
+    done: boolean;
+    hasNote: boolean;
+    noteLength: number;
+}
+/** Fields an agent may set. Ids must resolve in the host lists, among the
+ *  patients the host's search returned, or equal the stored one. At most
+ *  one of `patientId`, `companyId` and `operatorId` per call; each also
+ *  selects its `about` branch. `assigneeId: null` is Nobody. */
+export interface TaskEditorFieldPatch {
+    dateIso?: string;
+    note?: string;
+    typeId?: string;
+    assigneeId?: string | null;
+    about?: TaskEditorAbout;
+    patientId?: string;
+    companyId?: string;
+    operatorId?: string;
+}
+/** Curated agent handle. Writes return the host's promise, so a refusal
+ *  reaches the agent as a rejection. Every write fails unless the status is
+ *  'ready' and the form is not read-only. */
+export interface TaskEditorHandle {
+    getStatus: () => TaskEditorStatus;
+    getDraft: () => TaskEditorDraftState;
+    canSave: () => boolean;
+    /** Throws on an unknown id, two counterparts or a form not ready. */
+    setFields: (patch: TaskEditorFieldPatch) => void;
+    save: () => Promise<void>;
+    setDone: (done: boolean) => Promise<void>;
+    /** Skips the confirmation dialog: the agent runtime confirms instead. */
+    deleteTask: () => Promise<void>;
+    /** Throws while a save or delete is in flight, as Cancel waits. */
+    cancel: () => void;
+}
+export interface TaskEditorProps extends Omit<HTMLAttributes<HTMLElement>, 'children' | 'id' | 'title'> {
+    /** Stable instance id, surfaced as `data-component-id` for the agent
+     *  registry. Generated when absent. */
+    id?: string;
+    mode: 'create' | 'edit';
+    /** Edit mode: the task `loadTask` resolves. Without it, or without
+     *  `loadTask`, edit mode is 'locked'. */
+    taskId?: string;
+    /** Create mode: the local date and time to prefill. Read at mount, when
+     *  the mode or task changes and at each subview reopen. Default: now. */
+    initialDate?: Date;
+    /** 'panel' (default): fills its box with its own header, scroll body and
+     *  pinned footer, for a rail tool panel. 'subview': the editor IS a
+     *  PanelSubview; render it as the LAST, DIRECT child of a
+     *  `PanelSubview.Host`. */
+    variant?: 'panel' | 'subview';
+    /** Subview only. Default true. Each change from false to true starts a
+     *  fresh session: the draft resets and edit mode reloads. Keep one editor
+     *  mounted and toggle this, so it slides in and returns focus. */
+    open?: boolean;
+    /** Subview only: fires once the exit has played. */
+    onExited?: () => void;
+    /** The required Type select, defaulting to the first entry. */
+    taskTypes?: ReadonlyArray<TaskEditorTaskType>;
+    /** The optional "Assigned to" select: practice users, not operators. */
+    assignees?: ReadonlyArray<TaskEditorOption>;
+    /** The Company counterpart: a searchable Combobox matching the label,
+     *  never the id. */
+    companies?: ReadonlyArray<TaskEditorOption>;
+    /** The Operator counterpart: clinicians. */
+    operators?: ReadonlyArray<TaskEditorOption>;
+    /** Filtered on the client when `searchPatients` is absent. With neither,
+     *  the Patient counterpart is withheld; a stored link still shows
+     *  read-only and is re-sent on Save. */
+    patients?: ReadonlyArray<TaskEditorPatient>;
+    /** Host typeahead. Wins over `patients` for listing. May change identity
+     *  between renders; the next query uses the latest. */
+    searchPatients?: TaskEditorSearchPatients;
+    /** Display name of the task's STORED patient when nothing else resolves
+     *  it, for example from the TasksPanel row that opened the form. */
+    patientLabel?: string;
+    /** Resolves any patient id to a name. Tried before `patients` and
+     *  `patientLabel`. */
+    resolvePatientLabel?: (patientId: string) => string | undefined;
+    /** Display name of a STORED company that `companies` does not list.
+     *  Without it the read-only row names the id. */
+    companyLabel?: string;
+    /** Display name of a STORED operator that `operators` does not list.
+     *  Without it the row names the id. Each of the three labels names only
+     *  its own stored link, so a host may pass a TasksPanel row's
+     *  `linkedLabel` to the one its `linkType` names. */
+    operatorLabel?: string;
+    /** Subview only: the back arrow's name and tooltip. Already translated.
+     *  Default "Back to tasks". */
+    backLabel?: string;
+    /** Resolves the record for edit mode, once per task and session. Aborted
+     *  through `signal` when the task changes, the subview closes or the
+     *  privacy notice covers the form; a superseded answer is ignored. */
+    loadTask?: (id: string, options: {
+        signal: AbortSignal;
+    }) => Promise<TaskEditorTask>;
+    /** Must resolve WITH the saved record: the host assigns the id. */
+    onCreateTask?: (draft: TaskEditorDraft) => Promise<TaskEditorTask>;
+    /** A full re-send. Resolves with nothing. */
+    onUpdateTask?: (id: string, draft: TaskEditorDraft) => Promise<void>;
+    /** Called only after the confirmation dialog. */
+    onDeleteTask?: (id: string) => Promise<void>;
+    /** The Done switch (edit mode), called on the click. A rejection rolls
+     *  the switch back. */
+    onSetTaskDone?: (id: string, done: boolean) => Promise<void>;
+    /** Cancel, plus Back and Escape in the subview. Close the editor. None of
+     *  them fires while a save or delete is in flight. */
+    onCancel: () => void;
+    /** After a create or update LANDS. The form then stops writing until it
+     *  is closed, remounted or reopened. The form cannot be cancelled while a
+     *  write is in flight, so this fires for every save the user started,
+     *  unless the host closes or unmounts the editor itself first. */
+    onSaved?: (task: TaskEditorTask) => void;
+    /** After a delete LANDS. */
+    onDeleted?: (id: string) => void;
+    /** Withholds every write control and disables the fieldset. */
+    readOnly?: boolean;
+    /** Privacy mode: the linked patient shows as the mask, never the name. */
+    privacy?: boolean;
+    /** How an EXISTING task opens under `privacy`. 'notice' (default): the
+     *  privacy notice covers the form, the record is not loaded, and the
+     *  footer holds Cancel only. 'mask': the form opens with the patient
+     *  masked and the note visible. Create mode always opens masked. */
+    privacyMode?: 'notice' | 'mask';
+    /** The notice's "Turn off privacy mode" action. Absent: no button. */
+    onPrivacyOff?: () => void;
+}
+export declare const TaskEditor: import("react").ForwardRefExoticComponent<TaskEditorProps & import("react").RefAttributes<HTMLElement>>;
+//# sourceMappingURL=task-editor.d.ts.map

package/dist/components/task-editor/use-task-editor-form.d.ts

@@ -0,0 +1,101 @@
+import type { TaskEditorAbout, TaskEditorDraftState, TaskEditorFieldPatch, TaskEditorOption, TaskEditorPatient, TaskEditorProps, TaskEditorStatus, TaskEditorTask, TaskEditorTaskType } from './task-editor';
+/** The "unset" value of the operator and assignee selects. */
+export declare const NONE = "none";
+export interface TaskEditorFields {
+    date: Date | undefined;
+    time: {
+        hours: number;
+        minutes: number;
+    };
+    note: string;
+    /** `NONE` until an operator is chosen. */
+    operatorId: string;
+    /** '' until something chooses one. Read through `chosenTypeId`. */
+    typeId: string;
+    /** The practice user, not the operator. `NONE` is nobody. */
+    assigneeId: string;
+    about: TaskEditorAbout;
+    patientId: string;
+    /** A real id from the host list, never a typed name. */
+    companyId: string;
+}
+interface UiState {
+    showError: boolean;
+    saving: boolean;
+    saveError: string | undefined;
+    done: boolean;
+    confirmedDone: boolean;
+    donePending: boolean;
+    doneError: string | undefined;
+    deleting: boolean;
+    deleteError: string | undefined;
+    confirmDeleteOpen: boolean;
+    /** A save or delete landed: the form stops writing until a new session. */
+    accepted: boolean;
+}
+export declare function aboutOf(task: {
+    patientId?: string;
+    companyId?: string;
+    operatorId?: string;
+}): TaskEditorAbout;
+export interface UseTaskEditorFormOptions {
+    mode: 'create' | 'edit';
+    taskId: string | undefined;
+    initialDate: Date | undefined;
+    /** Panel: always. Subview: while `open`. A false-to-true change starts a
+     *  fresh session. */
+    active: boolean;
+    taskTypes: ReadonlyArray<TaskEditorTaskType>;
+    assignees: ReadonlyArray<TaskEditorOption>;
+    companies: ReadonlyArray<TaskEditorOption>;
+    operators: ReadonlyArray<TaskEditorOption>;
+    patients: ReadonlyArray<TaskEditorPatient>;
+    /** Names the host's search has returned, by id: a patient picked from
+     *  search stays nameable, and settable by the agent. */
+    searchedPatients: ReadonlyMap<string, string>;
+    resolvePatientLabel: TaskEditorProps['resolvePatientLabel'];
+    loadTask: TaskEditorProps['loadTask'];
+    onCreateTask: TaskEditorProps['onCreateTask'];
+    onUpdateTask: TaskEditorProps['onUpdateTask'];
+    onDeleteTask: TaskEditorProps['onDeleteTask'];
+    onSetTaskDone: TaskEditorProps['onSetTaskDone'];
+    onSaved: TaskEditorProps['onSaved'];
+    onDeleted: TaskEditorProps['onDeleted'];
+    readOnly: boolean;
+    /** The privacy notice covers an existing task: nothing loads. */
+    withheld: boolean;
+    /** The patient shows as the mask, so none may be picked. */
+    maskPatient: boolean;
+    /** Shown when a rejection carries no message of its own. */
+    fallbackError: string;
+}
+export declare function useTaskEditorForm({ mode, taskId, initialDate, active, taskTypes, assignees, companies, operators, patients, searchedPatients, resolvePatientLabel, loadTask, onCreateTask, onUpdateTask, onDeleteTask, onSetTaskDone, onSaved, onDeleted, readOnly, withheld, maskPatient, fallbackError, }: UseTaskEditorFormOptions): {
+    status: TaskEditorStatus;
+    loadError: string | undefined;
+    retry: () => void;
+    fields: TaskEditorFields;
+    patchFields: (next: Partial<TaskEditorFields>) => void;
+    stored: TaskEditorTask | undefined;
+    chosenTypeId: string;
+    canSave: boolean;
+    /** What the agent's `canSave` reports: the button's rule plus the
+     *  status, the seam and a save that has not landed yet. */
+    agentCanSave: boolean;
+    showSave: boolean;
+    showDelete: boolean;
+    showDone: boolean;
+    ui: UiState;
+    patchUi: (next: Partial<UiState>) => void;
+    /** True once a save or delete landed in this session. */
+    isAccepted: () => boolean;
+    /** A save or delete is in flight: closing now would lose its outcome. */
+    isBusy: () => boolean;
+    submit: () => Promise<void>;
+    setDone: (next: boolean) => Promise<void>;
+    remove: () => Promise<void>;
+    applyPatch: (patch: TaskEditorFieldPatch) => void;
+    draftState: () => TaskEditorDraftState;
+};
+export type TaskEditorForm = ReturnType<typeof useTaskEditorForm>;
+export {};
+//# sourceMappingURL=use-task-editor-form.d.ts.map

package/dist/components/task-tray/index.js

@@ -1,4 +1,4 @@
-import { T as s, t } from "../../_chunks/task-tray-DIwjAIes.js";
+import { T as s, t } from "../../_chunks/task-tray-JA-qp_pB.js";
 export {
   s as TaskTray,
   t as taskTrayAgent

package/dist/components/tasks-panel/index.d.ts

@@ -1,4 +1,4 @@
 export { TasksPanel } from './tasks-panel';
-export type { TasksPanelProps, TasksPanelHandle, TasksPanelItem, TasksPanelSize, TasksPanelScope, TasksPanelStatusFilter, } from './tasks-panel';
+export type { TasksPanelProps, TasksPanelHandle, TasksPanelItem, TasksPanelSize, TasksPanelScope, TasksPanelStatusFilter, TasksPanelFiltering, TasksPanelFilters, } from './tasks-panel';
 export { tasksPanelAgent } from './tasks-panel.agent';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/tasks-panel/index.js

@@ -1,4 +1,4 @@
-import { T as e, t } from "../../_chunks/tasks-panel-DncuBPIZ.js";
+import { T as e, t } from "../../_chunks/tasks-panel-C_dVDQKJ.js";
 export {
   e as TasksPanel,
   t as tasksPanelAgent

package/dist/components/tasks-panel/tasks-panel.d.ts

@@ -5,6 +5,15 @@ import { type TaskItem } from '../task-card';
 export type TasksPanelScope = 'patient' | 'mine';
 /** Status segment value. Mirrors the platform `done` filter (default `todo`). */
 export type TasksPanelStatusFilter = 'todo' | 'done' | 'all';
+/** Who filters the list: the panel ('client') or the host ('server'). */
+export type TasksPanelFiltering = 'client' | 'server';
+/** The whole filter state, as `onFiltersChange` reports it. */
+export interface TasksPanelFilters {
+    status: TasksPanelStatusFilter;
+    type: string | null;
+    assignee: string | null;
+    overdueOnly: boolean;
+}
 /**
  * Panel-local extension of the card's `TaskItem`. The extra fields here drive
  * bucketing + filtering; the row's display fields (the typed link via
@@ -20,7 +29,8 @@ export interface TasksPanelItem extends TaskItem {
     type?: string;
     /**
      * Localised type label, required for CUSTOM types (the panel resolves system
-     * keys itself). Falls back to the system label for the four known keys.
+     * keys itself). Falls back to the system label for the four known keys,
+     * then to "Other". The raw key is never shown.
      */
     typeLabel?: string;
     /**
@@ -40,8 +50,15 @@ export interface TasksPanelHandle {
         status: string;
     }>;
     selectItem: (id: string) => void;
-    toggleDone: (id: string) => void;
-    dismiss: (id: string) => void;
+    /**
+     * Same path as a click on the done box. Resolves once the host has
+     * answered (in client mode, after the row's fade) and rejects if the
+     * host refuses, or if nothing was started: an unknown id, a read-only
+     * panel, no `onToggleDone`, or a change to that task already pending.
+     */
+    toggleDone: (id: string) => Promise<void>;
+    /** Same path as the row's dismiss action, and settles in the same way. */
+    dismiss: (id: string) => Promise<void>;
     jumpToOverdue: () => void;
     setFilter: (next: {
         status?: TasksPanelStatusFilter;
@@ -69,21 +86,52 @@ export interface TasksPanelProps extends Omit<HTMLAttributes<HTMLElement>, 'onCl
     nowIso?: string;
     /** Panel heading. Defaults to the localised "Tasks". */
     title?: string;
+    /** PanelHeader glyph. Default <ClipboardCheck />. */
+    icon?: ReactNode;
+    /**
+     * A total the host counted, shown as given after the title ("Tasks (42)")
+     * and read as "42 tasks". Omitted: nothing shown. The panel never
+     * computes it.
+     */
+    totalCount?: number;
     /** Visual density forwarded to each TaskCard. Defaults to `sm`, matching the note and appointment rows. */
     size?: 'xs' | 'sm' | 'md';
+    /**
+     * 'client' (default): the panel filters `items`. 'server': the host has
+     * already filtered and paged `items`; the panel shows them as given. In
+     * server mode a filter control shows only when `onFiltersChange` or its
+     * own `on…Change` is set, since only the host can re-query.
+     */
+    filtering?: TasksPanelFiltering;
     /** Fires when a row is activated. */
     onOpenTask?: (item: TasksPanelItem) => void;
-    /** Fires when the host should toggle a task's done state. */
-    onToggleDone?: (item: TasksPanelItem) => void;
+    /**
+     * Fires when the host should set a task's done state to `nextDone`. In
+     * server mode it fires on the click. In client mode it fires on the click
+     * for a row that stays in view, and once the row has faded for one that
+     * leaves. Either way, the box ignores clicks until a returned promise
+     * settles, and a promise that rejects puts the row back, unticked. The
+     * panel does not announce a refusal: report it yourself (for example
+     * `toastError` with a translated message) and rethrow, so the row still
+     * rolls back.
+     */
+    onToggleDone?: (item: TasksPanelItem, nextDone: boolean) => void | Promise<void>;
     /** Fires when the host should open the task editor. Omit to hide the per-row edit action. */
     onEditTask?: (item: TasksPanelItem) => void;
-    /** Fires when the host should dismiss / remove a task. Omit to hide the per-row dismiss action. */
-    onDismissTask?: (item: TasksPanelItem) => void;
+    /**
+     * Fires when the host should dismiss / remove a task. Omit to hide the
+     * per-row dismiss action. In server mode it fires on the click, in client
+     * mode once the row has faded. A returned promise that rejects restores
+     * the row. The panel does not announce a refusal: report it yourself and
+     * rethrow, as for `onToggleDone`.
+     */
+    onDismissTask?: (item: TasksPanelItem) => void | Promise<void>;
     /** Fires when the header "Add" affordance is activated. Omit to hide it. */
     onAddTask?: () => void;
     /**
      * Read-only mode — hides every write affordance (toggle / edit / dismiss /
-     * add). Mirrors the platform gating writes behind `practice_task_edit`.
+     * add), and the handle's `toggleDone` and `dismiss` reject without calling
+     * the host. Mirrors the platform gating writes behind `practice_task_edit`.
      */
     readOnly?: boolean;
     /**
@@ -92,6 +140,13 @@ export interface TasksPanelProps extends Omit<HTMLAttributes<HTMLElement>, 'onCl
      * is always prepended by the panel). Ignored when `readOnly`.
      */
     renderItemActions?: (item: TasksPanelItem) => ReactNode;
+    /**
+     * Extra per-row actions, rendered before the toggle / edit / dismiss
+     * actions (or before `renderItemActions`, which still replaces those).
+     * Not a task write, so `readOnly` does not hide them: withhold them from
+     * the host side when they do not apply.
+     */
+    renderItemExtraActions?: (item: TasksPanelItem) => ReactNode;
     /** Controlled scope segment. */
     scope?: TasksPanelScope;
     /** Uncontrolled initial scope. Default `'patient'` when both scopes are available, else the only one. */
@@ -100,18 +155,35 @@ export interface TasksPanelProps extends Omit<HTMLAttributes<HTMLElement>, 'onCl
     onScopeChange?: (next: TasksPanelScope) => void;
     /** Which scopes the segment offers. Omit ⇒ no scope segment (single-scope panel). */
     availableScopes?: TasksPanelScope[];
-    /** Load the next page — fired when the bottom edge is reached and via the footer button. */
+    /** Load the next page — fired once per page when the bottom edge is reached, and via the footer button. */
     onLoadMore?: () => void;
-    /** Whether more tasks exist. Defaults to `true` when `onLoadMore` is set. */
+    /** Whether more tasks exist. Defaults to `true` when `onLoadMore` is set (client mode only; server mode needs `true`). */
     hasMore?: boolean;
     /** Show the bottom loading row while the next page is fetched. */
     loadingMore?: boolean;
-    /** Full-panel initial loading state (skeleton rows in the body). */
+    /** Loading state. Skeleton rows while there are none to show; in server mode, rows already shown stay. */
     loading?: boolean;
     /** Error surface — `true` for the default error EmptyState, or a custom node. */
     error?: boolean | ReactNode;
-    /** Show the filter header (status segment + type / assignee selects + overdue toggle). Default `true`. */
+    /** Adds a Retry action to the default error state (`error === true`). */
+    onRetry?: () => void;
+    /**
+     * Show the filter header (status segment + type / assignee selects +
+     * overdue toggle). Default `true`. In server mode each control also needs
+     * `onFiltersChange` or its own `on…Change`.
+     */
     showFilters?: boolean;
+    /**
+     * The host's default query: the uncontrolled start, what Clear filters
+     * returns to, and what server mode judges "filtered empty" against.
+     * Absent: To do, any type, anyone, not overdue-only.
+     */
+    defaultFilters?: TasksPanelFilters;
+    /**
+     * Once per user action, with the whole next filter state. Never fires
+     * when nothing changed. Fires in both modes.
+     */
+    onFiltersChange?: (next: TasksPanelFilters) => void;
     /** Controlled status segment. */
     statusFilter?: TasksPanelStatusFilter;
     /** Uncontrolled initial status segment. Default `'todo'` (the platform default). */

package/dist/components/theme-toggle/index.js

@@ -1,4 +1,4 @@
-import { T as o, t } from "../../_chunks/theme-toggle-BP0XRGMM.js";
+import { T as o, t } from "../../_chunks/theme-toggle-LUBxlNDm.js";
 export {
   o as ThemeToggle,
   t as themeToggleAgent

package/dist/components/toast/index.js

@@ -1,4 +1,4 @@
-import { T as s, t as o, a as r, b as e, c as n, d as c } from "../../_chunks/toast-ZZfhA5u0.js";
+import { T as s, t as o, a as r, b as e, c as n, d as c } from "../../_chunks/toast-CT8hjr9r.js";
 import { t as g } from "../../_chunks/toast.agent-DNQ0JYGv.js";
 export {
   s as Toaster,

package/dist/components/token-insert-menu/index.js

@@ -1,4 +1,4 @@
-import { T as t, t as o } from "../../_chunks/token-insert-menu-A9B5AJw6.js";
+import { T as t, t as o } from "../../_chunks/token-insert-menu-klwbxVKh.js";
 export {
   t as TokenInsertMenu,
   o as tokenInsertMenuAgent

package/dist/components/tool-rail/index.js

@@ -1,4 +1,4 @@
-import { T as l, t } from "../../_chunks/tool-rail-CCFqDfAn.js";
+import { T as l, t } from "../../_chunks/tool-rail-DEeX4PdN.js";
 export {
   l as ToolRail,
   t as toolRailAgent

package/dist/components/tooth-scheme/index.js

@@ -1,4 +1,4 @@
-import { T as s, t, r as e } from "../../_chunks/tooth-scheme-DPAq0vQK.js";
+import { T as s, t, r as e } from "../../_chunks/tooth-scheme-BkjhkI8g.js";
 import { C as i, a as T, b as S, c as l, d as r, e as I, F as O, f as N, g as _, h as c, I as E, P as C, i as A, S as m, j as L, k as d, l as h, m as D, n as F, T as y, o as P, p as b, q as R, r as U, s as p, t as M, u, v as K, w as f, x as B, y as Y, z as H, A as g, B as z, D as w, E as x, G as V, H as k, J as G, K as j, L as q, M as v, N as J, O as Q, Q as W, R as X, U as Z, V as $, W as aa, X as oa, Y as sa, Z as ta, _ as ea, $ as na } from "../../_chunks/tooth-data-DR8Kdnup.js";
 export {
   i as CONDITION_COLORS,

package/dist/components/treatment-receipt/index.js

@@ -1,4 +1,4 @@
-import { T as r } from "../../_chunks/treatment-receipt-DU0OewqH.js";
+import { T as r } from "../../_chunks/treatment-receipt-C-gWZ6uv.js";
 import { t as m } from "../../_chunks/treatment-receipt.agent-bpFm2RPH.js";
 export {
   r as TreatmentReceipt,

package/dist/components/unit-converter/index.js

@@ -1,4 +1,4 @@
-import { C as r, U as t, a as U, b as e, c as n } from "../../_chunks/unit-converter-C-LpGzrN.js";
+import { C as r, U as t, a as U, b as e, c as n } from "../../_chunks/unit-converter-Dp_KDxE6.js";
 export {
   r as CATEGORIES,
   t as UNITS,

package/dist/components/variables-menu/index.js

@@ -1,4 +1,4 @@
-import { V as r, v as s } from "../../_chunks/variables-menu-vXUaSBj4.js";
+import { V as r, v as s } from "../../_chunks/variables-menu-aJLKJ_cu.js";
 export {
   r as VariablesMenu,
   s as variablesMenuAgent

package/dist/components/warning-stack/index.js

@@ -1,4 +1,4 @@
-import { W as n } from "../../_chunks/warning-stack-C0glSB7p.js";
+import { W as n } from "../../_chunks/warning-stack-CEgYkI1z.js";
 export {
   n as WarningStack
 };

package/dist/components/widget-picker/index.js

@@ -1,4 +1,4 @@
-import { W as r, w as t } from "../../_chunks/widget-picker-B1sj6uyf.js";
+import { W as r, w as t } from "../../_chunks/widget-picker-CilQvcNL.js";
 export {
   r as WidgetPicker,
   t as widgetPickerAgent

package/dist/components/workflow/index.js

@@ -1,4 +1,4 @@
-import { C as r, W as e, a as s, b as d, c as w, i as t, l as f, m as l, r as i, w as k, d as n, e as A, f as C } from "../../_chunks/workflow-map-DhR_h5yw.js";
+import { C as r, W as e, a as s, b as d, c as w, i as t, l as f, m as l, r as i, w as k, d as n, e as A, f as C } from "../../_chunks/workflow-map-qGkQTNvS.js";
 export {
   r as CORE_PATIENT_FIELDS,
   e as WorkflowCard,