@inkami/blx 0.17.3

package/dist/ui/modal.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Modal dialog widget.
+ *
+ * Provides both static factory helpers (Modal.confirm, Modal.alert) and an
+ * instance-based API (new Modal()) for custom content dialogs.
+ *
+ * Uses the native `<dialog>` element with `showModal()` for:
+ * - Built-in focus trap (browser-managed)
+ * - Top-layer rendering (above all other content)
+ * - Native Escape key handling
+ *
+ * Accessibility:
+ * - `role="dialog"` + `aria-modal="true"` on the dialog element
+ * - `aria-labelledby` points to the title element when a title is provided
+ * - Scroll lock applied to body while dialog is open
+ * - Focus returned to triggering element on close
+ *
+ * @example
+ * // Confirm dialog
+ * const confirmed = await Modal.confirm("Delete this block?", { title: "Confirm Delete" });
+ *
+ * // Alert dialog
+ * await Modal.alert("Your changes have been saved.");
+ *
+ * // Custom content modal
+ * const modal = new Modal({ title: "Settings" });
+ * modal.contentEl.appendChild(myForm);
+ * modal.open();
+ */
+/** Construction / configuration options for Modal instances and static helpers. */
+export interface ModalOptions {
+    /** Dialog title displayed in a header `<h3>`. Used for `aria-labelledby`. */
+    title?: string;
+    /** Additional CSS class for the dialog element. */
+    className?: string;
+    /** Whether a click on the backdrop area closes the dialog (default: true). */
+    closeOnBackdropClick?: boolean;
+}
+export declare class Modal {
+    /** The native `<dialog>` element. */
+    readonly dialogEl: HTMLDialogElement;
+    /**
+     * Container element for custom content.
+     * Append child elements here when using the instance API.
+     */
+    readonly contentEl: HTMLElement;
+    private opts;
+    private previousFocus;
+    /**
+     * Create a new Modal instance for custom content dialogs.
+     * The dialog is NOT appended to the DOM until `.open()` is called.
+     *
+     * @param options - Modal configuration.
+     */
+    constructor(options?: ModalOptions);
+    /**
+     * Open the modal: append to DOM, apply scroll lock, call showModal().
+     * Records the currently focused element to restore focus on close.
+     */
+    open(): void;
+    /**
+     * Close the modal programmatically.
+     * Calls `dialog.close()` which fires the "close" event and removes scroll lock.
+     */
+    close(): void;
+    /**
+     * Remove the dialog element from the DOM.
+     * Should be called when you no longer need the modal instance.
+     */
+    destroy(): void;
+    /**
+     * Show a confirmation dialog.
+     *
+     * @param message - Body text for the dialog.
+     * @param opts - Optional title and configuration.
+     * @returns Promise that resolves to `true` (confirmed) or `false` (cancelled).
+     */
+    static confirm(message: string, opts?: Pick<ModalOptions, "title" | "closeOnBackdropClick">): Promise<boolean>;
+    /**
+     * Show an informational alert dialog with a single OK button.
+     *
+     * @param message - Body text for the dialog.
+     * @param opts - Optional title.
+     * @returns Promise that resolves when the dialog is dismissed.
+     */
+    static alert(message: string, opts?: Pick<ModalOptions, "title">): Promise<void>;
+    /**
+     * Build a `<dialog>` element with the standard modal structure:
+     * optional header (if title provided), body div, footer div.
+     * Sets ARIA attributes: role, aria-modal, aria-labelledby.
+     */
+    private static buildDialog;
+    /**
+     * Attach a backdrop click listener to a dialog.
+     * Backdrop clicks are detected by checking if the click target is the dialog
+     * element itself (not a child — those have a different target).
+     */
+    private static attachBackdropListener;
+    /**
+     * Apply scroll lock: hide body overflow and compensate for scrollbar width
+     * to prevent layout shift.
+     */
+    private static applyScrollLock;
+    /**
+     * Remove scroll lock previously applied by applyScrollLock().
+     */
+    private static removeScrollLock;
+}
+export type { ModalOptions as ModalConfirmOptions };

