@leavepulse/ui 0.43.2 → 0.43.4

package/dist/composables/useZoomPan.d.ts

@@ -0,0 +1,58 @@
+import { type ComputedRef, type CSSProperties, type Ref } from "vue";
+export interface UseZoomPanOptions {
+    /** Smallest allowed scale. Default 1 (fit — never shrink past the viewport). */
+    min?: number;
+    /** Largest allowed scale. Default 8. */
+    max?: number;
+    /** Multiplier per wheel notch. Default 1.15. */
+    step?: number;
+    /** Scale that a double-click/tap toggles to, from `min`. Default 2. */
+    zoomedScale?: number;
+}
+export interface UseZoomPan {
+    scale: Ref<number>;
+    /**
+     * Pan offset in CONTENT pixels — what `style` puts inside `translate()`,
+     * before the scale magnifies it. Exposed because anything that has to know
+     * *which part* is visible needs the number, not the CSS string: an exporter
+     * writing the cropped region, a minimap drawing the viewport rectangle, a
+     * caller restoring a saved position. Parsing it back out of `transform` is
+     * the alternative, and that breaks the moment this composable changes how it
+     * composes the transform.
+     */
+    offset: ComputedRef<{
+        x: number;
+        y: number;
+    }>;
+    /**
+     * Put the view somewhere — restoring a saved position, or carrying one
+     * through a change that re-frames the content. Clamped like any other pan,
+     * so a caller cannot place the content off the viewport. Omitting `scale`
+     * keeps the current one.
+     */
+    setView: (view: {
+        x: number;
+        y: number;
+        scale?: number;
+    }) => void;
+    /** True once zoomed past the minimum — the point at which panning matters. */
+    zoomed: ComputedRef<boolean>;
+    /** True while a drag is in flight, so the caller can swap the cursor. */
+    panning: Ref<boolean>;
+    style: ComputedRef<CSSProperties>;
+    onWheel: (e: WheelEvent) => void;
+    onPointerDown: (e: PointerEvent) => void;
+    onPointerMove: (e: PointerEvent) => void;
+    onPointerUp: (e: PointerEvent) => void;
+    /** Zoom about the viewport centre (buttons, keyboard). */
+    zoomBy: (factor: number) => void;
+    /** Toggle between fit and `zoomedScale`, optionally about a point. */
+    toggleZoom: (origin?: {
+        x: number;
+        y: number;
+    }) => void;
+    reset: () => void;
+    /** Call with the viewport element so pointer coords can be made relative. */
+    setViewport: (el: HTMLElement | null) => void;
+}
+export declare function useZoomPan(options?: UseZoomPanOptions): UseZoomPan;

