@leavepulse/ui 0.43.2 → 0.43.4

package/dist/components/LpUptimeBar.vue.d.ts

@@ -0,0 +1,46 @@
+export type UptimeStatus = "operational" | "degraded" | "down" | "maintenance" | "empty";
+export interface UptimeSegment {
+    /** Health of this slice. `empty` renders a faded placeholder (no data). */
+    status: UptimeStatus;
+    /** Optional rich tooltip body; falls back to a humanised status. */
+    label?: string;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    /** Oldest → newest. Each entry is one slice of the timeline. */
+    segments: UptimeSegment[];
+    /** Caption shown under the left edge (oldest point). */
+    startLabel?: string;
+    /** Caption shown under the right edge (newest point). */
+    endLabel?: string;
+    /** Show the computed uptime % above the bar. */
+    showUptime?: boolean;
+    /** Override the headline shown next to the uptime %. */
+    title?: string;
+    /**
+     * Per-status colours. Any CSS colour (hex, rgb, `var(--token)`). Unset
+     * statuses fall back to the theme tokens below. Pass e.g.
+     * `{ degraded: '#ffb84d' }` to recolour just one state.
+     */
+    colors?: Partial<Record<UptimeStatus, string>>;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    /** Oldest → newest. Each entry is one slice of the timeline. */
+    segments: UptimeSegment[];
+    /** Caption shown under the left edge (oldest point). */
+    startLabel?: string;
+    /** Caption shown under the right edge (newest point). */
+    endLabel?: string;
+    /** Show the computed uptime % above the bar. */
+    showUptime?: boolean;
+    /** Override the headline shown next to the uptime %. */
+    title?: string;
+    /**
+     * Per-status colours. Any CSS colour (hex, rgb, `var(--token)`). Unset
+     * statuses fall back to the theme tokens below. Pass e.g.
+     * `{ degraded: '#ffb84d' }` to recolour just one state.
+     */
+    colors?: Partial<Record<UptimeStatus, string>>;
+}> & Readonly<{}>, {
+    showUptime: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/LpWaypointEdge.vue.d.ts

@@ -0,0 +1,33 @@
+/**
+ * An edge that curves THROUGH a list of waypoints.
+ *
+ * The built-in shapes each fail one way in a layered graph: a bezier bulges off
+ * the line between its ends and cuts through whatever stands between the
+ * columns, and orthogonal routing clears the cards but draws the graph as a
+ * grid of right angles. Given the gaps a layout already knows about, a curve
+ * threaded through them is both — clear of the cards and still a curve.
+ *
+ * Waypoints ride on the edge's `data.waypoints`; with none, this is a plain
+ * bezier, so the type is safe to use for every edge in a graph.
+ */
+import { Position } from "@vue-flow/core";
+type __VLS_Props = {
+    id: string;
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+    sourcePosition?: Position;
+    targetPosition?: Position;
+    data?: {
+        waypoints?: {
+            x: number;
+            y: number;
+        }[];
+    };
+    markerEnd?: string;
+    style?: Record<string, unknown>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/actionBar.d.ts

@@ -0,0 +1,19 @@
+export interface BarEntry {
+    id: number;
+    /** Measured height in px, reported by the bar once it is on screen. */
+    height: number;
+}
+/** Gap between stacked bars, matching the padding the bar sits in. */
+export declare const STACK_GAP = 8;
+/**
+ * Registers a bar for as long as the calling scope lives. `setHeight` reports
+ * the measured height; `offset()` returns how far up this bar should sit —
+ * the total height of every bar that opened before it.
+ */
+export declare function useBarStack(): {
+    register: () => void;
+    unregister: () => void;
+    setHeight: (height: number) => void;
+    offset: () => number;
+    bars: import("vue").Ref<BarEntry[] | undefined, BarEntry[] | undefined>;
+};

package/dist/components/address.d.ts

@@ -0,0 +1,107 @@
+export interface LatLon {
+    lat: number;
+    lon: number;
+}
+export interface AddressValue {
+    /** Street and house number, e.g. "Baker Street 221B". */
+    line: string;
+    /** Apartment, suite, floor — only shown when LpAddressInput asks for it. */
+    line2?: string;
+    city: string;
+    postalCode: string;
+    /** ISO 3166-1 alpha-2, uppercase — same shape LpPhoneInput uses. */
+    country: string;
+    /** Set once a point is picked on the map or a suggestion carries one. */
+    lat?: number;
+    lon?: number;
+}
+export declare function emptyAddress(): AddressValue;
+export interface AddressSuggestion {
+    /** Text to put in the field that asked for it. */
+    value: string;
+    label: string;
+    /** Fuller context — the whole formatted address, shown under the label. */
+    description?: string;
+    /** Parsed parts, as much as the provider resolved. */
+    address: Partial<AddressValue>;
+    lat?: number;
+    lon?: number;
+}
+/** Which field is being completed — providers can bias results accordingly. */
+export type AddressField = "line" | "city" | "postalCode";
+export interface GeocodeQuery {
+    /** Restrict to a country (ISO2) when the form already has one. */
+    country?: string;
+    /** Preferred result language, as an Accept-Language value. */
+    language?: string;
+    limit?: number;
+    signal?: AbortSignal;
+}
+export interface GeocodeProvider {
+    search(term: string, field: AddressField, query?: GeocodeQuery): Promise<AddressSuggestion[]>;
+    /** Point → address. Undefined when the point resolves to nothing. */
+    reverse(lat: number, lon: number, query?: GeocodeQuery): Promise<AddressSuggestion | undefined>;
+}
+export interface NominatimOptions {
+    /** Base URL of a Nominatim instance, no trailing slash. */
+    endpoint?: string;
+    language?: string;
+    /**
+     * Public Nominatim asks for an identifying UA and rate-limits hard; browsers
+     * won't let us set User-Agent, so this rides along as `email` instead, which
+     * their usage policy accepts. Point `endpoint` at your own instance for
+     * anything busier than a settings form.
+     */
+    email?: string;
+}
+export declare function createNominatimProvider(options?: NominatimOptions): GeocodeProvider;
+/**
+ * Every user-facing string in LpAddressInput, so an app can translate it
+ * without the kit taking an i18n dependency. Pass a partial — anything absent
+ * keeps the English default.
+ */
+export interface AddressLabels {
+    line: string;
+    linePlaceholder: string;
+    secondLine: string;
+    secondLinePlaceholder: string;
+    city: string;
+    cityPlaceholder: string;
+    postalCode: string;
+    postalCodePlaceholder: string;
+    country: string;
+    countryPlaceholder: string;
+    countrySearch: string;
+    pickOnMap: string;
+    mapTitle: string;
+    mapHint: string;
+    use: string;
+    cancel: string;
+    searching: string;
+    noSuggestions: string;
+    nothingHere: string;
+}
+/** Formats an address the way a shipping label would read. */
+export declare function formatAddress(value: AddressValue, countryName?: string): string;
+export interface TileSource {
+    /** Template with {z}/{x}/{y}, plus optional {s} for a subdomain. */
+    url: string;
+    /** Rendered under the map — most tile terms require crediting the source. */
+    attribution?: string;
+    subdomains?: string[];
+    minZoom?: number;
+    maxZoom?: number;
+    /** Edge length of one tile in CSS pixels. Default 256. */
+    tileSize?: number;
+}
+export declare const OSM_TILES: TileSource;
+export declare function tileUrl(source: TileSource, z: number, x: number, y: number): string;
+export declare const MAX_LATITUDE = 85.05112878;
+export declare function project(lat: number, lon: number, zoom: number, tileSize?: number): {
+    x: number;
+    y: number;
+};
+export declare function unproject(x: number, y: number, zoom: number, tileSize?: number): {
+    lat: number;
+    lon: number;
+};

package/dist/components/chart.d.ts

@@ -0,0 +1,180 @@
+export interface ChartPoint {
+    /** Numeric value. `null` breaks the line — a real gap, not a zero. */
+    y: number | null;
+    /** Optional label for this point; falls back to the shared `labels` prop. */
+    x?: string;
+}
+export interface ChartSeries {
+    name: string;
+    /** Bare numbers are accepted and normalised to points. */
+    data: (number | null | ChartPoint)[];
+    /** Any CSS colour. Unset series cycle through the palette. */
+    color?: string;
+    /** Draw this series as a dashed line (targets, budgets, forecasts). */
+    dashed?: boolean;
+    /**
+     * Which y-axis this series is measured against. A series in different units
+     * or of a wildly different magnitude (errors beside requests, a rate beside a
+     * count) flattens against a shared axis; putting it on `"right"` gives it its
+     * own scale and its own ticks.
+     */
+    axis?: "left" | "right";
+}
+export type ChartAxis = "left" | "right";
+export interface NormalSeries {
+    name: string;
+    color: string;
+    dashed: boolean;
+    axis: ChartAxis;
+    values: (number | null)[];
+}
+export interface Box {
+    width: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+/** Plot area inside the padding — where marks may actually be drawn. */
+export declare const plotWidth: (b: Box) => number;
+export declare const plotHeight: (b: Box) => number;
+/** Series colours cycle through the theme's semantic palette. */
+export declare const CHART_PALETTE: string[];
+export declare const normalise: (series: ChartSeries[]) => NormalSeries[];
+/** Point labels win over the shared axis labels; index is the last resort. */
+export declare const resolveLabels: (series: ChartSeries[], labels: string[] | undefined, count: number) => string[];
+/** Longest series wins; shorter ones simply stop early. */
+export declare const pointCount: (series: NormalSeries[]) => number;
+/**
+ * "Nice" axis bounds: round the extent out to a human step (1/2/5 × 10ⁿ) so
+ * ticks land on readable numbers instead of 0.37, 1.24, 2.11.
+ */
+export declare const niceScale: (min: number, max: number, ticks: number) => {
+    min: number;
+    max: number;
+    step: number;
+};
+export declare const axisTicks: (min: number, max: number, step: number) => number[];
+/** Extent across every visible series, with zero pulled in when asked. */
+export declare const extent: (series: NormalSeries[], includeZero: boolean) => {
+    min: number;
+    max: number;
+};
+/** x pixel for point i. Bars sit at band centres, lines span edge to edge. */
+export declare const xAt: (i: number, count: number, box: Box, banded: boolean) => number;
+export declare const yAt: (v: number, min: number, max: number, box: Box) => number;
+interface Scale {
+    min: number;
+    max: number;
+    box: Box;
+    count: number;
+    banded: boolean;
+}
+export declare const linePath: (values: (number | null)[], s: Scale, smooth: number) => string;
+/** The line closed down to the baseline — one filled shape per unbroken run. */
+export declare const areaPath: (values: (number | null)[], s: Scale, smooth: number) => string;
+/** Nearest point index for a pixel x — what the hover crosshair snaps to. */
+export declare const nearestIndex: (px: number, s: Scale) => number;
+/**
+ * A bar as a path, rounded only on the corners named. A stack is one shape cut
+ * into segments: rounding every segment would bevel the internal joins and read
+ * as separate tiles rather than as one bar, so only the outermost segment of a
+ * stack rounds, and only on the end it actually terminates.
+ *
+ * `r` is clamped to half the box so a short segment degrades to a slab instead
+ * of inverting its own corners.
+ */
+export declare const barPath: (x: number, y: number, w: number, h: number, r: number, round: {
+    top: boolean;
+    bottom: boolean;
+}) => string;
+export interface PieSlice {
+    label: string;
+    value: number;
+    /** Any CSS colour. Unset slices cycle through the palette. */
+    color?: string;
+}
+export interface ResolvedSlice {
+    label: string;
+    value: number;
+    color: string;
+    /** 0–1 of the total. */
+    fraction: number;
+    /** True for the synthesised remainder slice. */
+    isOther: boolean;
+    /** How many input slices this one stands for (1, or N when collapsed). */
+    count: number;
+}
+/**
+ * Fold an arbitrary number of slices down to something a circle can actually
+ * show, WITHOUT dropping data.
+ *
+ * A pie is only legible while its slices are distinguishable by angle; past a
+ * handful they become slivers no one can compare or click. But a shared kit
+ * can't know how many categories a caller has, so refusing to draw twenty is
+ * not an option either. So: keep the largest `max - 1` and sum the rest into a
+ * single "Other" slice that keeps its own total, its own share, and a count of
+ * what it stands for — the tail stays visible and addressable instead of being
+ * silently truncated.
+ *
+ * Negative values are dropped: a share of a whole has no meaning below zero,
+ * and letting one in makes every other slice's fraction wrong.
+ */
+export declare const resolveSlices: (slices: PieSlice[], max: number | undefined, otherLabel: string, 
+/**
+ * Keep the caller's ordering for the slices that survive. Ranking decides
+ * WHICH slices are kept; it needn't decide the order they're shown in, and a
+ * caller that ordered its data deliberately ("Free" last, states worst-first)
+ * would see that shuffled for no reason. "Other" always sorts last.
+ */
+preserveOrder?: boolean) => {
+    slices: ResolvedSlice[];
+    total: number;
+};
+/**
+ * One slice as a path. `inner > 0` makes it a donut segment (an annulus) rather
+ * than a wedge from the centre.
+ *
+ * A slice covering the whole circle is drawn as two half-arcs: a single arc
+ * whose start and end coincide is a zero-length path, so "100% of one category"
+ * would render as nothing at all.
+ */
+export declare const arcPath: (cx: number, cy: number, outer: number, inner: number, startAngle: number, endAngle: number, 
+/** Corner radius in px, clamped to what the slice can actually carry. */
+corner?: number) => string;
+export interface CalloutLabel {
+    index: number;
+    /** Which side of the circle the label sits on. */
+    side: "left" | "right";
+    /** Elbow polyline: leader out of the slice, a bend, then a run to the text. */
+    points: string;
+    /** Where the text is anchored. */
+    x: number;
+    y: number;
+}
+/**
+ * Lay out callout labels around a circle: a leader line leaves each slice along
+ * its own bisector, bends, and runs horizontally to text stacked down the side.
+ *
+ * The whole difficulty is collision. Slices cluster — twenty versions of a
+ * server jar are mostly slivers packed into one arc — so labels placed at their
+ * natural angles would land on top of each other. Each side is therefore
+ * relaxed independently: labels keep their order around the circle, then get
+ * pushed apart to a minimum spacing and shifted back inside the box. That's why
+ * a leader can end well away from its slice's angle and still be unambiguous —
+ * the line, not the position, is what identifies it.
+ */
+export declare const calloutLabels: (angles: {
+    index: number;
+    mid: number;
+}[], cx: number, cy: number, radius: number, 
+/** How far past the radius the elbow sits. */
+elbow: number, 
+/** Horizontal run from the elbow to the text. */
+run: number, 
+/** Minimum vertical gap between two labels on the same side. */
+spacing: number, height: number) => CalloutLabel[];
+/** Compact default tick formatting: 1.2k, 3.4M — never 1200.0000001. */
+export declare const formatTick: (v: number) => string;
+export {};

package/dist/components/codeHighlight.d.ts

@@ -0,0 +1,8 @@
+export type CodeLang = "ts" | "js" | "json" | "bash" | "html" | "python" | "rust" | "yaml" | "toml" | "kotlin" | "java" | "groovy" | "plain";
+export interface Token {
+    text: string;
+    /** CSS class for this token, or "" for plain text. */
+    cls: string;
+}
+/** Tokenize one line into coloured spans. JSON keys get the property colour. */
+export declare function tokenizeLine(line: string, lang: CodeLang): Token[];

package/dist/components/color.d.ts

@@ -0,0 +1,65 @@
+/** Hue 0..360, saturation/value 0..1, alpha 0..1. */
+export interface Hsv {
+    h: number;
+    s: number;
+    v: number;
+    a: number;
+}
+/** Channels 0..255, alpha 0..1. */
+export interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/** The string shapes a caller can hand the picker, and ask back out of it. */
+export type ColorFormat = "hex" | "rgb" | "hsl";
+/** Wraps rather than clamps: hue is a circle, and 370° is 10°, not 360°. */
+export declare function normalizeHue(h: number): number;
+export declare function clampHsv(c: Hsv): Hsv;
+export declare function hsvToRgb({ h, s, v, a }: Hsv): Rgb;
+export declare function rgbToHsv({ r, g, b, a }: Rgb): Hsv;
+/** "#rrggbb", or "#rrggbbaa" when the colour is not fully opaque. */
+export declare function rgbToHex({ r, g, b, a }: Rgb): string;
+/**
+ * Parses #rgb / #rgba / #rrggbb / #rrggbbaa, with or without the leading `#`.
+ * Returns null for anything it doesn't recognise, so a half-typed value in the
+ * hex field can be left alone instead of snapping the picker to black.
+ */
+export declare function parseHex(input: string): Rgb | null;
+/**
+ * Parses a colour a person might paste: hex (3/4/6/8 digits, `#` optional),
+ * rgb()/rgba() and hsl()/hsla() in both the comma and the space/slash forms,
+ * percentages, hue in deg/turn/rad/grad, brackets optional, and a bare triple
+ * of numbers read as rgb. A round-trip through a caller's storage therefore
+ * comes back the colour it went in as, whatever shape it was stored in.
+ *
+ * Named colours ("rebeccapurple") and the newer spaces (lab, oklch, color())
+ * are out of scope: resolving those needs the browser's own parser, and a
+ * component that silently handled some and not others would be worse than one
+ * that is clear about what it takes.
+ */
+export declare function parseColor(input: string): Rgb | null;
+/** HSV→HSL, for the hsl() output format. Saturation/lightness come back 0..1. */
+export declare function hsvToHsl({ h, s, v }: Hsv): {
+    h: number;
+    s: number;
+    l: number;
+};
+/** The colour as a CSS string in the requested format. */
+export declare function formatColor(c: Hsv, format: ColorFormat): string;
+/** Always opaque — for the swatch behind an alpha checkerboard, and for rails. */
+export declare function opaqueCss(c: Hsv): string;
+/**
+ * Whether dark ink reads better than light on this colour, by WCAG relative
+ * luminance. The picker uses it for the check mark on a selected swatch, which
+ * otherwise disappears into a pale preset.
+ */
+export declare function isLight(c: Hsv): boolean;
+/**
+ * A neutral starting palette. Kit tokens are deliberately NOT used here: these
+ * are values a user picks *for their own data* (a tag, a calendar category),
+ * which must stay put when the app's theme changes — a preset that shifted with
+ * the theme would silently restyle everything already saved with it.
+ */
+export declare const DEFAULT_SWATCHES: readonly ["#ef4444", "#f97316", "#f59e0b", "#22c55e", "#10b981", "#06b6d4", "#3b82f6", "#6366f1", "#8b5cf6", "#ec4899", "#64748b", "#111827"];

package/dist/components/commandSearch.d.ts

@@ -0,0 +1,13 @@
+export interface SearchableCommand {
+    label: string;
+    description?: string;
+    keywords?: string[];
+    group?: string;
+}
+export interface CommandSearchTerms {
+    include: string[];
+    exclude: string[];
+    groups: string[];
+}
+export declare function parseCommandQuery(value: string): CommandSearchTerms;
+export declare function rankCommandItems<T extends SearchableCommand>(items: T[], terms: CommandSearchTerms): T[];

package/dist/components/commandSearch.js

@@ -1,11 +1,4 @@
 const QUERY_TOKEN = /(-?)(?:(in):)?(?:"([^"]*)"|(\S+))/giu;
-const LATIN = "qwertyuiop[]asdfghjkl;'zxcvbnm,.`";
-const CYRILLIC = "йцукенгшщзхъфывапролджэячсмитьбюё";
-const SWAP = /* @__PURE__ */ new Map();
-for (let i = 0; i < LATIN.length; i++) {
-  SWAP.set(LATIN[i], CYRILLIC[i]);
-  SWAP.set(CYRILLIC[i], LATIN[i]);
-}
 function parseCommandQuery(value) {
   const out = { include: [], exclude: [], groups: [] };
   QUERY_TOKEN.lastIndex = 0;
@@ -18,14 +11,6 @@ function parseCommandQuery(value) {
   }
   return out;
 }
-function swapCommandTerms(terms) {
-  const swap = (term) => [...term].map((ch) => SWAP.get(ch) ?? ch).join("");
-  return {
-    include: terms.include.map(swap),
-    exclude: terms.exclude.map(swap),
-    groups: terms.groups.map(swap)
-  };
-}
 function matches(command, term) {
   return command.label.toLowerCase().includes(term) || (command.keywords ?? []).some((keyword) => keyword.toLowerCase().includes(term)) || (command.description?.toLowerCase().includes(term) ?? false);
 }
@@ -61,6 +46,5 @@ function rankCommandItems(items, terms) {
 }
 export {
   parseCommandQuery,
-  rankCommandItems,
-  swapCommandTerms
+  rankCommandItems
 };

package/dist/components/countries-data.d.ts

@@ -0,0 +1,2 @@
+import type { Country } from "./countries";
+export declare const COUNTRIES: Country[];

package/dist/components/countries.d.ts

@@ -0,0 +1,20 @@
+export interface Country {
+    /** ISO 3166-1 alpha-2, uppercase (e.g. "US"). Drives the flag. */
+    iso2: string;
+    name: string;
+    /** Calling code without "+", e.g. "1", "44", "380". */
+    dial: string;
+}
+/** Turn an ISO2 code into its flag emoji (two regional-indicator symbols). */
+export declare function flagEmoji(iso2: string): string;
+/**
+ * Load the country table (code-split chunk). Cached after first call, so repeat
+ * calls are synchronous-ish (resolved promise) with no re-import cost.
+ */
+export declare function loadCountries(): Promise<Country[]>;
+/**
+ * Best-effort: pick the country whose dial code prefixes the given E.164-ish
+ * value (longest match wins, so "1868" beats "1"). For shared codes the primary
+ * country is preferred. Pass the list (from loadCountries). Undefined if none.
+ */
+export declare function matchCountryByValue(value: string, list: Country[]): Country | undefined;

package/dist/components/dropdown.d.ts

@@ -0,0 +1,29 @@
+/** Enter/exit animation for state-open panels (Select, Popover, Dropdown, …). */
+export declare const POPOVER_ANIM: string;
+/** Tooltip variant: faster, and reka uses `delayed-open` instead of `open`. */
+export declare const TOOLTIP_ANIM: string;
+/**
+ * The bare floating surface (border, raised overlay fill, blur, shadow) without
+ * any animation — pair with POPOVER_ANIM or TOOLTIP_ANIM. `group` lets option
+ * rows read the panel's data-side for the cascade direction.
+ */
+export declare const PANEL_SURFACE = "group rounded-control border border-line bg-surface-overlay shadow-panel backdrop-blur";
+/**
+ * Surface + the state-open animation. Add width/padding/overflow and the z-layer
+ * at the call-site (z-layer omitted so tooltips can use z-(--z-tooltip) while the
+ * rest use z-(--z-popover)).
+ */
+export declare const POPOVER_PANEL: string;
+/**
+ * A selectable option row: layout, highlight state, and the staggered cascade.
+ * Cascades downward by default and upward when the panel is flipped above the
+ * trigger (group-data-[side=top]). Pair with an inline animationDelay for the
+ * stagger. `flex` + gap are included; add justify/extra layout if needed.
+ */
+export declare const OPTION_ITEM: string;
+/**
+ * Micro-animation for a close / clear "✕" icon: a quarter-turn on hover and a
+ * dip on press. Put on the <LpIcon>, with `group` on its button. Shared by
+ * Modal, Drawer, Toaster and the Autocomplete clear button.
+ */
+export declare const CLOSE_ICON: string;

package/dist/components/fileTree.d.ts

@@ -0,0 +1,79 @@
+import type { ContextMenuItemDef } from "./LpContextMenu.vue";
+export interface FileNode {
+    /** Stable identity — use the full path when you have one. */
+    id: string;
+    name: string;
+    /** Directories can hold `children`; files are leaves. */
+    kind: "file" | "dir";
+    /** Size in bytes. Shown right-aligned when `showSize` is on. */
+    size?: number;
+    /** Last-modified time — Date, epoch ms, or a pre-formatted string. */
+    modified?: Date | number | string;
+    /** Extra right-aligned text (badge-ish), e.g. "read-only". */
+    meta?: string;
+    /**
+     * Omit on a directory to mark its children as not-yet-loaded: the row shows a
+     * chevron and emits `expand` on first open so the caller can fetch them.
+     * An empty array means "loaded, and genuinely empty".
+     */
+    children?: FileNode[];
+    /** Override the type-derived icon. */
+    icon?: string;
+    /** Dimmed row (e.g. a git-ignored or unreadable entry). Still expandable. */
+    disabled?: boolean;
+    /** Right-click menu for this entry. */
+    menu?: ContextMenuItemDef[];
+}
+/** Icon for a node: explicit override → dir state → name → extension → generic. */
+export declare function fileIcon(node: FileNode, expanded?: boolean): string;
+/** Directories first, then case-insensitive by name — the file-manager order. */
+export declare function sortNodes(nodes: FileNode[]): FileNode[];
+/** Human-readable byte size — binary units, matching what file managers show. */
+export declare function formatSize(bytes: number): string;
+/** Short local date-time for the modified column; passes strings through. */
+export declare function formatModified(value: Date | number | string): string;
+/**
+ * Total size of a subtree: a directory's own `size` when the caller computed one
+ * (the common case for a server-side listing), otherwise the sum of its loaded
+ * descendants. Returns undefined when nothing along the way carries a size.
+ */
+export declare function subtreeSize(node: FileNode): number | undefined;
+/** Every id in a subtree including the root — the unit a checkbox toggles. */
+export declare function subtreeIds(node: FileNode): string[];
+export type CheckState = "checked" | "unchecked" | "indeterminate";
+/**
+ * A node's checkbox state derived from the checked-id set.
+ *
+ * A directory reflects its loaded children: all checked → checked, some →
+ * indeterminate. A directory whose children aren't loaded yet (or which has
+ * none) falls back to its own membership, so an unexpanded folder can still be
+ * ticked as a whole — which is exactly what a backup picker needs.
+ */
+export declare function checkStateOf(node: FileNode, checked: ReadonlySet<string>): CheckState;
+/**
+ * How much of a directory's subtree is ticked, counting FILES only (folders are
+ * containers, not payload). Lets a row say "3 / 12" so a half-filled checkbox
+ * isn't the only clue that a folder is partially selected.
+ */
+export declare function checkedCount(node: FileNode, checked: ReadonlySet<string>): {
+    checked: number;
+    total: number;
+};
+/** Everything a row needs to render, precomputed once per node. */
+export interface NodeStats {
+    state: CheckState;
+    /** Ticked files in the subtree, and how many there are in total. */
+    checked: number;
+    total: number;
+    /** Rolled-up subtree size, or undefined when nothing carries one. */
+    size?: number;
+}
+/**
+ * Derive every row's state in ONE post-order pass over the tree, keyed by node
+ * id. Calling `checkStateOf`/`subtreeSize`/`checkedCount` per row instead makes
+ * each row walk its own subtree, which is quadratic on a deep tree and shows up
+ * as a stutter the moment a directory holds a few thousand files.
+ */
+export declare function computeStats(nodes: FileNode[], checked: ReadonlySet<string>): Map<string, NodeStats>;
+/** Ids of every ancestor directory of `id`, so callers can reveal a deep node. */
+export declare function ancestorIds(nodes: FileNode[], id: string): string[];

package/dist/components/lightbox.d.ts

@@ -0,0 +1,24 @@
+export interface LightboxItem {
+    /** Full-size source. */
+    src: string;
+    /** Smaller source for the filmstrip; falls back to `src`. */
+    thumb?: string;
+    /** Caption under the image, and the img alt text. */
+    title?: string;
+    /** Secondary line under the title (size, date, resolution…). */
+    description?: string;
+    /** Filename used when downloading; derived from `src` when absent. */
+    filename?: string;
+    /**
+     * Hide this image behind a cover until someone asks for it — a spoiler, a
+     * screenshot of something not everyone in the channel has reached yet, a
+     * picture that should not appear in a scroll past.
+     *
+     * A property of the ITEM rather than of the grid showing it: which images are
+     * spoilers is a fact about the images, and the usual set is a mixed one, with
+     * a marked picture sitting beside plain ones.
+     */
+    spoiler?: boolean;
+}
+/** Last path segment of a URL, or a fallback — used to name a download. */
+export declare function fileNameOf(item: LightboxItem, fallback?: string): string;