package/dist/ui/popover.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Reusable floating container with positioning and dismiss logic.
+ * Content is appended by the consumer via `popover.el`.
+ *
+ * Used internally by LinkPopover, HighlightPicker, and InlineToolbar.
+ */
+/** Construction options for {@link Popover}. */
+export interface PopoverOptions {
+    /** Additional CSS class (e.g. "blx-link-popover") */
+    className?: string;
+    /** CSS display value when shown (default: "flex") */
+    displayMode?: string;
+    /** Pixel gap between anchor and popover (default: 6) */
+    gap?: number;
+    /** Horizontal alignment (default: "center") */
+    align?: "start" | "center";
+    /** Preferred vertical placement (default: "below") */
+    placement?: "above" | "below";
+    /** Dismiss on click outside (default: true) */
+    dismissOnClickOutside?: boolean;
+    /** Dismiss on Escape key (default: true) */
+    dismissOnEscape?: boolean;
+}
+export declare class Popover {
+    /** The root DOM element of the popover. Append to document before calling {@link show}. */
+    readonly el: HTMLElement;
+    private _visible;
+    private opts;
+    private dismissHandle;
+    /** Called after the popover is hidden (by any means). */
+    onHide: (() => void) | null;
+    /**
+     * Create a new Popover.
+     * @param options - Optional configuration overrides.
+     */
+    constructor(options?: PopoverOptions);
+    /** Whether the popover is currently visible. */
+    get visible(): boolean;
+    /**
+     * Show the popover anchored to `anchorRect`.
+     * Installs click-outside and/or Escape-key dismiss handlers as configured.
+     * @param anchorRect - Bounding rect of the element to anchor to.
+     */
+    show(anchorRect: DOMRect): void;
+    /**
+     * Reposition to a new anchor rect without toggling visibility or dismiss handlers.
+     * No-op if the popover is not currently visible.
+     * @param anchorRect - New bounding rect to anchor to.
+     */
+    reposition(anchorRect: DOMRect): void;
+    private positionTo;
+    /**
+     * Hide the popover and remove all dismiss handlers.
+     * Fires {@link onHide} if it was previously visible.
+     */
+    hide(): void;
+    /** Hide the popover and remove its element from the DOM. */
+    destroy(): void;
+}

package/dist/ui/position-fixed.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared positioning utility for floating UI elements.
+ * Sets `position: fixed` and places the element relative to an anchor rect,
+ * flipping vertically if it overflows and clamping horizontally.
+ * Constrains max-height to available viewport space so menus scroll
+ * instead of bleeding outside the viewport.
+ */
+/** Options for {@link positionFixed}. */
+export interface PositionFixedOptions {
+    /** Pixel gap between anchor and element (default: 4) */
+    gap?: number;
+    /** Horizontal alignment relative to anchor (default: "start") */
+    align?: "start" | "center";
+    /** Preferred vertical placement (default: "below") */
+    placement?: "above" | "below";
+    /** Viewport edge padding in px (default: 4) */
+    viewportPadding?: number;
+    /**
+     * Called after final placement is determined.
+     * Receives the actual placement used (`"above"` or `"below"`), which may
+     * differ from `options.placement` if a flip was necessary.
+     */
+    onPlaced?: (placement: "above" | "below") => void;
+}
+/**
+ * Position `el` with `position: fixed` relative to `anchor`.
+ *
+ * Measures the element and places it in a single synchronous pass so the
+ * final position is painted on the first frame (no flash/jump).
+ *
+ * @param el - The floating element to position (must be in the DOM and visible).
+ * @param anchor - The anchor bounding rect (e.g. from `getBoundingClientRect()`).
+ * @param options - Placement preferences and callbacks.
+ */
+export declare function positionFixed(el: HTMLElement, anchor: DOMRect, options?: PositionFixedOptions): void;