package/dist/icons.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,162 @@
+export { default as LayoutCanvas } from "./components/LayoutCanvas.vue";
+export { default as LpAddressInput } from "./components/LpAddressInput.vue";
+export { default as LpMapPicker } from "./components/LpMapPicker.vue";
+export { OSM_TILES, createNominatimProvider, emptyAddress, formatAddress, project, tileUrl, unproject, } from "./components/address";
+export type { AddressField, AddressLabels, AddressSuggestion, AddressValue, GeocodeProvider, GeocodeQuery, LatLon, NominatimOptions, TileSource, } from "./components/address";
+export { default as LpActionBar } from "./components/LpActionBar.vue";
+export type { ActionBarAction } from "./components/LpActionBar.vue";
+export { default as LpAlert } from "./components/LpAlert.vue";
+export { default as LpAppShell } from "./components/LpAppShell.vue";
+export { default as LpAutocomplete } from "./components/LpAutocomplete.vue";
+export type { AutocompleteOption } from "./components/LpAutocomplete.vue";
+export { default as LpAvatar } from "./components/LpAvatar.vue";
+export { default as LpBadge } from "./components/LpBadge.vue";
+export { default as LpBreadcrumbs } from "./components/LpBreadcrumbs.vue";
+export type { Crumb } from "./components/LpBreadcrumbs.vue";
+export { default as LpButton } from "./components/LpButton.vue";
+export { default as LpCalendar } from "./components/LpCalendar.vue";
+export { default as LpCard } from "./components/LpCard.vue";
+export { default as LpChart } from "./components/LpChart.vue";
+export type { ChartPointEvent } from "./components/LpChart.vue";
+export { CHART_PALETTE, axisTicks, formatTick, niceScale, } from "./components/chart";
+export type { ChartAxis, ChartPoint, ChartSeries } from "./components/chart";
+export { default as LpCheckbox } from "./components/LpCheckbox.vue";
+export { default as LpCodeBlock } from "./components/LpCodeBlock.vue";
+export type { CodeLang } from "./components/codeHighlight";
+export { default as LpColorPicker } from "./components/LpColorPicker.vue";
+export type { ColorPickerLabels } from "./components/LpColorPicker.vue";
+export { clampHsv, DEFAULT_SWATCHES, formatColor, hsvToHsl, hsvToRgb, isLight, normalizeHue, opaqueCss, parseColor, parseHex, rgbToHex, rgbToHsv, } from "./components/color";
+export type { ColorFormat, Hsv, Rgb } from "./components/color";
+export { default as LpCommandPalette } from "./components/LpCommandPalette.vue";
+export type { Command, PaletteLabels } from "./components/LpCommandPalette.vue";
+export { parseCommandQuery, rankCommandItems } from "./components/commandSearch";
+export type { CommandSearchTerms, SearchableCommand } from "./components/commandSearch";
+export { default as LpConfirmDialog } from "./components/LpConfirmDialog.vue";
+export { default as LpContextMenu } from "./components/LpContextMenu.vue";
+export type { ContextMenuItemDef } from "./components/LpContextMenu.vue";
+export { default as LpDatePicker } from "./components/LpDatePicker.vue";
+export { default as LpDisclosure } from "./components/LpDisclosure.vue";
+export { default as LpDivider } from "./components/LpDivider.vue";
+export { default as LpDrawer } from "./components/LpDrawer.vue";
+export { default as LpDropdownMenu } from "./components/LpDropdownMenu.vue";
+export type { MenuItem } from "./components/LpDropdownMenu.vue";
+export { default as LpDropzone } from "./components/LpDropzone.vue";
+export { default as LpEmptyState } from "./components/LpEmptyState.vue";
+export { default as LpFileTree } from "./components/LpFileTree.vue";
+export type { FileTreeSummary } from "./components/LpFileTree.vue";
+export type { CheckState, FileNode, NodeStats } from "./components/fileTree";
+export { ancestorIds, checkedCount, checkStateOf, computeStats, fileIcon, formatModified, formatSize, sortNodes, subtreeIds, subtreeSize, } from "./components/fileTree";
+export { default as LpFormField } from "./components/LpFormField.vue";
+export { default as LpIcon } from "./components/LpIcon.vue";
+export { default as LpImageEditor } from "./components/LpImageEditor.vue";
+export { default as LpInfraNode } from "./components/LpInfraNode.vue";
+export type { InfraNodeData } from "./components/LpInfraNode.vue";
+export { default as LpInput } from "./components/LpInput.vue";
+export { default as LpLightbox } from "./components/LpLightbox.vue";
+export type { LightboxItem } from "./components/lightbox";
+export { fileNameOf } from "./components/lightbox";
+export { default as LpLink } from "./components/LpLink.vue";
+export { default as LpLogViewer } from "./components/LpLogViewer.vue";
+export type { LogLevel, LogLine } from "./components/LpLogViewer.vue";
+export { default as LpMediaGallery } from "./components/LpMediaGallery.vue";
+export { default as LpModal } from "./components/LpModal.vue";
+export { default as LpModalNav } from "./components/LpModalNav.vue";
+export { default as LpNotificationBell } from "./components/LpNotificationBell.vue";
+export type { NotificationItem, NotificationLabels, } from "./components/LpNotificationBell.vue";
+export { default as LpNumberField } from "./components/LpNumberField.vue";
+export { default as LpTimeField } from "./components/LpTimeField.vue";
+export { default as LpNumberFlow } from "./components/LpNumberFlow.vue";
+export { default as LpOtpInput } from "./components/LpOtpInput.vue";
+export { default as LpPagination } from "./components/LpPagination.vue";
+export { default as LpPasswordInput } from "./components/LpPasswordInput.vue";
+export { default as LpPie } from "./components/LpPie.vue";
+export type { SliceEvent } from "./components/LpPie.vue";
+export { resolveSlices } from "./components/chart";
+export type { PieSlice, ResolvedSlice } from "./components/chart";
+export { default as LpPhoneInput } from "./components/LpPhoneInput.vue";
+export type { PhoneDetail } from "./components/LpPhoneInput.vue";
+export { flagEmoji, loadCountries, matchCountryByValue } from "./components/countries";
+export type { Country } from "./components/countries";
+export { default as LpPopover } from "./components/LpPopover.vue";
+export { default as LpProgress } from "./components/LpProgress.vue";
+export { default as LpRadio } from "./components/LpRadio.vue";
+export { default as LpRadioGroup } from "./components/LpRadioGroup.vue";
+export type { RadioOption } from "./components/LpRadioGroup.vue";
+export { default as LpRollingText } from "./components/LpRollingText.vue";
+export { default as LpScrollArea } from "./components/LpScrollArea.vue";
+export { default as LpSegmented } from "./components/LpSegmented.vue";
+export type { SegmentedOption } from "./components/LpSegmented.vue";
+export { default as LpSection } from "./components/LpSection.vue";
+export { default as LpSelect } from "./components/LpSelect.vue";
+export type { SelectOption, SelectValue } from "./components/LpSelect.vue";
+export { default as LpServiceNode } from "./components/LpServiceNode.vue";
+export type { ServiceNodeData } from "./components/LpServiceNode.vue";
+export { default as LpShift } from "./components/LpShift.vue";
+export { default as LpShortcutsDialog } from "./components/LpShortcutsDialog.vue";
+export { default as LpSidebar } from "./components/LpSidebar.vue";
+export type { SidebarItem, SidebarSection } from "./components/LpSidebar.vue";
+export { default as LpSkeleton } from "./components/LpSkeleton.vue";
+export { default as LpSlider } from "./components/LpSlider.vue";
+export { default as LpSparkline } from "./components/LpSparkline.vue";
+export { default as LpStat } from "./components/LpStat.vue";
+export { default as LpStepper } from "./components/LpStepper.vue";
+export type { Step } from "./components/LpStepper.vue";
+export { default as LpSwitch } from "./components/LpSwitch.vue";
+export { default as LpTable } from "./components/LpTable.vue";
+export type { SortState, TableColumn, TablePage, TableQuery } from "./components/LpTable.vue";
+export { default as LpTableOfContents } from "./components/LpTableOfContents.vue";
+export type { TocLink } from "./components/LpTableOfContents.vue";
+export { default as LpTabs } from "./components/LpTabs.vue";
+export type { TabItem } from "./components/LpTabs.vue";
+export { default as LpTextarea } from "./components/LpTextarea.vue";
+export { default as LpThemeSwitcher } from "./components/LpThemeSwitcher.vue";
+export { default as LpTilt } from "./components/LpTilt.vue";
+export { default as LpToaster } from "./components/LpToaster.vue";
+export { default as LpTooltip } from "./components/LpTooltip.vue";
+export { default as LpTopologyCanvas } from "./components/LpTopologyCanvas.vue";
+export type { CanvasViewport, EdgeCategory, EdgeObserved, TopologyEdge, TopologyLane, TopologyNode, } from "./components/LpTopologyCanvas.vue";
+export { default as LpUptimeBar } from "./components/LpUptimeBar.vue";
+export type { UptimeSegment, UptimeStatus } from "./components/LpUptimeBar.vue";
+export { addLeaf, addTab, countBlocks, countLeaves, deserializeLayout, makeLayout, moveLeaf, removeBlock, removeLeaf, reorderTab, resizeAt, setActiveTab, serializeLayout, } from "./layout/tree";
+export type { Dir, LayoutNode, Leaf, Side, Split } from "./layout/tree";
+export { blockTitle, defineBlocks } from "./layout/registry";
+export type { BlockDef, BlockRegistry } from "./layout/registry";
+export { useLayout } from "./layout/useLayout";
+export type { UseLayout, UseLayoutOptions } from "./layout/useLayout";
+export { applyTheme, applyThemeWithTransition, bootstrapTheme, parseTheme, serializeTheme, THEME_COOKIE, themeFromCookie, themeToCssRule, themeToCssVars, useTheme, } from "./theme/useTheme";
+export type { RevealOrigin } from "./theme/useTheme";
+export { detectBackdropFilter, isBrokenBackdropEngine, NO_BACKDROP_ATTR } from "./theme/backdrop";
+export { DEFAULT_SURFACE } from "./theme/tokens";
+export { defineTheme } from "./theme/define";
+export type { ThemeOverrides } from "./theme/define";
+export type { ColorTokens, DensityTokens, FontTokens, ShapeTokens, SurfaceTokens, TokenSet, } from "./theme/tokens";
+export { amber, dark, leavepulse, light, lime, nord, presets, rose, violet } from "./theme/presets";
+export type { PresetName } from "./theme/presets";
+export { parseConfig, serializeConfig, UI_CONFIG_VERSION } from "./theme/config";
+export type { UiConfig } from "./theme/config";
+export { useClipboard } from "./composables/useClipboard";
+export type { CopyOptions, UseClipboard } from "./composables/useClipboard";
+export { useHotkeys, isAppleKeyboard, appleModifierLabel, activeShortcuts, mergeShortcutGroups, } from "./composables/useHotkeys";
+export type { HotkeyBinding, HotkeyHelp, ShortcutEntry, ShortcutGroup } from "./composables/useHotkeys";
+export { provideGlass, useGlass } from "./composables/useGlass";
+export { useMergedClass, useMergedAttrs, mergeClass } from "./composables/useMergedClass";
+export { useInputFilter } from "./composables/useInputFilter";
+export type { UseInputFilterOptions } from "./composables/useInputFilter";
+export { easeOut, easeTravel, easingToken, prefersReducedMotion } from "./composables/easing";
+export { useReveal } from "./composables/useReveal";
+export type { UseReveal, UseRevealOptions } from "./composables/useReveal";
+export { useAsyncTask } from "./composables/useAsyncTask";
+export { useRovingFocus } from "./composables/useRovingFocus";
+export type { RovingItem, UseRovingFocusOptions } from "./composables/useRovingFocus";
+export { useFormDraft } from "./composables/useFormDraft";
+export type { UseFormDraft, UseFormDraftOptions } from "./composables/useFormDraft";
+export { useSettled } from "./composables/useSettled";
+export type { UseSettledOptions } from "./composables/useSettled";
+export { useShift } from "./composables/useShift";
+export type { ShiftAxis, UseShift, UseShiftOptions } from "./composables/useShift";
+export { useTilt } from "./composables/useTilt";
+export type { UseTilt, UseTiltOptions } from "./composables/useTilt";
+export { useZoomPan } from "./composables/useZoomPan";
+export type { UseZoomPan, UseZoomPanOptions } from "./composables/useZoomPan";
+export { useToast } from "./composables/useToast";
+export type { ToastAction, ToastItem, ToastOptions, ToastVariant, } from "./composables/useToast";

