@alfadocs/ui-kit 1.2.0 → 1.3.0

package/dist/patterns/_shared/target-tile.d.ts

@@ -0,0 +1,31 @@
+import type { ReactNode } from 'react';
+/** Where the patient stands against one target. */
+export type TargetStatus = 'onTarget' | 'approaching' | 'offTarget';
+/** Traffic light → semantic Badge variant. green / amber / red map to the
+ * kit's success / warning / error tokens (each carries its own -foreground
+ * pairing, so the chip stays legible in all four themes). */
+export declare const TARGET_STATUS_VARIANT: Record<TargetStatus, 'success' | 'warning' | 'error'>;
+export interface TargetTileProps {
+    /** `outlined` (default) for hosts already inside a Card; `elevated`
+     * mirrors the kit Card's elevated recipe for tiles that read as cards. */
+    variant?: 'outlined' | 'elevated';
+    /** Metric name, e.g. "Target weight". Also the group's accessible name. */
+    label: string;
+    /** The TARGET, formatted with its unit — the tile's headline figure. */
+    target: string;
+    /** The patient's current value, already phrased ("Now 74.5 kg"). */
+    now: string;
+    /** Omit (or `null`) when no target is set — the tile then shows no chip. */
+    status?: TargetStatus | null;
+    /** Translated status text. Required whenever `status` is set: the traffic
+     * light is colour PLUS text, never colour alone (WCAG 1.4.1). */
+    statusLabel?: string;
+    /** Trailing affordance on the status row — e.g. an edit control. */
+    action?: ReactNode;
+    /** Extra body under the `now` line — e.g. a banded gauge for the current
+     * value. Kept adjacent to `now` so it reads as an elaboration of the
+     * measured figure, never of the headline target. */
+    children?: ReactNode;
+}
+export declare function TargetTile({ variant, label, target, now, status, statusLabel, action, children, }: TargetTileProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=target-tile.d.ts.map

package/dist/patterns/anamnesis/anamnesis-catalogue.d.ts

@@ -0,0 +1,23 @@
+import type { IntakeSectionDef, LabParameterDefinition, NumericParameterDef, PathologyCode } from './anamnesis-types';
+export declare const ANTHRO_PARAMETERS: NumericParameterDef[];
+export declare const LAB_PARAMETERS: LabParameterDefinition[];
+export declare const DIETARY_PARAMETERS: NumericParameterDef[];
+/** Every numeric parameter, in evolution-grid row order (anthropometrics,
+ * dietary intake, then labs). Callers can slice this to build a smaller grid.
+ * Intake sits beside the anthropometrics it explains, and above the bloods
+ * that are only drawn once or twice a year. */
+export declare const ALL_NUMERIC_PARAMETERS: NumericParameterDef[];
+/** Fast lookup by key. */
+export declare const PARAMETER_BY_KEY: Record<string, NumericParameterDef>;
+export declare const PATHOLOGY_TAXONOMY: PathologyCode[];
+export declare const PATHOLOGY_BY_CODE: Record<string, PathologyCode>;
+/** i18next uses '.' as its key separator, so a pathology code like `E66.0`
+ * must be sanitised before it can be used as an i18n key segment. */
+export declare const pathologyLabelKey: (code: string) => string;
+/** Only the leaf/assignable codes (a parent family with sub-codes is a
+ * heading, not itself assignable). Parents without sub-codes stay assignable. */
+export declare const ASSIGNABLE_PATHOLOGY_CODES: string[];
+export declare const INTAKE_SECTIONS: IntakeSectionDef[];
+/** Flat list of every intake field key (in registry order). */
+export declare const INTAKE_FIELD_KEYS: string[];
+//# sourceMappingURL=anamnesis-catalogue.d.ts.map

package/dist/patterns/anamnesis/anamnesis-compare-panel.d.ts

@@ -0,0 +1,82 @@
+import type { TFunction } from 'i18next';
+import type { SparklineAnnotation } from '../../components/sparkline';
+import { type DeltaInfo, type SpanDiff } from './anamnesis-derive';
+import type { NumericParameterDef, PathologyCode, Visit } from './anamnesis-types';
+import type { VisitColumn } from './anamnesis-window';
+/** The one grammar every category speaks. */
+export type CompareChangeKind = 'added' | 'removed' | 'changed';
+/** One line of the compare table. Every field is already display-ready, so
+ * the renderer below never reaches back into the domain model. */
+export interface CompareRow {
+    /** Stable row id — `<category>:<subject>`. */
+    id: string;
+    /** Owning category's id (see `COMPARE_CATEGORIES`). */
+    categoryId: string;
+    /** What changed, in the clinician's words. */
+    item: string;
+    /** Second line under `item` — the unit and reference range, where there is
+     * one. Numeric rows only; the grid puts the same thing in the same place. */
+    meta?: string;
+    change: CompareChangeKind;
+    /** Translated change word — what the Change cell says when there is no
+     * number to say it with. */
+    changeLabel: string;
+    /** One display string per compared visit, in the diff's (record) order. */
+    values: string[];
+    /** Numeric rows only: the FULL-RECORD series, so the sparkline here is the
+     * same line as the grid's — not a shorter one drawn from the picked visits,
+     * which would move every event annotation. */
+    series?: (number | null)[];
+    /** Numeric rows only: the net first→last change, direction-aware. */
+    delta?: DeltaInfo | null;
+    /** Numeric rows only: needed to colour the delta by valence. */
+    def?: NumericParameterDef;
+}
+export interface CompareRowContext {
+    t: TFunction;
+    pathologies: Record<string, PathologyCode>;
+    /** Full-record sparkline series by parameter key. */
+    seriesByKey: ReadonlyMap<string, (number | null)[]>;
+}
+export interface CompareCategoryDef {
+    /** Stable id; also the i18n leaf under `anamnesis.compare.category.*`. */
+    id: string;
+    /** Pull this category's rows out of one span diff. */
+    rows: (diff: SpanDiff, ctx: CompareRowContext) => CompareRow[];
+}
+/** One entry per `SpanDiff` array, in reading order. A future symptom or
+ * event diff is ADDED here — the grammar, the columns and the renderer below
+ * stay untouched. Adding a category is data, never a rewrite. */
+export declare const COMPARE_CATEGORIES: readonly CompareCategoryDef[];
+/** Every difference across the compared visits as one flat, ordered list.
+ * Category order is the registry's order; within a category, the diff's own
+ * order. Nothing is sorted here — the record's order is the reading order. */
+export declare function buildCompareRows(diff: SpanDiff, ctx: CompareRowContext): CompareRow[];
+export interface AnamnesisComparePanelProps {
+    /** The record's visits, in record order — the picker's options. */
+    visits: Visit[];
+    /** The compared columns, resolved in RECORD order (never tick order). */
+    columns: readonly VisitColumn[];
+    /** Currently compared visit ids. */
+    selectedIds: readonly string[];
+    onSelectionChange: (ids: string[]) => void;
+    /** The computed diff, or `null` when fewer than two visits are compared. */
+    diff: SpanDiff | null;
+    /** Full-record sparkline series by parameter key. */
+    seriesByKey: ReadonlyMap<string, (number | null)[]>;
+    pathologies: Record<string, PathologyCode>;
+    /** The event lines drawn on the grid, so they are drawn here too. */
+    annotations?: readonly SparklineAnnotation[];
+    /** Make those lines pointer-selectable, exactly as they are on the grid.
+     * The event bar above the grid stays the keyboard route for both. */
+    onSelectAnnotation?: (eventId: string) => void;
+    t: TFunction;
+    /** Exit compare mode from inside the panel. The toggle that opened it is a
+     * full grid above, so without this the only way out is off-screen. */
+    onClose?: () => void;
+}
+/** Slot 4's contents: a header carrying the way out, the visit picker, then
+ * one matrix of differences. The enclosing `Collapsible` lives in
+ * `anamnesis-evolution.tsx`. */
+export declare function AnamnesisComparePanel({ visits, columns, selectedIds, onSelectionChange, diff, seriesByKey, pathologies, annotations, onSelectAnnotation, t, onClose, }: AnamnesisComparePanelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=anamnesis-compare-panel.d.ts.map

package/dist/patterns/anamnesis/anamnesis-compile-blocks.d.ts

@@ -0,0 +1,46 @@
+import type { NumericParameterDef, Visit } from './anamnesis-types';
+/** Open on arrival: the blocks a clinician records at — or must recall at —
+ * EVERY consultation. Visit details and anthropometrics are recorded each
+ * time; an unanswered required question is this visit's to-do list; the
+ * pathology list and the current therapy are the "what does this patient carry
+ * / already take" memory aids, and proposing a supplement without seeing the
+ * current medication is exactly the recall failure this surface prevents.
+ * The questionnaire itself is read on the Summary tab, not here. */
+export declare const EVERY_VISIT_BLOCKS: readonly ["visitMeta", "intakeGaps", "anthropometrics", "pathologies", "therapy", "proposal"];
+/** Folded on arrival at a FOLLOW-UP: reference or occasional. Oncological
+ * history is blank for most patients; bloods are drawn a few times a year;
+ * fasting cycles and the annual programme are yearly. Each keeps a fill
+ * summary in its header, so folding hides the detail and never the existence
+ * of a record. A first visit opens all of them — see `compileBlockDensity`. */
+export declare const OCCASIONAL_BLOCKS: readonly ["oncological", "labs", "fmd", "annual"];
+export type EveryVisitBlockId = (typeof EVERY_VISIT_BLOCKS)[number];
+export type OccasionalBlockId = (typeof OCCASIONAL_BLOCKS)[number];
+/** One titled block of the compile form whose arrival state this module
+ * decides. Adding an id to this union without listing it in one of the two
+ * arrays above is a type error. It does NOT catch a `<Block>` rendered in the
+ * JSX with no id at all — that block simply keeps the shell's own default. */
+export type CompileBlockId = EveryVisitBlockId | OccasionalBlockId;
+export interface CompileBlockDensity {
+    /** Open on arrival. */
+    open: boolean;
+    /** How much this block already holds, for the header summary. `null` on the
+     * always-open blocks, where a count beside visible content is noise. */
+    fill: number | null;
+    /** Of that fill, how many values sit outside their reference range. Named in
+     * the header so a folded block can never hide a flagged result. */
+    flagged: number;
+}
+/** How each compile block opens for the visit being recorded.
+ *
+ * A FIRST visit opens everything: there is no history to fold away, and an
+ * empty block on a first consultation means "to be filled", not "nothing to
+ * see". A follow-up folds the occasional blocks behind their fill summary.
+ *
+ * `labDefs` is the practice's live lab vocabulary — the same list the Blood
+ * tests block renders. Pass it, or the lab fill and flag counts describe a
+ * different set of values from the one the opened block shows.
+ *
+ * Safe on a record with no visit — everything falls back to the arrival
+ * default with no fill. */
+export declare function compileBlockDensity(visit: Visit | undefined, labDefs?: readonly NumericParameterDef[]): Record<CompileBlockId, CompileBlockDensity>;
+//# sourceMappingURL=anamnesis-compile-blocks.d.ts.map

package/dist/patterns/anamnesis/anamnesis-compile.d.ts

@@ -0,0 +1,48 @@
+import { type ReactNode } from 'react';
+import type { TFunction } from 'i18next';
+import { type PracticeAnamnesisConfig } from './anamnesis-config';
+import type { DisclosureAudience } from './anamnesis-disclosure';
+import type { AnamnesisExportTab } from './anamnesis-export';
+import type { AnamnesisRecord, OpenAnamnesisNote } from './anamnesis-types';
+/** The three Diagnosis views. Also the three export tabs — one vocabulary. */
+export type AnamnesisCompileView = AnamnesisExportTab;
+export interface AnamnesisCompileProps {
+    record: AnamnesisRecord;
+    t: TFunction;
+    /** Mount flush inside a host section tab (drops the full-page chrome + the
+     * patient-name page heading — the host shows the patient banner). */
+    embedded?: boolean;
+    /** The practice's configured vocabulary. Omitted = the kit-seeded default. */
+    config?: PracticeAnamnesisConfig;
+    /** A per-patient target was set or cleared (`null` clears it). The surface
+     * applies it to its own working record either way; this is the seam a
+     * platform host persists through — and the one place a shared target could
+     * be reconciled with the care plan, which no story can do. */
+    onTargetChange?: (parameterKey: string, target: number | null) => void;
+    /** Host status chips rendered at the surface header's end — the slot a
+     * platform host uses to fold its OWN record state (signature status,
+     * expiry, save feedback, a renew affordance) into the section instead of
+     * bolting a second bar above it. Content is host-owned and already
+     * translated. The surface itself claims no save state. */
+    statusSlot?: ReactNode;
+    /** Omit the nutrition-targets strip above the record card — for hosts
+     * that present the record without the goals (the isolated single-section
+     * demo). Default false: the strip renders. Target editors inside the
+     * record blocks are unaffected. */
+    hideTargetStrip?: boolean;
+    /** The host's side panel, forwarded to the Evolution view. Omitted = the
+     * evolution surface reads notes in place. */
+    onOpenNote?: OpenAnamnesisNote;
+    /** Mount on this view instead of Summary. Demo/story hook only — Chromatic
+     * skips play functions, so a click-selected tab is never snapshotted. */
+    defaultView?: AnamnesisCompileView;
+    /** Mount with the export menu open. Demo/story hook only — Chromatic skips
+     * play functions, so a click-opened menu is never snapshotted. */
+    defaultExportMenuOpen?: boolean;
+    /** Mount with the share preview open. Demo/story hook, same reason. */
+    defaultShareOpen?: boolean;
+    /** Mount the export control on this audience. Demo/story hook. */
+    defaultExportAudience?: DisclosureAudience;
+}
+export declare function AnamnesisCompile({ record: initial, t, embedded, config, onTargetChange, hideTargetStrip, statusSlot, onOpenNote, defaultView, defaultExportMenuOpen, defaultShareOpen, defaultExportAudience, }: AnamnesisCompileProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=anamnesis-compile.d.ts.map

package/dist/patterns/anamnesis/anamnesis-config-editor.d.ts

@@ -0,0 +1,26 @@
+import type { TFunction } from 'i18next';
+import { type PracticeAnamnesisConfig } from './anamnesis-config';
+export interface AnamnesisConfigEditorProps {
+    /** The practice's vocabulary — materialised (every list present). Build the
+     * initial value with `seededConfigDraft()`, never from the module constants
+     * directly: the editor patches lists immutably, but a shared array identity
+     * with the kit seed would leak one accidental in-place edit into every
+     * other mount in the session. */
+    config: Required<PracticeAnamnesisConfig>;
+    onConfigChange: (next: Required<PracticeAnamnesisConfig>) => void;
+    t: TFunction;
+    /** Override the cascade / test marker (defaults to `anamnesis-config-editor`). */
+    dataComponent?: string;
+}
+/** A per-entry deep-enough clone of the kit seed: sections own their `fields`
+ * arrays and parameters their `referenceRange` objects, so no array or object
+ * identity is shared with the module constants. */
+export declare function seededConfigDraft(): Required<PracticeAnamnesisConfig>;
+/** Derive an immutable camelCase key from a practice label — the practice
+ * never types identifiers, and a labelled entry can never render as a raw
+ * key. Uniquified with a numeric suffix on collision. Practice-derived keys
+ * are practice-LOCAL: they do not join any shared cross-practice vocabulary
+ * (the curated-library question — decision 0.3 — is still open). */
+export declare function keyFromLabel(label: string, taken: ReadonlySet<string>): string;
+export declare function AnamnesisConfigEditor({ config, onConfigChange, t, dataComponent, }: AnamnesisConfigEditorProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=anamnesis-config-editor.d.ts.map

package/dist/patterns/anamnesis/anamnesis-config.d.ts

@@ -0,0 +1,62 @@
+import type { IntakeFieldDef, IntakeSectionDef, NumericParameterDef, ParameterGroup, PathologyCode } from './anamnesis-types';
+/** The only keys the derivation engine cannot lose. `bmi` is computed from
+ * `weight` + `height`; every other key in the kit is read generically. */
+export declare const LOCKED_PARAMETER_KEYS: ReadonlySet<string>;
+/** Whether a numeric parameter is locked against archiving / deletion. */
+export declare function isParameterLocked(key: string): boolean;
+/** Parameters a plan sets a per-patient GOAL for. Not every number is one: a
+ * height is a fact about the patient, and a blood test carries a population
+ * reference range rather than a target. The four the nutrition plan is written
+ * in — weight, BMI, daily energy, protein — plus waist, which practices have
+ * long set a goal for. */
+export declare const TARGETABLE_PARAMETER_KEYS: ReadonlySet<string>;
+/** Whether a per-patient target can be set for this parameter. */
+export declare function isParameterTargetable(key: string): boolean;
+/** A practice's anamnesis vocabulary. Every list is optional: an omitted list
+ * falls back to the kit-seeded catalogue, so `undefined` is a fully working
+ * configuration and every existing mount keeps rendering unchanged. */
+export interface PracticeAnamnesisConfig {
+    /** Numeric parameters (anthropometrics + labs), in the practice's order. */
+    parameters?: readonly NumericParameterDef[];
+    /** The intake questionnaire — the practice's own form, transcribed. */
+    intakeSections?: readonly IntakeSectionDef[];
+    /** The coded pathology taxonomy. */
+    pathologies?: readonly PathologyCode[];
+}
+/** What the kit ships when a practice has configured nothing. Seeded, not
+ * empty — an empty vocabulary renders an empty record. */
+export declare const SEEDED_ANAMNESIS_CONFIG: Required<PracticeAnamnesisConfig>;
+/** Fill every omitted list from the seed. */
+export declare function resolveConfig(config?: PracticeAnamnesisConfig): Required<PracticeAnamnesisConfig>;
+/** CAPTURE surfaces: live parameters only. A locked parameter is never
+ * dropped, whatever the config says — archiving `weight` would silently break
+ * BMI everywhere. */
+export declare function configuredParameters(config?: PracticeAnamnesisConfig, group?: ParameterGroup): NumericParameterDef[];
+/** HISTORY surfaces: every parameter, archived ones included, so a value
+ * recorded under an archived parameter still renders. */
+export declare function allParametersIncludingArchived(config?: PracticeAnamnesisConfig, group?: ParameterGroup): NumericParameterDef[];
+/** Lookup over every parameter, archived included — callers resolving a key
+ * read from a record must never miss an archived one. */
+export declare function parameterLookup(config?: PracticeAnamnesisConfig): Record<string, NumericParameterDef>;
+/** CAPTURE: the questionnaire as the patient sees it — archived sections and
+ * fields dropped, and a section left with no live field dropped with them. */
+export declare function configuredSections(config?: PracticeAnamnesisConfig): IntakeSectionDef[];
+/** HISTORY: every section and field ever configured, so answers recorded under
+ * a since-archived question still render in the record and the read-only view.
+ * Using `configuredSections` here would erase them from the screen. */
+export declare function allSectionsIncludingArchived(config?: PracticeAnamnesisConfig): IntakeSectionDef[];
+/** Flat field lookup across every section, archived included. */
+export declare function intakeFieldLookup(config?: PracticeAnamnesisConfig): Record<string, IntakeFieldDef>;
+/** CAPTURE: live codes, in configured order. */
+export declare function configuredPathologies(config?: PracticeAnamnesisConfig): PathologyCode[];
+/** HISTORY: every code, archived included. A code assigned last year must
+ * still render its label this year. */
+export declare function allPathologiesIncludingArchived(config?: PracticeAnamnesisConfig): PathologyCode[];
+/** Lookup by code over the FULL taxonomy. Without this, reading
+ * `entry.parentCode` off a practice-added code throws. */
+export declare function pathologyLookup(config?: PracticeAnamnesisConfig): Record<string, PathologyCode>;
+/** Assignable codes: a family that carries sub-codes is a heading, not itself
+ * assignable. Derived from the LIVE taxonomy so an archived code cannot be
+ * newly assigned, but stays resolvable for history. */
+export declare function assignablePathologyCodes(config?: PracticeAnamnesisConfig): string[];
+//# sourceMappingURL=anamnesis-config.d.ts.map

package/dist/patterns/anamnesis/anamnesis-derive.d.ts

@@ -0,0 +1,194 @@
+import type { AnamnesisRecord, MedicationEntry, NumericParameterDef, Visit } from './anamnesis-types';
+/** Anthropometric parameter keys map to AnthropometricSet fields; `bmi` is
+ * computed. Kept as a lookup so the grid can treat anthropometrics + labs
+ * uniformly. */
+export declare const ANTHRO_FIELD_BY_KEY: Record<string, keyof Visit['anthropometrics']>;
+/** `Timestamp` options for the record's calendar dates (visit date, date of
+ * birth, cycle start). Every one of them is a date-only ISO string, which
+ * `Date` parses as UTC midnight — rendered with the viewer's zone that shows a
+ * phantom time ("13 Apr 2026, 2:00" in CEST) and, west of UTC, the WRONG DAY.
+ * Dropping the time fields and pinning the zone to UTC makes the calendar date
+ * render as written, identically in every timezone (and so deterministically
+ * in Chromatic). */
+export declare const CALENDAR_DATE_FORMAT: Intl.DateTimeFormatOptions;
+/** BMI = kg / m². Thin `undefined`-tolerant wrapper over the kit's canonical
+ * BMI maths — the anthropometric set leaves unmeasured fields `undefined`,
+ * which `bmi-calculator/bmi` (a form-backed component) does not model. The
+ * formula itself lives there and is not restated here. */
+export declare function computeBmi(weightKg: number | null | undefined, heightCm: number | null | undefined): number | null;
+/** Whether a stored ISO string is a date `Date` can actually read. An archive
+ * holds blanks and typos; nothing downstream may throw or print "NaN" on one. */
+export declare function isReadableDate(iso: string | null | undefined): boolean;
+/** Whole-years age at a reference instant, or `null` when either date is
+ * unreadable OR the reference predates the birth — an unknown age is absent,
+ * never `NaN` and never negative. Reference is the record's
+ * own visit date (deterministic for stories / Chromatic), not the wall clock.
+ * Read in UTC because both inputs are date-only strings, which `Date` parses as
+ * UTC midnight: local getters return the previous day west of UTC. */
+export declare function ageAt(dobIso: string, referenceIso: string): number | null;
+/** Where a parameter's value actually lives on a `Visit`. */
+export type ParameterStorage = 'computed' | 'anthropometric' | 'dietary' | 'lab';
+/** Keys stored in `visit.dietaryIntake`. Explicit, like `ANTHRO_FIELD_BY_KEY`:
+ * the kit's two shipped intake parameters have a drawer of their own, and
+ * anything else a practice adds falls through to the open-ended one below. */
+export declare const DIETARY_STORAGE_KEYS: ReadonlySet<string>;
+/** Resolve a parameter's STORAGE HOME. Read and write branch on this, never on
+ * `def.group`: `AnthropometricSet` is a fixed shape, so a practice-added
+ * anthropometric has no field of its own and must round-trip through the
+ * open-ended `labs` array. Branching on `group` made it read null and store
+ * nothing. `bmi` keeps its explicit guard — `def.computed` is a bare boolean
+ * with no formula registry to dispatch on.
+ *
+ * `labs` stays the FALLBACK, so a key with no drawer of its own still stores
+ * and reads back. There is no such thing as a parameter with no storage home. */
+export declare function parameterStorage(def: NumericParameterDef): ParameterStorage;
+/** The raw numeric value of a parameter at a visit (BMI computed on the fly,
+ * the six shipped anthropometrics read from the set, everything else looked up
+ * in `labs` by key). Non-finite stored values read as absent. */
+export declare function parameterValueAt(visit: Visit, def: NumericParameterDef): number | null;
+/** Write a numeric value onto a visit at its storage home, returning a new
+ * visit. Computed parameters are never written. Pure — the surfaces call it
+ * through their own working-state setters. */
+export declare function setNumericOnVisit(visit: Visit, def: NumericParameterDef, value: number | null): Visit;
+/** Set or clear a per-patient target, returning a new record. `null` clears
+ * it. Pure — the surfaces call it through their own working-state setters,
+ * exactly as they call `setNumericOnVisit`. A non-finite target is not a goal
+ * and clears rather than storing "NaN". */
+export declare function setTargetOnRecord(record: AnamnesisRecord, parameterKey: string, target: number | null): AnamnesisRecord;
+export type RangeFlag = 'low' | 'high' | null;
+/** Whether a value sits outside its reference range. */
+export declare function outOfRange(value: number | null, range: NumericParameterDef['referenceRange']): RangeFlag;
+export type DeltaDirection = 'up' | 'down' | 'flat';
+export type DeltaValence = 'good' | 'bad' | 'neutral';
+export interface DeltaInfo {
+    /** Signed change vs the previous visit (current − previous). */
+    abs: number;
+    direction: DeltaDirection;
+    valence: DeltaValence;
+}
+/** Direction-aware good/bad. Uses the parameter's `betterDirection` and, for
+ * `toRange`, the reference range — never the sign of the delta alone. */
+export declare function deltaInfo(current: number | null, previous: number | null, def: NumericParameterDef): DeltaInfo | null;
+export interface ParameterCell {
+    visitId: string;
+    value: number | null;
+    outOfRange: RangeFlag;
+    /** Change vs the immediately preceding visit; null for the first column. */
+    delta: DeltaInfo | null;
+}
+export interface ParameterRow {
+    def: NumericParameterDef;
+    /** One cell per record visit, aligned to `record.visits` order. */
+    cells: ParameterCell[];
+    /** ONE ENTRY PER RECORD VISIT, in visit order — the sparkline series. A
+     * `null` is a visit where this parameter was not measured, and it holds its
+     * place: dropping it would compress a four-times-measured lab across the
+     * same width as a thirteen-times-measured weight, and an event annotation
+     * would then land on a different date in each row. */
+    series: (number | null)[];
+    /** Per-patient target for this parameter, when one is configured. */
+    target: number | null;
+}
+/** Build the transposed grid: one row per parameter definition, one cell per
+ * visit, with derived deltas / out-of-range flags / sparkline series. */
+export declare function buildParameterRows(record: AnamnesisRecord, defs: NumericParameterDef[]): ParameterRow[];
+export interface NumericChange {
+    def: NumericParameterDef;
+    from: number | null;
+    to: number | null;
+    delta: DeltaInfo | null;
+}
+export interface PathologyChange {
+    code: string;
+    change: 'added' | 'removed';
+}
+export interface MedicationChange {
+    entry: MedicationEntry;
+    change: 'added' | 'removed' | 'changed';
+    previous?: MedicationEntry;
+}
+export type TextField = 'nutritionalProposal' | 'clinicalNotes';
+/** The free-text fields a visit carries, in diff order. */
+export declare const TEXT_FIELDS: readonly TextField[];
+export interface TextChange {
+    field: TextField;
+    from?: string;
+    to?: string;
+}
+export interface VisitDiff {
+    from: Visit;
+    to: Visit;
+    numeric: NumericChange[];
+    pathologies: PathologyChange[];
+    medications: MedicationChange[];
+    texts: TextChange[];
+}
+/** Everything that changed between two visits — numeric parameters plus the
+ * non-numeric fields (pathologies added/removed, medications added/removed/
+ * changed, free-text notes edited). Only entries that actually differ are
+ * returned, so compare mode can mark exactly the changed cells. */
+export declare function compareVisits(from: Visit, to: Visit, defs: NumericParameterDef[]): VisitDiff;
+export interface NumericSpanChange {
+    def: NumericParameterDef;
+    /** One entry per compared visit, rounded to the parameter's precision. */
+    values: (number | null)[];
+    /** Net change, first compared visit → last. Null when either end is absent. */
+    delta: DeltaInfo | null;
+}
+export interface PathologySpanChange {
+    code: string;
+    /** Whether the code was assigned at each compared visit. */
+    present: boolean[];
+}
+export interface MedicationSpanChange {
+    id: string;
+    /** The entry at each compared visit; `undefined` where it was not carried. */
+    entries: (MedicationEntry | undefined)[];
+}
+export interface TextSpanChange {
+    field: TextField;
+    /** The field's text at each compared visit, trimmed; '' where absent. */
+    values: string[];
+}
+export interface SpanDiff {
+    /** The compared visits, in the order given (record order). Never below two. */
+    visits: Visit[];
+    numeric: NumericSpanChange[];
+    pathologies: PathologySpanChange[];
+    medications: MedicationSpanChange[];
+    texts: TextSpanChange[];
+}
+/** Everything that is not constant across two or more visits. `null` below
+ * two visits — there is no span to read, and an empty diff would claim there
+ * was nothing to report. */
+export declare function compareVisitSpan(visits: readonly Visit[], defs: NumericParameterDef[]): SpanDiff | null;
+/** The newest visit — the editable one in compile mode, and the record's one
+ * reference instant for anything dated against "now": the patient's age, the
+ * header's visit date. Every surface must read it from here. Intake used to
+ * date itself to `visits[0]` while compile and read-only used the last visit,
+ * which printed two different ages for the same patient. */
+export declare function latestVisit(record: AnamnesisRecord): Visit | undefined;
+/** The one string every absent value renders as. Never a bare hyphen, never a
+ * blank, never "NaN". */
+export declare const ABSENT_VALUE = "\u2014";
+/** Format a numeric value to its parameter precision, or an em dash when
+ * absent. `0` formats as a value; a non-finite number is absent, because
+ * `NaN.toFixed(1)` is the string "NaN" and that must never reach a cell.
+ * Callers append the unit separately. */
+export declare function formatValue(value: number | null, precision?: number): string;
+/** Localised medium date (e.g. "12 May 2025") from an ISO date string.
+ * @deprecated Pins neither timezone nor locale. Use `visitDateLabel`
+ * (anamnesis-format.ts) for anything date-only; it is the reason this has no
+ * callers left. */
+export declare function formatDateMedium(iso: string): string;
+/** Localised calendar date from a date-only ISO string, pinned to UTC through
+ * `CALENDAR_DATE_FORMAT`. Prefer `visitDateLabel` (anamnesis-format.ts), which
+ * resolves `locale` from the surface's `t` — omitting it falls back to the
+ * BROWSER locale, which disagrees with `<Timestamp>` on the same screen.
+ * An unreadable date renders the em dash: `Intl` THROWS on one, which would
+ * take down the whole evolution surface rather than blank one label. */
+export declare function formatCalendarDate(iso: string, locale?: string): string;
+/** Signed, precision-formatted delta string (e.g. "+2.4", "−1.0"). Uses a
+ * real minus sign for the negative case. */
+export declare function formatDelta(abs: number, precision?: number): string;
+//# sourceMappingURL=anamnesis-derive.d.ts.map

package/dist/patterns/anamnesis/anamnesis-digest.d.ts

@@ -0,0 +1,84 @@
+import type { RefObject } from 'react';
+import type { TFunction } from 'i18next';
+import { type AlertAnnounce } from '../../components/alert';
+import type { IntakeAnswer, IntakeSectionDef, PatientSex } from './anamnesis-types';
+/** How one digest group is built. Phase 3 adds a group by adding an entry
+ * here — the renderer switches on `kind` and never on a group id. */
+export type DigestGroupKind = 'prose' | 'facts' | 'flags';
+export type DigestGroupDef = {
+    id: string;
+    kind: 'prose';
+    fieldKeys: readonly string[];
+} | {
+    id: string;
+    kind: 'facts';
+    fieldKeys: readonly string[];
+} | {
+    id: string;
+    kind: 'flags';
+};
+/** Reading order for a clinician with the patient in the room: why they came,
+ * what they already carry, what they report, what they do every day. */
+export declare const DIGEST_GROUPS: readonly DigestGroupDef[];
+/** Reads one answer by field key. Both surfaces hold their answers in a
+ * different shape (a working map vs `Sourced<IntakeAnswer>`), so the digest
+ * takes a reader rather than either shape. */
+export type AnswerReader = (key: string) => IntakeAnswer | undefined;
+export interface DigestItem {
+    key: string;
+    label: string;
+    /** Already display-ready. Absent numerics are an em dash, never "NaN". */
+    value: string;
+}
+export interface DigestGroup {
+    id: string;
+    kind: DigestGroupKind;
+    items: DigestItem[];
+}
+export interface IntakeDigest {
+    /** Only groups that have something to say. */
+    groups: DigestGroup[];
+    answered: number;
+    total: number;
+}
+export interface MissingAnswer {
+    key: string;
+    sectionKey: string;
+    label: string;
+}
+/** The whole digest. Pure apart from `t`; safe on an absent questionnaire, a
+ * half-answered one, and a practice that archived half the form. */
+export declare function buildIntakeDigest(sections: readonly IntakeSectionDef[], read: AnswerReader, sex: PatientSex, t: TFunction): IntakeDigest;
+/** Mandatory questions the patient has not answered, in questionnaire order.
+ * "Not sure" counts as unanswered — provisional, and flagged in the `.mdx`. */
+export declare function missingMandatoryAnswers(sections: readonly IntakeSectionDef[], read: AnswerReader, sex: PatientSex, t: TFunction): MissingAnswer[];
+/** Jump-to-field seam. The caller opens whatever disclosures hide the target
+ * (on compile that is BOTH the section block and the answer review), then asks
+ * for the jump; this waits for the reveal to mount before moving focus. */
+export declare function useFieldJump(): {
+    containerRef: RefObject<HTMLDivElement | null>;
+    requestJump: (key: string) => void;
+};
+export interface AnamnesisMissingAnswersProps {
+    missing: readonly MissingAnswer[];
+    t: TFunction;
+    /** Reveals the first missing answer and moves focus to it. */
+    onJump: (missing: MissingAnswer) => void;
+    /** How loudly this is announced. Pass `'off'` where the list RECOMPUTES as
+     * the user types — a live region re-announces its whole content on every
+     * change, so a per-keystroke summary is noise, not help. Default `'polite'`
+     * suits a list fixed at mount. */
+    announce?: AlertAnnounce;
+    /** Label for the jump action. Override where the jump LEAVES the surface —
+     * a button that changes tab has to say so before it moves focus. */
+    jumpKey?: string;
+}
+/** Guidance, not an interruption. Tint and urgency are independent in the kit,
+ * so the `info` tint here is a visual choice, separate from `announce`. */
+export declare function AnamnesisMissingAnswers({ missing, t, onJump, announce, jumpKey, }: AnamnesisMissingAnswersProps): import("react/jsx-runtime").JSX.Element | null;
+export interface AnamnesisDigestProps {
+    digest: IntakeDigest;
+    t: TFunction;
+}
+export declare function AnamnesisDigest({ digest, t }: AnamnesisDigestProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=anamnesis-digest.d.ts.map

package/dist/patterns/anamnesis/anamnesis-disclosure.d.ts

@@ -0,0 +1,19 @@
+/** Who a concept may be disclosed to. `clinician` is implicit on every row. */
+export type DisclosureAudience = 'clinician' | 'patient' | 'external';
+export interface DisclosureRule {
+    /** Stable concept id — never a UI label, never a data-model field path. */
+    id: string;
+    /** Where the concept is captured or rendered. */
+    surface: 'intake' | 'compile' | 'evolution' | 'readOnly' | 'export';
+    /** Audiences allowed to see it. Always includes 'clinician'. */
+    audiences: readonly DisclosureAudience[];
+    /** One English sentence, for the customer sign-off walkthrough. */
+    rationale: string;
+    /** 'provisional' = our judgement, not the customer's. */
+    status: 'provisional' | 'signedOff';
+}
+export declare const DISCLOSURE_RULES: readonly DisclosureRule[];
+/** The one resolver. Never inline this logic. An unknown id is NOT disclosed —
+ * a concept with no row is a concept nobody has thought about yet. */
+export declare function disclosedTo(id: string, audience: DisclosureAudience): boolean;
+//# sourceMappingURL=anamnesis-disclosure.d.ts.map

package/dist/patterns/anamnesis/anamnesis-event-bar.d.ts

@@ -0,0 +1,12 @@
+import type { TFunction } from 'i18next';
+import { type EventMark } from './anamnesis-events';
+export interface AnamnesisEventBarProps {
+    /** Events that HAVE a position on the plot, in the order they happened.
+     * One with no place on it never reaches here — see `eventMarks`. */
+    marks: readonly EventMark[];
+    activeIds: ReadonlySet<string>;
+    onToggle: (eventId: string) => void;
+    t: TFunction;
+}
+export declare function AnamnesisEventBar({ marks, activeIds, onToggle, t, }: AnamnesisEventBarProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=anamnesis-event-bar.d.ts.map