package/dist/ui/toast.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Toast notification widget.
+ *
+ * Displays brief, auto-dismissing notifications at the bottom-center of the
+ * viewport. Uses static factory methods — callers never manage instances.
+ *
+ * Two aria-live containers are maintained:
+ * - Polite container (info/success): does not interrupt screen readers
+ * - Assertive container (error): interrupts screen readers immediately
+ *
+ * Both containers are created lazily on first use and persist indefinitely
+ * so that aria-live regions are pre-registered before content is injected
+ * (which is required for reliable screen reader announcements).
+ *
+ * @example
+ * Toast.show("File saved");
+ * Toast.show("Connection failed", { type: "error" });
+ * Toast.show("Copied!", { type: "success", duration: 2000 });
+ */
+/** Visual variant of a toast notification. */
+export type ToastType = "info" | "error" | "success";
+/** Options for {@link Toast.show}. */
+export interface ToastShowOptions {
+    /** Toast variant (default: "info"). */
+    type?: ToastType;
+    /** Auto-dismiss duration in milliseconds (default: 4000). */
+    duration?: number;
+}
+export declare class Toast {
+    /** Polite aria-live container (info / success toasts). Created on first use. */
+    private static container;
+    /** Assertive aria-live container (error toasts). Created on first use. */
+    private static assertiveContainer;
+    private constructor();
+    /**
+     * Display a toast notification.
+     *
+     * @param message - Text content to show in the toast.
+     * @param opts - Optional configuration.
+     */
+    static show(message: string, opts?: ToastShowOptions): void;
+    /**
+     * Return the appropriate aria-live container for the given toast type,
+     * creating and appending it to document.body if it doesn't exist yet.
+     *
+     * The container is created BEFORE any toast is appended so that
+     * screen readers register the live region in advance.
+     */
+    private static getOrCreateContainer;
+    /**
+     * Create a new toast container element and append it to document.body.
+     */
+    private static createContainer;
+    /**
+     * Dismiss a toast element with an exit animation.
+     * Removes the element from DOM after the animation completes.
+     * If prefers-reduced-motion is set, removes immediately.
+     */
+    private static dismiss;
+}

package/dist/ui/tooltip.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Accessible Tooltip widget.
+ *
+ * Shows a short text label near a trigger element on hover (with configurable
+ * delay) or focus (immediately). Uses `positionFixed` for viewport-aware placement.
+ *
+ * Follows WAI-ARIA Tooltip pattern: the trigger gets `aria-describedby` pointing
+ * to the tooltip element which has `role="tooltip"`. The tooltip element itself
+ * is never focusable (`pointer-events: none` set in CSS).
+ */
+/** Construction options for {@link Tooltip}. */
+export interface TooltipOptions {
+    /** Tooltip text content. */
+    content: string;
+    /** Preferred placement relative to trigger (default: "above"). */
+    placement?: "above" | "below";
+    /** Show delay in ms on mouseenter (default: 350). Focus always shows instantly. */
+    delay?: number;
+}
+export declare class Tooltip {
+    /** The tooltip DOM element. Has `role="tooltip"` and class `blx-tooltip`. */
+    readonly el: HTMLElement;
+    private opts;
+    private _visible;
+    private trigger;
+    private showTimer;
+    private onMouseEnter;
+    private onMouseLeave;
+    private onFocus;
+    private onBlur;
+    private onKeyDown;
+    private onVisibilityChange;
+    /**
+     * Create a new Tooltip.
+     * The element is appended to `document.body` immediately so it is available
+     * for positioning. It starts hidden (`display: none`).
+     * @param options - Tooltip configuration.
+     */
+    constructor(options: TooltipOptions);
+    /**
+     * Attach the tooltip to a trigger element.
+     * Sets `aria-describedby` on the trigger and installs event listeners.
+     * Call at most once per Tooltip instance — create a new Tooltip to re-attach.
+     * @param trigger - The element that triggers the tooltip.
+     */
+    attachTo(trigger: HTMLElement): void;
+    /**
+     * Update the tooltip's text content.
+     * Can be called at any time, including while the tooltip is visible.
+     * @param content - New text content.
+     */
+    updateContent(content: string): void;
+    /**
+     * Remove the tooltip element from the DOM and clean up all event listeners
+     * and timers. Removes `aria-describedby` from the trigger.
+     * After calling destroy, do not use this Tooltip instance.
+     */
+    destroy(): void;
+    private startShowTimer;
+    private cancelAndHide;
+    private cancelTimer;
+    private showNow;
+    private hide;
+}