package/dist/index.js

@@ -19,7 +19,7 @@ import { _ as _15 } from "./chunks/LpCodeBlock-Bo0B4TFR.js";
 import { _ as _16 } from "./chunks/LpColorPicker-BlXea7LM.js";
 import { DEFAULT_SWATCHES, clampHsv, formatColor, hsvToHsl, hsvToRgb, isLight, normalizeHue, opaqueCss, parseColor, parseHex, rgbToHex, rgbToHsv } from "./components/color.js";
 import { default as default3 } from "./components/LpCommandPalette.vue.js";
-import { parseCommandQuery, rankCommandItems, swapCommandTerms } from "./components/commandSearch.js";
+import { parseCommandQuery, rankCommandItems } from "./components/commandSearch.js";
 import { _ as _17 } from "./chunks/LpConfirmDialog-Q-bxff8z.js";
 import { _ as _18 } from "./chunks/LpContextMenu-CwW1QXe_.js";
 import { _ as _19 } from "./chunks/LpDatePicker-CwOToxGq.js";
@@ -295,7 +295,6 @@ export {
   sortNodes,
   subtreeIds,
   subtreeSize,
-  swapCommandTerms,
   t as themeFromCookie,
   k as themeToCssRule,
   m as themeToCssVars,

package/dist/layout/registry.d.ts

@@ -0,0 +1,26 @@
+import type { Component } from "vue";
+export interface BlockDef {
+    /**
+     * Content component for this block. Optional: when the consumer renders block
+     * content via the canvas's #block slot (keyed by id), the registry is used
+     * only for tab chrome (title/icon) and no component is needed here.
+     */
+    component?: Component;
+    /** Human label shown on the tab / cell header. Defaults to the id. */
+    title?: string;
+    /** Optional iconify name (e.g. "lucide:activity") for the tab. */
+    icon?: string;
+    /** Whether the user may close this block. Defaults to true. */
+    closable?: boolean;
+    /** Props passed to the component. */
+    props?: Record<string, unknown>;
+}
+export type BlockRegistry = Record<string, BlockDef>;
+/**
+ * Identity helper that pins the key type so callers get autocomplete on block
+ * ids elsewhere (e.g. when seeding a layout). Purely for inference — it returns
+ * the object unchanged.
+ */
+export declare function defineBlocks<const T extends BlockRegistry>(blocks: T): T;
+/** Resolve a block's display title, falling back to its id. */
+export declare function blockTitle(registry: BlockRegistry, id: string): string;

package/dist/layout/tree.d.ts

@@ -0,0 +1,75 @@
+export type Dir = "row" | "col";
+export type Side = "left" | "right" | "top" | "bottom" | "center";
+export interface Leaf {
+    kind: "leaf";
+    id: string;
+    /**
+     * Block ids stacked as tabs in this cell. A plain cell is a single-element
+     * stack; dropping onto a cell's center adds another tab. The consumer maps
+     * each id to content via the canvas slot.
+     */
+    blocks: string[];
+    /** Index into `blocks` of the visible tab. */
+    active: number;
+    /** Flex fraction among siblings. */
+    size: number;
+}
+export interface Split {
+    kind: "split";
+    id: string;
+    dir: Dir;
+    size: number;
+    children: LayoutNode[];
+}
+export type LayoutNode = Leaf | Split;
+/** Build a single-row layout from a flat list of block ids (one cell each). */
+export declare function makeLayout(blocks: string[]): Split;
+export declare function findParent(node: Split, childId: string): Split | null;
+export declare function findLeaf(node: LayoutNode, id: string): Leaf | null;
+export declare function countLeaves(node: LayoutNode): number;
+/** Total blocks across all cells (a tabbed cell counts each of its tabs). */
+export declare function countBlocks(node: LayoutNode): number;
+/** Remove an entire cell (with all its tabs). */
+export declare function removeLeaf(root: Split, id: string): void;
+/**
+ * Remove one tab from a cell. Removing the last tab removes the cell itself
+ * (unless it's the only block left in the whole layout, which is kept).
+ */
+export declare function removeBlock(root: Split, leafId: string, index: number): void;
+export declare function addLeaf(root: Split, block: string, side?: Side): void;
+/** Append a block as a new tab in the target cell and focus it. */
+export declare function addTab(root: Split, leafId: string, block: string): void;
+/** Switch the visible tab of a cell. */
+export declare function setActiveTab(root: Split, leafId: string, index: number): void;
+/**
+ * Reorder a tab within its cell, moving the block at `from` to `to`. The same
+ * block stays visible afterwards (active follows the moved block by identity,
+ * not by index). Always available — not gated by edit mode.
+ */
+export declare function reorderTab(root: Split, leafId: string, from: number, to: number): void;
+/**
+ * Move an existing cell to a target. An edge side splits beside the target;
+ * `center` merges the moving cell's tabs into the target cell (and focuses
+ * the first moved tab).
+ */
+export declare function moveLeaf(root: Split, movingId: string, targetId: string, side: Side): void;
+/** Splitter drag: redistribute size between two adjacent siblings. */
+export declare function resizeAt(parent: Split, index: number, deltaFraction: number): void;
+interface SerializedLeaf {
+    kind: "leaf";
+    blocks: string[];
+    active: number;
+    size: number;
+    /** Legacy single-block form (pre-tabs); hydrated into `blocks`. */
+    block?: string;
+}
+interface SerializedSplit {
+    kind: "split";
+    dir: Dir;
+    size: number;
+    children: SerializedNode[];
+}
+type SerializedNode = SerializedLeaf | SerializedSplit;
+export declare function serializeLayout(root: Split): SerializedNode;
+export declare function deserializeLayout(data: SerializedNode): Split;
+export {};

package/dist/layout/useLayout.d.ts

@@ -0,0 +1,39 @@
+import { type Ref } from "vue";
+import { type Side, type Split } from "./tree";
+export interface UseLayoutOptions {
+    /** Initial block ids, left-to-right, when no saved layout is loaded. */
+    initial: string[];
+    /** Max undo depth. */
+    historyLimit?: number;
+}
+export interface UseLayout {
+    /** The live reactive tree to hand to <LayoutCanvas v-model>. */
+    layout: Ref<Split>;
+    /** Block count across all tabs, handy for "N blocks" labels and guards. */
+    count: Ref<number>;
+    canUndo: Ref<boolean>;
+    canRedo: Ref<boolean>;
+    /** Add a block: a new cell on an edge, or a tab on the last cell (center). */
+    add: (block: string, side?: Side) => void;
+    /** Add a block as a tab in a specific cell. */
+    addTab: (leafId: string, block: string) => void;
+    /** Switch the visible tab of a cell. */
+    setActive: (leafId: string, index: number) => void;
+    /** Reorder a tab within its cell (always available, not edit-gated). */
+    reorderTab: (leafId: string, from: number, to: number) => void;
+    /** Remove one tab (drops the cell when it was the last tab). */
+    removeBlock: (leafId: string, index: number) => void;
+    /** Remove an entire cell with all its tabs. */
+    remove: (leafId: string) => void;
+    move: (movingId: string, targetId: string, side: Side) => void;
+    resize: (parent: Split, index: number, deltaFraction: number) => void;
+    undo: () => void;
+    redo: () => void;
+    /** Replace the whole layout from a flat block list. */
+    reset: (blocks?: string[]) => void;
+    /** Serialize to JSON-safe data for persistence. */
+    serialize: () => unknown;
+    /** Replace the layout from previously serialized data. */
+    hydrate: (data: unknown) => void;
+}
+export declare function useLayout(options: UseLayoutOptions): UseLayout;

package/dist/theme/backdrop.d.ts

@@ -0,0 +1,9 @@
+/** Set on <html> when backdrop-filter resolves but does not composite. */
+export declare const NO_BACKDROP_ATTR = "data-lp-no-backdrop";
+export declare function isBrokenBackdropEngine(nav?: Navigator): boolean;
+/**
+ * Flag the document when backdrop-filter cannot be trusted, so the fallback
+ * rules in tokens.css can trade blur for opacity. Safe to call more than once
+ * and a no-op outside the browser.
+ */
+export declare function detectBackdropFilter(root?: HTMLElement): boolean;

package/dist/theme/config.d.ts

@@ -0,0 +1,16 @@
+import type { Split } from "../layout/tree";
+import type { TokenSet } from "./tokens";
+export declare const UI_CONFIG_VERSION = 1;
+export interface UiConfig {
+    version: number;
+    theme: TokenSet;
+    /** Optional — apps without a composable layout omit it. */
+    layout?: Split;
+}
+export interface SerializedUiConfig {
+    version: number;
+    theme: TokenSet;
+    layout?: unknown;
+}
+export declare function serializeConfig(config: UiConfig): string;
+export declare function parseConfig(json: string): UiConfig;

package/dist/theme/define.d.ts

@@ -0,0 +1,12 @@
+import { presets } from "./presets";
+import type { ColorTokens, DensityTokens, FontTokens, ShapeTokens, SurfaceTokens, TokenSet } from "./tokens";
+export interface ThemeOverrides {
+    name?: string;
+    mode?: "dark" | "light";
+    colors?: Partial<ColorTokens>;
+    shape?: Partial<ShapeTokens>;
+    density?: Partial<DensityTokens>;
+    font?: Partial<FontTokens>;
+    surface?: Partial<SurfaceTokens>;
+}
+export declare function defineTheme(base: TokenSet | keyof typeof presets, overrides?: ThemeOverrides): TokenSet;

package/dist/theme/presets.d.ts

@@ -0,0 +1,20 @@
+import type { TokenSet } from "./tokens";
+export declare const dark: TokenSet;
+export declare const light: TokenSet;
+export declare const lime: TokenSet;
+export declare const leavepulse: TokenSet;
+export declare const rose: TokenSet;
+export declare const amber: TokenSet;
+export declare const violet: TokenSet;
+export declare const nord: TokenSet;
+export declare const presets: {
+    readonly dark: TokenSet;
+    readonly light: TokenSet;
+    readonly lime: TokenSet;
+    readonly leavepulse: TokenSet;
+    readonly rose: TokenSet;
+    readonly amber: TokenSet;
+    readonly violet: TokenSet;
+    readonly nord: TokenSet;
+};
+export type PresetName = keyof typeof presets;

package/dist/theme/tokens.d.ts

@@ -0,0 +1,75 @@
+export interface ColorTokens {
+    surface: string;
+    surfaceRaised: string;
+    surfaceSoft: string;
+    ink: string;
+    inkInverse: string;
+    muted: string;
+    mutedStrong: string;
+    brand: string;
+    brandHover: string;
+    brandSoft: string;
+    action: string;
+    actionHover: string;
+    actionSoft: string;
+    accent: string;
+    accentHover: string;
+    accentSoft: string;
+    danger: string;
+    dangerHover: string;
+    dangerSoft: string;
+    line: string;
+    lineStrong: string;
+    ring: string;
+}
+export interface ShapeTokens {
+    radiusControl: number;
+    radiusCard: number;
+    radiusPill: number;
+}
+export interface DensityTokens {
+    /** base spacing unit in px */
+    spacingUnit: number;
+    controlSm: number;
+    controlMd: number;
+    controlLg: number;
+}
+export interface FontTokens {
+    /** CSS font-family stack for UI text */
+    sans: string;
+    /** CSS font-family stack for numerals / code */
+    mono: string;
+}
+export interface SurfaceTokens {
+    /** Border width for panels/cards/controls (CSS length, e.g. "1px"). */
+    borderWidth: string;
+    /** backdrop-filter blur radius (CSS length; "0" disables glass blur). */
+    panelBlur: string;
+    /** backdrop-filter saturate (unitless or %, e.g. "100%" / "180%"). */
+    panelSaturate: string;
+    /** Overlay painted over a panel's base color ("none" or a gradient). */
+    panelOverlay: string;
+    /** Box-shadow for a raised panel (may be multi-layer for glass). */
+    panelShadow: string;
+    /** Inset highlight line for a panel ("none" or an inset box-shadow). */
+    panelInset: string;
+}
+export interface TokenSet {
+    /** human label, e.g. "Lime" */
+    name: string;
+    /** "dark" | "light" — drives `color-scheme` and the data-theme-mode hint */
+    mode: "dark" | "light";
+    colors: ColorTokens;
+    shape: ShapeTokens;
+    density: DensityTokens;
+    font: FontTokens;
+    /** Optional skin axis; older themes without it fall back to a flat default. */
+    surface?: SurfaceTokens;
+}
+/** camelCase token key → CSS custom property name. */
+export declare const COLOR_VARS: Record<keyof ColorTokens, string>;
+export declare const SHAPE_VARS: Record<keyof ShapeTokens, string>;
+export declare const DENSITY_VARS: Record<keyof DensityTokens, string>;
+export declare const FONT_VARS: Record<keyof FontTokens, string>;
+export declare const SURFACE_VARS: Record<keyof SurfaceTokens, string>;
+export declare const DEFAULT_SURFACE: SurfaceTokens;

package/dist/theme/useTheme.d.ts

@@ -0,0 +1,46 @@
+import { type ComputedRef, type DeepReadonly, type Ref } from "vue";
+import { type TokenSet } from "./tokens";
+export declare function applyTheme(theme: TokenSet, root?: HTMLElement): void;
+/** Point a circular theme reveal expands from (viewport px). */
+export interface RevealOrigin {
+    x: number;
+    y: number;
+}
+export declare function applyThemeWithTransition(theme: TokenSet, origin?: RevealOrigin, root?: HTMLElement, durationMs?: number): void;
+export declare function serializeTheme(theme: TokenSet): string;
+export declare function themeToCssVars(theme: TokenSet): string;
+/** Render a theme as a complete CSS rule (default selector `:root`). */
+export declare function themeToCssRule(theme: TokenSet, selector?: string): string;
+/** Parse + shallow-validate a theme JSON; throws on a malformed shape. */
+export declare function parseTheme(json: string): TokenSet;
+export declare function bootstrapTheme(fallback: TokenSet): TokenSet;
+export declare function cacheTheme(theme: TokenSet): void;
+export declare const THEME_COOKIE = "lp-theme";
+/**
+ * Resolve a theme name (as read from the `lp-theme` cookie) against a set of
+ * known themes. Returns `null` when the name is absent or unknown, so the caller
+ * can fall back to its own default.
+ *
+ * Server-side counterpart to `cacheTheme`: pair it with `themeToCssRule` to
+ * inline the right variables into `<head>` during SSR.
+ */
+export declare function themeFromCookie(cookieValue: string | null | undefined, themes: readonly TokenSet[]): TokenSet | null;
+export interface UseTheme {
+    /** The active theme, kept in sync by the kit. Null until hydrated (SSR/first
+     *  paint) — reactive, so a switcher binds straight to it. */
+    current: DeepReadonly<Ref<TokenSet | null>>;
+    /** The active theme's name (""="not yet hydrated"). */
+    currentName: ComputedRef<string>;
+    /** Set + persist a theme (with the circular reveal if `origin`/transition).
+     *  This is the one call a switcher needs — it updates `current` too. */
+    setTheme: (theme: TokenSet, origin?: RevealOrigin) => void;
+    /** Seed the fallback (used when nothing is cached) and hydrate now. Call once
+     *  at app start (client) — optional; the first useTheme() hydrates anyway. */
+    init: (fallback: TokenSet) => TokenSet;
+    apply: (theme: TokenSet) => void;
+    applyWithTransition: (theme: TokenSet, origin?: RevealOrigin) => void;
+    serialize: typeof serializeTheme;
+    parse: typeof parseTheme;
+    bootstrap: typeof bootstrapTheme;
+}
+export declare function useTheme(): UseTheme;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leavepulse/ui",
-  "version": "0.43.2",
+  "version": "0.43.4",
   "type": "module",
   "description": "LeavePulse token-driven Vue component kit.",
   "repository": {
@@ -47,7 +47,7 @@
     "gen:names": "node scripts/gen-component-names.mjs",
     "build": "node scripts/gen-component-names.mjs && vue-tsc --noEmit -p tsconfig.build.json && vite build --config vite.lib.config.ts && vue-tsc --declaration --emitDeclarationOnly --noEmit false -p tsconfig.build.json --outDir dist",
     "dev:dist": "vite build --watch --config vite.lib.config.ts",
-    "prepublishOnly": "node scripts/gen-component-names.mjs && vue-tsc --noEmit -p tsconfig.build.json && vite build --config vite.lib.config.ts",
+    "prepublishOnly": "npm run build",
     "typecheck": "vue-tsc --noEmit",
     "test": "bun test",
     "release": "npm version patch -m \"chore: release v%s\" && git push --follow-tags",

package/src/components/LpCommandPalette.vue

@@ -44,7 +44,7 @@ import { useGlass } from "../composables/useGlass"
 import { useClipboard } from "../composables/useClipboard"
 import { useHotkeys } from "../composables/useHotkeys"
 import { useModalLayer } from "./modalDepth"
-import { parseCommandQuery, rankCommandItems, swapCommandTerms } from "./commandSearch"
+import { parseCommandQuery, rankCommandItems } from "./commandSearch"
 
 export interface Command {
   id: string
@@ -190,12 +190,6 @@ const props = withDefaults(
      * other group off the screen. 0 shows everything.
      */
     groupLimit?: number
-    /**
-     * When the query matches nothing, retry it as if typed in the other
-     * keyboard layout (QWERTY ↔ Cyrillic). Off for an app whose commands are
-     * meant to be typed in one layout only.
-     */
-    layoutFallback?: boolean
     /**
      * A pane beside the list showing the highlighted result in full — its
      * `preview` text, or the `preview` slot. For palettes that search
@@ -229,7 +223,6 @@ const props = withDefaults(
     resultsLabel: "Results",
     excerptLines: 4,
     groupLimit: 0,
-    layoutFallback: true,
     previewPane: false,
     glass: undefined,
   },
@@ -469,10 +462,7 @@ const local = computed<{ items: Command[]; terms: string[] }>(() => {
   // typed). With a query, hidden commands rank like any other.
   if (!terms.include.length && !terms.exclude.length && !terms.groups.length) return { items: filtered, terms: [] }
   const items = rankCommandItems(filtered, terms)
-  if (items.length || !props.layoutFallback) return { items, terms: terms.include }
-  const swapped = swapCommandTerms(terms)
-  const other = rankCommandItems(filtered, swapped)
-  return other.length ? { items: other, terms: swapped.include } : { items, terms: terms.include }
+  return { items, terms: terms.include }
 })
 
 const ranked = computed<Command[]>(() => local.value.items)