package/dist/undo/index.d.ts

@@ -0,0 +1,5 @@
+export { UndoManager } from "./undo-manager";
+export type { UndoManagerOptions } from "./undo-manager";
+export { JumpList } from "./jump-list";
+export type { JumpEntry, JumpListOptions } from "./jump-list";
+export type { UndoAction, UndoEntry, CursorState, BlockSnapshot } from "./types";

package/dist/undo/jump-list.d.ts

@@ -0,0 +1,37 @@
+/** A position in the editor (block + cursor offset) */
+export interface JumpEntry {
+    blockId: string;
+    offset: number;
+}
+export interface JumpListOptions {
+    /** Maximum number of entries (default 100) */
+    maxSize?: number;
+}
+/**
+ * Vim-style navigation history (jumplist).
+ *
+ * Records cursor positions before "jumps" — significant position changes
+ * such as search navigation, internal link clicks, or scrollToBlock calls.
+ * Navigate with Ctrl-O (back) and Ctrl-I (forward).
+ */
+export declare class JumpList {
+    private entries;
+    private index;
+    private readonly maxSize;
+    constructor(options?: JumpListOptions);
+    /**
+     * Record the current position before jumping away.
+     * Discards forward history (like vim's jumplist).
+     */
+    push(entry: JumpEntry): void;
+    /** Go back (Ctrl-O). Returns the position to jump to, or null. */
+    back(): JumpEntry | null;
+    /** Go forward (Ctrl-I). Returns the position to jump to, or null. */
+    forward(): JumpEntry | null;
+    /** Current position in the jump list */
+    current(): JumpEntry | null;
+    canGoBack(): boolean;
+    canGoForward(): boolean;
+    clear(): void;
+    get size(): number;
+}

package/dist/undo/types.d.ts

@@ -0,0 +1,49 @@
+import type { AttributedString } from "../attributed-string";
+import type { BlockMetadata } from "../schema";
+/** Snapshot of a block's full state for undo/redo */
+export interface BlockSnapshot {
+    id: string;
+    type: string;
+    content: AttributedString;
+    metadata: BlockMetadata;
+}
+/** Cursor position within the editor */
+export interface CursorState {
+    blockId: string;
+    offset: number;
+}
+/** A single reversible action within an undo entry */
+export type UndoAction = {
+    type: "contentChange";
+    blockId: string;
+    before: {
+        content: AttributedString;
+        metadata: BlockMetadata;
+        blockType: string;
+    };
+    after: {
+        content: AttributedString;
+        metadata: BlockMetadata;
+        blockType: string;
+    };
+} | {
+    type: "addBlock";
+    block: BlockSnapshot;
+    index: number;
+} | {
+    type: "removeBlock";
+    block: BlockSnapshot;
+    index: number;
+} | {
+    type: "moveBlock";
+    blockId: string;
+    fromIndex: number;
+    toIndex: number;
+};
+/** A group of actions that form a single undoable unit */
+export interface UndoEntry {
+    actions: UndoAction[];
+    beforeCursor: CursorState | null;
+    afterCursor: CursorState | null;
+    timestamp: number;
+}

package/dist/undo/undo-manager.d.ts

@@ -0,0 +1,47 @@
+import type { UndoAction, UndoEntry, CursorState } from "./types";
+export interface UndoManagerOptions {
+    /** Maximum entries in the undo stack (default 200) */
+    maxEntries?: number;
+    /** Max ms between content changes on the same block to merge them (default 500) */
+    mergeWindow?: number;
+}
+/**
+ * Transaction-aware undo/redo history manager.
+ *
+ * Records individual actions or compound groups (e.g., block split = content
+ * change + block add). Consecutive content changes on the same block within
+ * `mergeWindow` ms are automatically coalesced into a single entry.
+ */
+export declare class UndoManager {
+    private undoStack;
+    private redoStack;
+    private readonly maxEntries;
+    private readonly mergeWindow;
+    private compoundActions;
+    private compoundBeforeCursor;
+    constructor(options?: UndoManagerOptions);
+    /** Start grouping actions into a single compound entry */
+    beginGroup(beforeCursor: CursorState | null): void;
+    /** Whether a compound group is currently active */
+    get isGrouping(): boolean;
+    /**
+     * Record an undoable action.
+     *
+     * If a compound group is active, the action is appended to the group.
+     * Otherwise, consecutive content changes on the same block within
+     * `mergeWindow` are merged into the last entry.
+     */
+    record(action: UndoAction, beforeCursor: CursorState | null, afterCursor: CursorState | null): void;
+    /** End compound group and push as a single entry */
+    endGroup(afterCursor: CursorState | null): void;
+    private pushEntry;
+    /** Pop the last undo entry. Returns null if nothing to undo. */
+    popUndo(): UndoEntry | null;
+    /** Pop the last redo entry. Returns null if nothing to redo. */
+    popRedo(): UndoEntry | null;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    clear(): void;
+    get undoSize(): number;
+    get redoSize(): number;
+}

package/dist/util/icons.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Icon utilities — thin wrapper around lucide icon definitions.
+ *
+ * Usage:
+ *   import { iconHtml, X, Plus } from "../util/icons";
+ *   el.innerHTML = iconHtml(X, 14);
+ */
+import type { IconNode } from "lucide";
+export { Check, ChevronDown, CircleCheckBig, ChevronsLeft, ChevronsRight, Clipboard, ClipboardPaste, ClockFading, ClockPlus, Code, Copy, GripVertical, Heading1, Heading2, Heading3, Heading4, History, Image, Link, List, ListChecks, ListOrdered, Pause, Pencil, Pilcrow, Play, Plus, Repeat2, Scissors, Sparkles, TextQuote, Trash2, Ban, X, } from "lucide";
+/**
+ * Return an HTML string for a lucide icon (for innerHTML contexts).
+ */
+export declare function iconHtml(def: IconNode, size?: number, attrs?: Record<string, string>): string;

package/dist/util/id.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generate a unique block ID using UUID v4.
+ *
+ * Uses `crypto.randomUUID()` when available (all modern browsers and
+ * Node 19+). Falls back to a manual implementation for older runtimes
+ * (e.g. jsdom in tests).
+ */
+export declare function generateId(): string;
+/** Validate whether a string is a valid UUID v4 */
+export declare function isUUID(id: string): boolean;

package/dist/viewport/block-viewport.d.ts

@@ -0,0 +1,106 @@
+import type { BlockController } from "../block";
+export interface BlockViewportOptions {
+    /**
+     * Number of pixels above/below the viewport to keep blocks fully active
+     * (listeners attached, content visible). Defaults to 1x viewport height,
+     * giving a total active zone of ~3x the viewport (1 above + visible + 1 below).
+     *
+     * Blocks outside this zone are *ejected*: listeners detached and the
+     * browser skips painting via `content-visibility: hidden`. The DOM stays
+     * intact so the container height is perfectly preserved — zero layout shift.
+     */
+    bufferPx?: number;
+    /**
+     * Estimated height in px for blocks whose content has not yet been
+     * rendered. Used as `minHeight` on the container to maintain scroll
+     * position stability. Default: 32
+     */
+    estimatedBlockHeight?: number;
+}
+/**
+ * Manages virtual rendering of blocks using IntersectionObserver.
+ *
+ * Two-tier lifecycle:
+ *
+ * 1. **First mount** — Block has never been rendered. When it enters the
+ *    buffer zone, `mountContent()` is called to run the plugin's `render()`
+ *    and attach listeners. This is the only transition that may cause a
+ *    layout shift (estimated height → real height); it is compensated
+ *    with a scroll anchor.
+ *
+ * 2. **Eject / Restore** — Once rendered, blocks are never unmounted.
+ *    When they leave the buffer, `ejectContent()` detaches listeners and
+ *    sets `content-visibility: hidden` (browser skips painting but
+ *    remembers the size). When they re-enter, `restoreContent()` reverses
+ *    this. Because the DOM is untouched, there is zero layout shift.
+ *
+ * When IntersectionObserver is unavailable (e.g. jsdom in tests), all blocks
+ * are mounted immediately, preserving existing behavior.
+ */
+export declare class BlockViewport {
+    private observer;
+    private controllers;
+    private forceMounted;
+    /** Measured content heights — used as `minHeight` for blocks that have
+     *  never been rendered, so first-mount layout shifts are minimized. */
+    private heightCache;
+    private readonly blocksContainer;
+    private readonly estimatedHeight;
+    private readonly hasIO;
+    /** Guard against re-entrant intersection callbacks caused by scrollBy */
+    private handlingIntersection;
+    /** Callback invoked after a batch of blocks is mounted by the viewport */
+    onContentMounted: ((blockId: string) => void) | null;
+    constructor(container: HTMLElement, options?: BlockViewportOptions);
+    /**
+     * Register a block controller with the viewport manager.
+     * If IntersectionObserver is available, the block is observed and content
+     * is mounted lazily. Otherwise, content is mounted immediately.
+     */
+    register(controller: BlockController): void;
+    /**
+     * Register multiple block controllers in a single batch.
+     * More efficient than individual register() calls during initial load.
+     */
+    registerBatch(controllers: BlockController[]): void;
+    /** Unregister a block and stop observing it */
+    unregister(blockId: string): void;
+    /**
+     * Ensure a block's content is mounted and active (e.g., before focusing
+     * or searching). The block is also marked as force-mounted so it won't
+     * be ejected when scrolling away.
+     */
+    ensureMounted(blockId: string): void;
+    /**
+     * Remove the force-mount flag from a block. If the block is outside the
+     * viewport buffer, it may be ejected on the next intersection check.
+     */
+    releaseForceMounted(blockId: string): void;
+    /** Whether a block is currently content-mounted */
+    isContentMounted(blockId: string): boolean;
+    /** Whether a block is force-mounted (won't be ejected by intersection) */
+    isForceMounted(blockId: string): boolean;
+    /**
+     * Synchronously mount content for all blocks currently visible in the
+     * viewport. Call this after the initial block load to avoid a flash of
+     * empty containers.
+     */
+    mountInitialViewport(): void;
+    /**
+     * Ensure a block is mounted, then scroll its container into view.
+     */
+    scrollIntoView(blockId: string, behavior?: ScrollBehavior): void;
+    /**
+     * Recalculate the average height from measured blocks and apply it to
+     * all never-rendered block placeholders.
+     */
+    private updateEstimatedHeights;
+    destroy(): void;
+    /** Check if an element is within the viewport (synchronous fallback) */
+    private isInViewport;
+    private handleIntersection;
+    /**
+     * Find a block container visible in the viewport to use as a scroll anchor.
+     */
+    private pickScrollAnchor;
+}

package/dist/viewport/index.d.ts

@@ -0,0 +1,2 @@
+export { BlockViewport } from "./block-viewport";
+export type { BlockViewportOptions } from "./block-viewport";

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@inkami/blx",
+  "version": "0.17.3",
+  "description": "A block-based editor library",
+  "files": [
+    "dist",
+    "style.css"
+  ],
+  "type": "module",
+  "main": "./dist/blx.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/blx.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./style.css": "./style.css"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "lucide": "^0.575.0",
+    "prismjs": "^1.30.0"
+  },
+  "peerDependencies": {
+    "@automerge/automerge": "^3.0.0",
+    "mermaid": "^11.0.0",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0",
+    "@excalidraw/excalidraw": ">=0.18.0"
+  },
+  "peerDependenciesMeta": {
+    "@automerge/automerge": {
+      "optional": true
+    },
+    "mermaid": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "@excalidraw/excalidraw": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/prismjs": "^1.26.5",
+    "jsdom": "^28.0.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-wasm": "^3.5.0",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "vite build && pnpm run build:types",
+    "build:types": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}