sibujs 1.0.0-beta.1

package/dist/extras.d.cts

@@ -0,0 +1,2356 @@
+export { InfiniteQueryOptions, InfiniteQueryResult, LoaderRoute, MutationOptions, MutationResult, OfflineStore, OfflineStoreOptions, QueryOptions, QueryResult, Resource, ResourceOptions, RetryOptions, RouteLoaderFn, SyncAdapter, SyncChange, SyncResult, calculateDelay, clearQueryCache, createResource, createSyncAdapter, executeLoader, getQueryData, invalidateQueries, preloadRoute, sbDebounce, sbInfiniteQuery, sbLoaderData, sbMutation, sbOfflineStore, sbPrevious, sbQuery, sbSocket, sbStream, sbThrottle, setQueryData, withRetry } from './data.cjs';
+export { sbBattery, sbClipboard, sbColorScheme, sbDraggable, sbDropZone, sbGeo, sbIdle, sbMedia, sbOnline, sbPermissions, sbResize, sbScroll, sbTitle } from './browser.cjs';
+export { ComponentProps, GlobalStore, MachineConfig, MachineReturn, Middleware, OptimisticAction, PersistOptions, PropDef, PropSchema, RenderProp, Selector, TimeTravelReturn, Validator, assertType, compose, createComposable, createEffect, createGlobalStore, createGuard, createMemo, createSignal, createSlots, defineComponent, defineSlottedComponent, defineStrictComponent, sbMachine, sbOptimistic, sbOptimisticList, sbPersisted, sbTimeline, validateProps, validators, withBoundary, withDefaults, withProps, withWrapper } from './patterns.cjs';
+export { AnimationPreset, PresetOptions, SlideDirection, TransitionGroup, TransitionGroupOptions, TransitionOptions, animate, bounceIn, bounceOut, fadeIn, fadeOut, flipIn, pulse, sbReducedMotion, sbSpring, sbTransition, sbViewTransition, scaleDown, scaleUp, sequence, shake, slideIn, slideOut, stagger } from './motion.cjs';
+import { R as ReactiveSignal, T as TagProps } from './tagFactory-CZPO4RXF.cjs';
+
+type ValidatorFn<T = unknown> = (value: T) => string | null;
+interface FieldConfig<T = unknown> {
+    initial: T;
+    validators?: ValidatorFn<T>[];
+}
+type FormConfig<T extends Record<string, unknown>> = {
+    [K in keyof T]: FieldConfig<T[K]>;
+};
+interface FormField<T = unknown> {
+    value: () => T;
+    set: (v: T) => void;
+    error: () => string | null;
+    touched: () => boolean;
+    touch: () => void;
+    reset: () => void;
+}
+interface FormReturn<T extends Record<string, unknown>> {
+    fields: {
+        [K in keyof T]: FormField<T[K]>;
+    };
+    errors: () => Partial<Record<keyof T, string | null>>;
+    isValid: () => boolean;
+    isDirty: () => boolean;
+    touched: () => Partial<Record<keyof T, boolean>>;
+    values: () => T;
+    handleSubmit: (onSubmit: (values: T) => void | Promise<void>) => (e?: Event) => void;
+    reset: () => void;
+    setError: (field: keyof T, message: string) => void;
+}
+declare function required(message?: string): ValidatorFn<unknown>;
+declare function minLength(min: number, message?: string): ValidatorFn<string>;
+declare function maxLength(max: number, message?: string): ValidatorFn<string>;
+declare function matchesPattern(regex: RegExp, message?: string): ValidatorFn<string>;
+declare function email(message?: string): ValidatorFn<string>;
+declare function min(minVal: number, message?: string): ValidatorFn<number>;
+declare function max(maxVal: number, message?: string): ValidatorFn<number>;
+declare function custom<T>(fn: (value: T) => boolean, message: string): ValidatorFn<T>;
+declare function sbForm<T extends Record<string, unknown>>(config: FormConfig<T>): FormReturn<T>;
+
+interface VirtualListProps<T> {
+    items: () => T[];
+    itemHeight: number;
+    containerHeight: number;
+    overscan?: number;
+    renderItem: (item: T, index: number) => HTMLElement;
+    class?: string;
+}
+/**
+ * VirtualList renders only visible items for efficient large-list rendering.
+ */
+declare function VirtualList<T>(props: VirtualListProps<T>): HTMLElement;
+
+interface IntersectionResult {
+    isIntersecting: () => boolean;
+    intersectionRatio: () => number;
+    observe: (element: HTMLElement) => void;
+    unobserve: () => void;
+}
+/**
+ * sbIntersection provides reactive intersection observer state.
+ */
+declare function sbIntersection(options?: IntersectionObserverInit): IntersectionResult;
+/**
+ * Lazy-load utility using IntersectionObserver.
+ * Calls the loader function when element becomes visible.
+ */
+declare function lazyLoad(element: HTMLElement, loader: () => void, options?: IntersectionObserverInit): () => void;
+
+interface MaskOptions {
+    /** Pattern: 9 = digit, A = letter, * = any, other chars are literals */
+    pattern: string;
+    /** Placeholder character for unfilled positions */
+    placeholder?: string;
+}
+/**
+ * sbInputMask applies a mask to an input element.
+ * Returns reactive value and ref binding.
+ */
+declare function sbInputMask(options: MaskOptions): {
+    value: () => string;
+    rawValue: () => string;
+    bind: (input: HTMLInputElement) => void;
+};
+/** Phone number mask: (999) 999-9999 */
+declare function phoneMask(): MaskOptions;
+/** Date mask: 99/99/9999 */
+declare function dateMask(): MaskOptions;
+/** Credit card mask: 9999 9999 9999 9999 */
+declare function creditCardMask(): MaskOptions;
+/** Time mask: 99:99 */
+declare function timeMask(): MaskOptions;
+/** SSN mask: 999-99-9999 */
+declare function ssnMask(): MaskOptions;
+/** ZIP code mask: 99999 */
+declare function zipMask(): MaskOptions;
+
+/**
+ * sbAria applies reactive ARIA attributes to an element.
+ */
+declare function sbAria(element: HTMLElement, attrs: Record<string, string | boolean | (() => string | boolean)>): void;
+/**
+ * sbFocus manages focus state for an element.
+ */
+declare function sbFocus(): {
+    isFocused: () => boolean;
+    focus: () => void;
+    blur: () => void;
+    bind: (element: HTMLElement) => void;
+};
+/**
+ * FocusTrap traps focus within a container element.
+ * Tab cycling stays inside the container.
+ */
+declare function FocusTrap(nodes: HTMLElement, options?: {
+    autoFocus?: boolean;
+    restoreFocus?: boolean;
+}): HTMLElement;
+/**
+ * sbHotkey registers a keyboard shortcut handler.
+ * Returns a cleanup function.
+ */
+declare function sbHotkey(key: string, handler: (e: KeyboardEvent) => void, options?: {
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    global?: boolean;
+}): () => void;
+/**
+ * announce creates a screen reader announcement using ARIA live regions.
+ */
+declare function announce(message: string, priority?: "polite" | "assertive"): void;
+
+/**
+ * scopedStyle creates component-scoped CSS by generating a unique scope ID
+ * and prefixing all selectors.
+ * Returns the scope attribute name and injects the CSS into the document.
+ */
+declare function scopedStyle(css: string): {
+    scope: string;
+    attr: string;
+};
+/**
+ * withScopedStyle wraps a component function to auto-apply scoped styles.
+ * The component and all its children get the scope attribute.
+ */
+declare function withScopedStyle<P>(css: string, component: (props: P) => HTMLElement): (props: P) => HTMLElement;
+/**
+ * Removes a scoped style by its scope ID.
+ */
+declare function removeScopedStyle(scopeId: string): void;
+
+/**
+ * Bind multiple reactive attributes to an element.
+ * Each attribute value can be a static value or a reactive getter.
+ * Returns a single teardown function that stops all bindings.
+ */
+declare function bindAttrs(el: HTMLElement, attrs: Record<string, string | number | boolean | (() => string | number | boolean)>): () => void;
+/**
+ * Reactively toggle a boolean attribute (like disabled, readonly, hidden).
+ * When the value is truthy the attribute is present (set to ""),
+ * when falsy the attribute is removed entirely.
+ * Returns a teardown function to stop reactive tracking.
+ */
+declare function bindBoolAttr(el: HTMLElement, attr: string, getter: boolean | (() => boolean)): () => void;
+/**
+ * Bind a data-* attribute reactively.
+ * Shorthand for `bindAttribute(el, "data-<key>", getter)`.
+ * Returns a teardown function to stop reactive tracking.
+ */
+declare function bindData(el: HTMLElement, key: string, getter: string | (() => string)): () => void;
+
+/**
+ * sbDialog provides reactive dialog state management with escape-to-close support.
+ */
+declare function sbDialog(): {
+    open: () => void;
+    close: () => void;
+    isOpen: () => boolean;
+    toggle: () => void;
+};
+
+/**
+ * Toast notification system with auto-dismiss and max toast limits.
+ */
+interface Toast {
+    id: string;
+    message: string;
+    type?: "info" | "success" | "error" | "warning";
+}
+declare function sbToast(options?: {
+    duration?: number;
+    maxToasts?: number;
+}): {
+    toasts: () => Toast[];
+    show: (message: string, type?: Toast["type"]) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+};
+
+/**
+ * sbInfiniteScroll combines IntersectionObserver with a data-fetching trigger
+ * to implement infinite scroll behavior.
+ */
+declare function sbInfiniteScroll(options: {
+    onLoadMore: () => Promise<void>;
+    hasMore: () => boolean;
+    threshold?: number;
+}): {
+    sentinelRef: {
+        current: HTMLElement | null;
+    };
+    loading: () => boolean;
+    dispose: () => void;
+};
+
+/**
+ * sbPagination provides reactive pagination state and controls.
+ */
+declare function sbPagination(options: {
+    totalItems: () => number;
+    pageSize?: number;
+    initialPage?: number;
+}): {
+    page: () => number;
+    pageSize: () => number;
+    totalPages: () => number;
+    next: () => void;
+    prev: () => void;
+    goTo: (page: number) => void;
+    startIndex: () => number;
+    endIndex: () => number;
+};
+
+/**
+ * createEventBus creates a typed publish/subscribe event system.
+ * No reactive state needed -- pure event dispatching.
+ */
+declare function createEventBus<T extends Record<string, unknown>>(): {
+    on: <K extends keyof T>(event: K, handler: (data: T[K]) => void) => () => void;
+    emit: <K extends keyof T>(event: K, data: T[K]) => void;
+    off: <K extends keyof T>(event: K, handler: (data: T[K]) => void) => void;
+    clear: () => void;
+};
+
+declare const Priority: {
+    readonly IMMEDIATE: 0;
+    readonly USER_BLOCKING: 1;
+    readonly NORMAL: 2;
+    readonly LOW: 3;
+    readonly IDLE: 4;
+};
+type PriorityLevel = (typeof Priority)[keyof typeof Priority];
+/**
+ * Schedule an update with a given priority level.
+ * Returns a cancel function.
+ */
+declare function scheduleUpdate(priority: PriorityLevel, callback: () => void): () => void;
+/**
+ * Flush all pending tasks synchronously (useful for testing).
+ */
+declare function flushScheduler(): void;
+/**
+ * Get the number of pending tasks.
+ */
+declare function pendingTasks(): number;
+/**
+ * Yield control back to the main thread, allowing the browser to process
+ * user input, rendering, and other high-priority work.
+ *
+ * Uses `scheduler.yield()` when available (Chrome 115+),
+ * falls back to `setTimeout(0)`.
+ *
+ * @example
+ * ```ts
+ * for (let i = 0; i < items.length; i++) {
+ *   renderItem(items[i]);
+ *   if (i % 50 === 0) await yieldToMain();
+ * }
+ * ```
+ */
+declare function yieldToMain(): Promise<void>;
+/**
+ * Process an array in chunks, yielding to the main thread between chunks.
+ * Prevents long-running loops from blocking the UI.
+ *
+ * @param items Array of items to process
+ * @param processor Callback invoked for each item
+ * @param chunkSize Number of items per chunk before yielding (default: 50)
+ */
+declare function processInChunks<T>(items: T[], processor: (item: T, index: number) => void, chunkSize?: number): Promise<void>;
+
+/**
+ * Mark a state update as non-urgent.
+ * The callback is scheduled at NORMAL priority so it won't block
+ * high-priority work like user input handling.
+ */
+declare function startTransition(callback: () => void): void;
+/**
+ * Returns a deferred getter for a reactive value.
+ * The deferred value mirrors the source but updates at LOW priority,
+ * allowing the UI to remain responsive while expensive derived state
+ * catches up.
+ */
+declare function sbDeferredValue<T>(getter: () => T): () => T;
+/**
+ * Provides a `startTransition` wrapper paired with a reactive
+ * `isPending` flag that is `true` while the transition is in flight.
+ *
+ * Usage:
+ *   const [isPending, startTransition] = sbTransitionState();
+ *   startTransition(() => { setSomeState(newValue); });
+ *   if (isPending()) { // show spinner }
+ */
+declare function sbTransitionState(): [isPending: () => boolean, startTransition: (cb: () => void) => void];
+/**
+ * Reset the ID counter. Call at the start of each SSR request
+ * to ensure server and client produce matching IDs.
+ */
+declare function resetIdCounter(): void;
+/**
+ * Set a custom prefix for generated IDs.
+ * Useful when multiple SibuJS apps coexist on the same page.
+ */
+declare function setIdPrefix(prefix: string): void;
+/**
+ * Generate a unique, stable ID for use in accessibility attributes.
+ * SSR-compatible: call resetIdCounter() at the start of each SSR render
+ * to ensure server and client produce matching IDs.
+ *
+ * @param suffix Optional suffix appended to the generated ID
+ * @returns A unique ID string like "sibu-0", "sibu-1-label"
+ *
+ * @example
+ * ```ts
+ * const id = sbId();
+ * label({ htmlFor: id, nodes: "Name" });
+ * input({ id, type: "text" });
+ * ```
+ */
+declare function sbId(suffix?: string): string;
+
+/**
+ * DOMPool manages a pool of reusable DOM elements to reduce GC pressure.
+ */
+declare class DOMPool {
+    private pools;
+    private maxSize;
+    constructor(maxSize?: number);
+    /**
+     * Get a recycled element or create a new one.
+     */
+    acquire(tag: string): HTMLElement;
+    /**
+     * Return an element to the pool for reuse.
+     * Clears attributes, children, and event listeners.
+     */
+    release(element: HTMLElement): void;
+    /**
+     * Clear all pools.
+     */
+    clear(): void;
+    /**
+     * Get pool statistics.
+     */
+    stats(): Record<string, number>;
+}
+/** Default global pool instance */
+declare const domPool: DOMPool;
+/**
+ * Preloads a resource (script, style, or generic fetch).
+ */
+declare function preloadResource(url: string, type?: "script" | "style" | "fetch" | "image"): void;
+/**
+ * Prefetches a URL for future navigation.
+ */
+declare function prefetch(url: string): void;
+/**
+ * Preloads an image and returns a promise that resolves when loaded.
+ */
+declare function preloadImage(src: string): Promise<HTMLImageElement>;
+
+/**
+ * Bundle size optimization utilities for SibuJS.
+ * Provides markers and utilities for tree-shaking and dead code elimination.
+ */
+/**
+ * Mark a function as pure for tree-shaking.
+ * Bundlers (Rollup, esbuild, webpack) use this to eliminate unused code.
+ * Wraps a factory function with the PURE annotation.
+ */
+declare function pure<T>(fn: () => T): T;
+/**
+ * Conditional import helper for tree-shaking.
+ * Only includes the module in the bundle if the condition is true.
+ * In production builds, dead branches are eliminated.
+ */
+declare function conditional<T>(condition: boolean, loader: () => T): T | undefined;
+/**
+ * Feature flag helper for dead code elimination.
+ * Bundlers can statically replace these with true/false to eliminate dead code.
+ */
+declare const Features: {
+    readonly SSR: boolean;
+    readonly DEV: boolean;
+    readonly BROWSER: boolean;
+};
+/**
+ * Development-only code block. Eliminated in production builds
+ * when process.env.NODE_ENV is set to 'production'.
+ */
+declare function devOnly(fn: () => void): void;
+/**
+ * Marks an export as having no side effects.
+ * Used by module-level sideEffects annotation.
+ */
+declare function noSideEffect<T extends (...args: unknown[]) => unknown>(fn: T): T;
+
+/**
+ * Compiled optimizations for SibuJS.
+ * Provides markers and utilities for Svelte-style compile-time optimizations.
+ * These are hints for build tools and static analyzers.
+ */
+/**
+ * Marks a component's template as static (no reactive bindings).
+ * A build tool can pre-render this to a static HTML string and
+ * skip reactive setup entirely.
+ */
+declare function staticTemplate(html: string): HTMLElement;
+/**
+ * Clone a static template for efficient repeated rendering.
+ * Uses template.content.cloneNode(true) which is faster than createElement.
+ */
+declare function cloneTemplate(template: HTMLTemplateElement): DocumentFragment;
+/**
+ * Pre-compile a component factory.
+ * Caches the template and only applies dynamic bindings on each call.
+ */
+declare function precompile<Props>(templateHtml: string, hydrate: (el: HTMLElement, props: Props) => void): (props: Props) => HTMLElement;
+/**
+ * Marker for static expressions that can be hoisted out of reactive scopes.
+ * A compiler pass would extract these to module scope.
+ */
+declare function hoistable<T>(value: T): T;
+/**
+ * Marks a block of DOM creation as having a known, fixed structure.
+ * Enables block-level optimization where the compiler can generate
+ * optimized creation and patching code.
+ */
+declare function block(factory: () => HTMLElement): HTMLElement;
+
+/**
+ * Schema definition for entity normalization.
+ * Describes the shape of an entity type and its relationships.
+ */
+interface NormalizedSchema {
+    /** Name of the entity type (e.g. "user", "post") */
+    name: string;
+    /** Key used as the unique identifier. Defaults to "id" */
+    idKey?: string;
+    /** Map of relation field names to their entity type names */
+    relations?: Record<string, string>;
+}
+/** Internal normalized state shape, following the ids + entities pattern */
+interface NormalizedState<T> {
+    ids: string[];
+    entities: Record<string, T>;
+}
+/** Actions returned by createNormalizedStore */
+interface NormalizedStoreActions<T> {
+    /** Add a single entity to the store */
+    add(entity: T): void;
+    /** Add multiple entities to the store */
+    addMany(entities: T[]): void;
+    /** Get an entity by its id, or undefined if not found */
+    get(id: string): T | undefined;
+    /** Get all entities as an array */
+    getAll(): T[];
+    /** Update an entity by merging a partial object */
+    update(id: string, partial: Partial<T>): void;
+    /** Remove an entity by id */
+    remove(id: string): void;
+    /** Query entities matching a predicate */
+    select(predicate: (entity: T) => boolean): T[];
+    /** Get the raw normalized state (reactive getter) */
+    getState(): NormalizedState<T>;
+}
+/**
+ * createNormalizedStore creates a reactive normalized store for a single
+ * entity type. Internal storage uses the `{ ids, entities }` pattern
+ * (like Redux Toolkit's entity adapter) backed by sbSignal for reactivity.
+ *
+ * @param schema Schema describing the entity type
+ * @returns Store actions for CRUD and query operations
+ *
+ * @example
+ * ```ts
+ * const users = createNormalizedStore<User>({ name: "user" });
+ *
+ * users.add({ id: "1", name: "Alice" });
+ * users.addMany([
+ *   { id: "2", name: "Bob" },
+ *   { id: "3", name: "Charlie" },
+ * ]);
+ *
+ * const alice = users.get("1");       // { id: "1", name: "Alice" }
+ * const all = users.getAll();         // [Alice, Bob, Charlie]
+ * users.update("1", { name: "Alicia" });
+ * users.remove("3");
+ * const bobs = users.select(u => u.name.startsWith("B"));
+ * ```
+ */
+declare function createNormalizedStore<T extends Record<string, unknown>>(schema: NormalizedSchema): NormalizedStoreActions<T>;
+/** A map of entity type names to their flat entity tables */
+type NormalizedEntities = Record<string, Record<string, unknown>>;
+/** Result of normalizing nested data */
+interface NormalizeResult {
+    /** The top-level id (or array of ids) of the normalized data */
+    result: string | string[];
+    /** All extracted entities keyed by type name, then by id */
+    entities: NormalizedEntities;
+}
+/**
+ * normalize takes a nested data object (or array) and flattens it into
+ * a normalized entities map according to the provided schema.
+ *
+ * Relations defined in the schema are recursively extracted and replaced
+ * with their id references.
+ *
+ * @param data The nested data to normalize (single object or array)
+ * @param schema The schema describing entity shape and relations
+ * @returns A NormalizeResult with the top-level id(s) and all entities
+ *
+ * @example
+ * ```ts
+ * const postSchema: NormalizedSchema = {
+ *   name: "post",
+ *   relations: { author: "user", comments: "comment" },
+ * };
+ *
+ * const data = {
+ *   id: "p1",
+ *   title: "Hello",
+ *   author: { id: "u1", name: "Alice" },
+ *   comments: [
+ *     { id: "c1", text: "Great!" },
+ *     { id: "c2", text: "Thanks" },
+ *   ],
+ * };
+ *
+ * const { result, entities } = normalize(data, postSchema);
+ * // result === "p1"
+ * // entities.post["p1"] === { id: "p1", title: "Hello", author: "u1", comments: ["c1", "c2"] }
+ * // entities.user["u1"] === { id: "u1", name: "Alice" }
+ * // entities.comment["c1"] === { id: "c1", text: "Great!" }
+ * ```
+ */
+declare function normalize<T extends Record<string, unknown>>(data: T | T[], schema: NormalizedSchema): NormalizeResult;
+/**
+ * denormalize reconstructs a nested object from a flat normalized entities
+ * map, resolving relation references back to their full objects.
+ *
+ * @param id The id of the root entity to reconstruct
+ * @param entities The flat entities map (from normalize or manual construction)
+ * @param schema The schema describing entity shape and relations
+ * @returns The fully reconstructed nested object, or undefined if not found
+ *
+ * @example
+ * ```ts
+ * const post = denormalize("p1", entities, postSchema);
+ * // post.author is the full user object, not just "u1"
+ * // post.comments is an array of full comment objects
+ * ```
+ */
+declare function denormalize<T extends Record<string, unknown>>(id: string, entities: NormalizedEntities, schema: NormalizedSchema): T | undefined;
+
+/**
+ * Advanced runtime chunk loading with caching strategies for SibuJS.
+ * Provides configurable caching, preloading, retry logic, and loading orchestration.
+ */
+interface ChunkConfig {
+    /** Maximum number of cached chunks */
+    maxCacheSize?: number;
+    /** Cache TTL in milliseconds (0 = no expiry) */
+    cacheTTL?: number;
+    /** Number of retry attempts on failure */
+    retries?: number;
+    /** Delay between retries in ms */
+    retryDelay?: number;
+    /** Timeout for chunk loading in ms */
+    timeout?: number;
+    /** Called when a chunk starts loading */
+    onLoadStart?: (id: string) => void;
+    /** Called when a chunk finishes loading */
+    onLoadEnd?: (id: string) => void;
+    /** Called when a chunk fails to load */
+    onLoadError?: (id: string, error: Error) => void;
+}
+/**
+ * Central registry for managing dynamic chunks with caching and lifecycle callbacks.
+ */
+declare function createChunkRegistry(config?: ChunkConfig): {
+    /**
+     * Load a chunk by ID. Uses cache if available, otherwise loads via the provided loader.
+     */
+    load<T>(id: string, loader: () => Promise<T>): Promise<T>;
+    /**
+     * Preload a chunk without blocking. Silently caches for later use.
+     */
+    preload<T>(id: string, loader: () => Promise<T>): void;
+    /**
+     * Preload multiple chunks in parallel.
+     */
+    preloadAll(entries: Array<{
+        id: string;
+        loader: () => Promise<unknown>;
+    }>): void;
+    /**
+     * Check if a chunk is cached and valid.
+     */
+    has(id: string): boolean;
+    /**
+     * Get a cached chunk synchronously. Returns undefined if not cached.
+     */
+    get<T>(id: string): T | undefined;
+    /**
+     * Invalidate a cached chunk.
+     */
+    invalidate(id: string): void;
+    /**
+     * Clear all cached chunks.
+     */
+    clear(): void;
+    /**
+     * Get cache statistics.
+     */
+    stats(): {
+        size: number;
+        maxSize: number;
+        pending: number;
+        preloaded: number;
+    };
+};
+/**
+ * Create a lazy-loaded component that uses the chunk registry for caching.
+ * Provides automatic retry, timeout, and cache management.
+ */
+declare function lazyChunk(id: string, loader: () => Promise<{
+    default: () => HTMLElement;
+} | (() => HTMLElement)>, registry: ReturnType<typeof createChunkRegistry>, fallback?: () => HTMLElement): () => HTMLElement;
+/**
+ * Preload ES modules using link[rel=modulepreload].
+ * Improves loading performance by informing the browser early.
+ */
+declare function preloadModule(url: string): void;
+/**
+ * Preload multiple modules.
+ */
+declare function preloadModules(urls: string[]): void;
+
+interface HeadProps {
+    title?: string | (() => string);
+    meta?: Record<string, string | (() => string)>[];
+    link?: Record<string, string>[];
+    script?: Record<string, string>[];
+    base?: {
+        href?: string;
+        target?: string;
+    };
+}
+/**
+ * Head() manages document <head> tags reactively.
+ * Supports dynamic title, meta tags, link tags, and structured data.
+ * Cleans up managed elements when called again.
+ */
+declare function Head(props: HeadProps): Comment;
+/**
+ * Sets structured data (JSON-LD) for SEO.
+ */
+declare function setStructuredData(data: Record<string, unknown>): void;
+/**
+ * Sets the canonical URL for the page.
+ */
+declare function setCanonical(url: string): void;
+
+/**
+ * Converts an HTMLElement tree to an HTML string for server-side rendering.
+ */
+declare function renderToString(element: HTMLElement | DocumentFragment | Node): string;
+/**
+ * Hydrates a server-rendered DOM tree by attaching event listeners
+ * and activating reactive bindings.
+ */
+declare function hydrate(component: () => HTMLElement, container: HTMLElement): void;
+/**
+ * Renders a component to a full HTML document string.
+ *
+ * **Security warning:** `headExtra` is injected as raw HTML into the document head.
+ * Never pass unsanitized user input to `headExtra` — it is intended for trusted,
+ * developer-controlled content only (e.g. inline styles, custom meta tags).
+ */
+declare function renderToDocument(component: () => HTMLElement, options?: {
+    title?: string;
+    meta?: Record<string, string>[];
+    links?: Record<string, string>[];
+    scripts?: string[];
+    bodyAttrs?: Record<string, string>;
+    /** Raw HTML injected into <head>. Must not contain unsanitized user input. */
+    headExtra?: string;
+}): string;
+/**
+ * Renders a component tree to an async iterable of HTML chunks.
+ * Enables progressive server-side rendering — the consumer can write
+ * each chunk to a response stream as it becomes available.
+ */
+declare function renderToStream(element: HTMLElement | DocumentFragment | Node): AsyncGenerator<string>;
+/**
+ * Collects the full output of renderToStream into a string.
+ */
+declare function collectStream(stream: AsyncGenerator<string> | AsyncIterable<string>): Promise<string>;
+/**
+ * Renders a component tree to a Web ReadableStream<string>.
+ * Compatible with Node 18+, Deno, and edge runtimes.
+ * Uses pull-based backpressure — chunks are produced on demand.
+ */
+declare function renderToReadableStream(element: HTMLElement | DocumentFragment | Node): ReadableStream<string>;
+/**
+ * Marks an element as a hydration island. During partial hydration
+ * only elements marked with `data-sibu-island` will be hydrated.
+ */
+declare function island(id: string, component: () => HTMLElement): HTMLElement;
+/**
+ * Hydrate only elements marked as islands (`data-sibu-island`).
+ * Non-island content keeps its server-rendered HTML untouched.
+ */
+declare function hydrateIslands(container: HTMLElement, islands: Record<string, () => HTMLElement>): void;
+/**
+ * Progressively hydrate islands only when they enter the viewport.
+ * Uses IntersectionObserver to defer hydration of off-screen islands,
+ * reducing initial JavaScript execution cost.
+ *
+ * Returns a cleanup function that disconnects all observers.
+ */
+declare function hydrateProgressively(container: HTMLElement, islands: Record<string, () => HTMLElement>, options?: IntersectionObserverInit): () => void;
+/**
+ * Reset SSR state between requests. Call at the start of each SSR render
+ * to prevent ID drift in long-lived server processes.
+ */
+declare function resetSSRState(): void;
+/**
+ * Create a suspense boundary for SSR streaming.
+ * Renders fallback HTML inline and returns a promise for the resolved content.
+ *
+ * The returned element contains the fallback UI with a `data-sibu-suspense-id`
+ * marker. The promise resolves to `{ id, html }` once async content is ready.
+ */
+declare function ssrSuspense(props: {
+    fallback: () => HTMLElement;
+    content: () => Promise<HTMLElement>;
+}): {
+    element: HTMLElement;
+    promise: Promise<{
+        id: string;
+        html: string;
+    }>;
+};
+/**
+ * Generate an inline script that swaps a suspense fallback with resolved content.
+ * The id is escaped for both JS string and HTML attribute contexts to prevent injection.
+ */
+declare function suspenseSwapScript(id: string): string;
+/**
+ * Renders a component tree with suspense boundaries as a stream.
+ * Yields the main tree HTML first (including fallback content for suspended
+ * boundaries), then flushes resolved content with inline swap scripts.
+ */
+declare function renderToSuspenseStream(element: HTMLElement | DocumentFragment | Node, pendingBoundaries?: Promise<{
+    id: string;
+    html: string;
+}>[]): AsyncGenerator<string>;
+/**
+ * Serialize application state into an HTML script tag for SSR.
+ * The serialized data is embedded in the document and picked up
+ * on the client with `deserializeState()`.
+ */
+declare function serializeState(state: Record<string, unknown>): string;
+/**
+ * Retrieve state that was embedded by `serializeState()` during SSR.
+ */
+declare function deserializeState<T = Record<string, unknown>>(): T | undefined;
+
+interface CustomElementOptions {
+    shadow?: boolean;
+    mode?: "open" | "closed";
+    styles?: string;
+    observedAttributes?: string[];
+    extends?: string;
+}
+/**
+ * defineElement creates a Web Component wrapping a SibuJS component function.
+ */
+declare function defineElement(name: string, component: (props: Record<string, unknown>, element: HTMLElement) => HTMLElement, options?: CustomElementOptions): void;
+/**
+ * Creates an SVG element with proper namespace.
+ */
+declare function svgElement(tag: string, props?: Record<string, unknown>, ...nodes: (SVGElement | string)[]): SVGElement;
+
+interface UseWorkerReturn<TInput, TOutput> {
+    post(data: TInput): void;
+    result: () => TOutput | null;
+    error: () => Error | null;
+    loading: () => boolean;
+    terminate(): void;
+}
+/**
+ * sbWorker creates a Web Worker from an inline function and provides
+ * reactive state for its result, error, and loading status.
+ *
+ * The workerFn receives messages via the standard `onmessage` handler
+ * and should call `postMessage` to send results back. It is serialized
+ * into a Blob URL, so it must be self-contained (no closures).
+ *
+ * @param workerFn The function body to run inside the worker.
+ *                 It receives `self` as the worker global scope.
+ * @returns An object with post, result, error, loading, and terminate.
+ */
+declare function sbWorker<TInput = unknown, TOutput = unknown>(workerFn: (e: MessageEvent<TInput>) => void): UseWorkerReturn<TInput, TOutput>;
+interface UseWorkerFnReturn<TArgs extends unknown[], TResult> {
+    run(...args: TArgs): Promise<TResult>;
+    loading: () => boolean;
+    terminate(): void;
+}
+/**
+ * sbWorkerFn wraps a pure function so it runs inside a Web Worker.
+ *
+ * The function must be self-contained -- it cannot reference variables
+ * from the outer scope. Arguments are serialized via postMessage.
+ *
+ * @param fn A pure function to execute in a worker thread.
+ * @returns An object with run, loading, and terminate.
+ */
+declare function sbWorkerFn<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => TResult): UseWorkerFnReturn<TArgs, TResult>;
+interface WorkerPool<TInput, TOutput> {
+    execute(data: TInput): Promise<TOutput>;
+    terminate(): void;
+}
+/**
+ * createWorkerPool creates a pool of workers for parallel task execution.
+ *
+ * Tasks are distributed across workers using round-robin scheduling.
+ * Each worker is created from the same inline function.
+ *
+ * @param workerFn The function body to run inside each worker.
+ * @param poolSize Number of workers in the pool (defaults to navigator.hardwareConcurrency or 4).
+ * @returns An object with execute and terminate.
+ */
+declare function createWorkerPool<TInput = unknown, TOutput = unknown>(workerFn: (e: MessageEvent<TInput>) => void, poolSize?: number): WorkerPool<TInput, TOutput>;
+
+/**
+ * WebAssembly integration for SibuJS.
+ * Provides hooks and utilities to load, cache, and use WASM modules
+ * for performance-critical operations.
+ */
+interface WasmModuleState<T extends Record<string, unknown> = Record<string, unknown>> {
+    /** The instantiated WASM module exports, null until loaded */
+    instance: T | null;
+    /** Loading state */
+    loading: boolean;
+    /** Error if loading failed */
+    error: Error | null;
+    /** Whether the module has been loaded successfully */
+    ready: boolean;
+}
+interface WasmConfig {
+    /** Import object passed to WebAssembly.instantiate */
+    imports?: WebAssembly.Imports;
+    /** Cache key for module caching (defaults to URL) */
+    cacheKey?: string;
+}
+/**
+ * Hook to load and use a WebAssembly module reactively.
+ * Returns reactive state that updates when the module loads.
+ *
+ * @example
+ * ```ts
+ * const wasm = sbWasm<{ add: (a: number, b: number) => number }>('/math.wasm');
+ * // In reactive context:
+ * if (wasm.ready()) {
+ *   const result = wasm.instance()!.add(1, 2);
+ * }
+ * ```
+ */
+declare function sbWasm<T extends Record<string, unknown> = Record<string, unknown>>(source: string | ArrayBuffer | Uint8Array, config?: WasmConfig): {
+    instance: () => T | null;
+    loading: () => boolean;
+    error: () => Error | null;
+    ready: () => boolean;
+    reload: () => Promise<void>;
+};
+/**
+ * Load and instantiate a WebAssembly module.
+ * Supports loading from URL, ArrayBuffer, or Uint8Array.
+ * Caches compiled modules for reuse.
+ */
+declare function loadWasmModule(source: string | ArrayBuffer | Uint8Array, imports?: WebAssembly.Imports, cacheKey?: string): Promise<WebAssembly.Instance>;
+/**
+ * Preload and compile a WASM module without instantiating it.
+ * The compiled module is cached for instant instantiation later.
+ */
+declare function preloadWasm(url: string): Promise<void>;
+/**
+ * Create a type-safe bridge to a WASM module with automatic memory management.
+ * Provides helpers for passing strings and arrays between JS and WASM.
+ */
+declare function createWasmBridge<T extends Record<string, unknown>>(instance: WebAssembly.Instance): {
+    exports: T;
+    memory: WebAssembly.Memory;
+    /** Allocate bytes in WASM memory (requires WASM to export malloc) */
+    alloc: (size: number) => number;
+    /** Free allocated memory (requires WASM to export free) */
+    free: (ptr: number) => void;
+    /** Write a string to WASM memory, returns pointer */
+    writeString: (str: string) => {
+        ptr: number;
+        len: number;
+    };
+    /** Read a string from WASM memory */
+    readString: (ptr: number, len: number) => string;
+    /** Write a typed array to WASM memory, returns pointer */
+    writeArray: (arr: ArrayLike<number>) => {
+        ptr: number;
+        len: number;
+    };
+    /** Read a Float64Array from WASM memory */
+    readF64Array: (ptr: number, len: number) => Float64Array;
+};
+/**
+ * Clear all cached WASM modules and instances.
+ */
+declare function clearWasmCache(): void;
+/**
+ * Check if a WASM module is cached.
+ */
+declare function isWasmCached(key: string): boolean;
+
+interface MicroAppConfig {
+    /** Unique name for this micro-frontend instance */
+    name: string;
+    /** Optional host element to mount into. Defaults to a new div. */
+    container?: HTMLElement;
+    /** If true, use Shadow DOM for style isolation */
+    shadow?: boolean;
+}
+interface MicroApp {
+    /** Mount a component into this micro-app container */
+    mount(component: () => HTMLElement): void;
+    /** Unmount the currently rendered component and clean up */
+    unmount(): void;
+    /** The outer host element */
+    element: HTMLElement;
+}
+interface SharedScope<T extends Record<string, unknown>> {
+    /** Get the current value for a key */
+    get<K extends keyof T>(key: K): T[K];
+    /** Set a value for a key, notifying all subscribers */
+    set<K extends keyof T>(key: K, value: T[K]): void;
+    /** Subscribe to changes on a specific key. Returns an unsubscribe function. */
+    subscribe<K extends keyof T>(key: K, callback: (value: T[K]) => void): () => void;
+}
+/**
+ * Creates an isolated micro-frontend container.
+ *
+ * Each micro-app gets its own DOM boundary. When `shadow: true` is set the
+ * component renders inside a Shadow DOM root so its styles are fully isolated
+ * from the host page.
+ *
+ * @example
+ * ```ts
+ * const app = createMicroApp({ name: "widget", shadow: true });
+ * document.body.appendChild(app.element);
+ *
+ * app.mount(() => div({ nodes: "Hello from micro-app!" }));
+ *
+ * // Later, tear it down:
+ * app.unmount();
+ * ```
+ */
+declare function createMicroApp(config: MicroAppConfig): MicroApp;
+/**
+ * Dynamically load a remote ES module by URL.
+ *
+ * Modules are cached by URL so repeated calls with the same URL return the
+ * same promise without issuing another network request.
+ *
+ * @example
+ * ```ts
+ * const charts = await loadRemoteModule("https://cdn.example.com/charts.js");
+ * const el = charts.BarChart({ data: [1, 2, 3] });
+ * ```
+ */
+declare function loadRemoteModule(url: string): Promise<unknown>;
+type Component = () => HTMLElement;
+type RemoteLoader = () => Promise<{
+    default: Component;
+}>;
+/**
+ * Register a remote component that loads on demand.
+ *
+ * Returns a component factory function. On first call it shows a loading
+ * placeholder, fetches the remote module, then swaps in the real component.
+ * Subsequent calls render instantly from the cached module.
+ *
+ * @example
+ * ```ts
+ * const RemoteHeader = defineRemoteComponent(
+ *   "remote-header",
+ *   () => loadRemoteModule("https://cdn.example.com/header.js")
+ * );
+ *
+ * // Use it like any local component
+ * document.body.appendChild(RemoteHeader());
+ * ```
+ */
+declare function defineRemoteComponent(name: string, loader: RemoteLoader): Component;
+/**
+ * Create a shared state scope that enables communication between independent
+ * micro-frontend instances.
+ *
+ * Each key in the scope can be read, written, and subscribed to independently.
+ * This is intentionally kept simpler than a full global store so micro-apps
+ * can share data with minimal coupling.
+ *
+ * @example
+ * ```ts
+ * const shared = createSharedScope({ user: null, theme: "light" });
+ *
+ * // Micro-app A sets a value
+ * shared.set("user", { name: "Alice" });
+ *
+ * // Micro-app B subscribes to changes
+ * const unsub = shared.subscribe("user", (user) => {
+ *   console.log("User changed:", user);
+ * });
+ *
+ * // Later
+ * unsub();
+ * ```
+ */
+declare function createSharedScope<T extends Record<string, unknown>>(initialState: T): SharedScope<T>;
+
+interface ServiceWorkerState {
+    registration: () => ServiceWorkerRegistration | null;
+    isReady: () => boolean;
+    isUpdateAvailable: () => boolean;
+    error: () => Error | null;
+    update: () => Promise<void>;
+    unregister: () => Promise<boolean>;
+}
+/**
+ * sbServiceWorker registers and manages a service worker.
+ */
+declare function sbServiceWorker(scriptUrl: string, options?: RegistrationOptions): ServiceWorkerState;
+
+interface SSGOptions {
+    routes: string[];
+    renderFn: (path: string) => Promise<string>;
+    outDir?: string;
+}
+interface SSGResult {
+    pages: Array<{
+        path: string;
+        html: string;
+    }>;
+    errors: Array<{
+        path: string;
+        error: Error;
+    }>;
+}
+/**
+ * Generate a static site by iterating over routes and collecting rendered HTML.
+ * This is a pure async function — it does NOT write files, only returns results.
+ */
+declare function generateStaticSite(options: SSGOptions): Promise<SSGResult>;
+
+interface ISROptions<T> {
+    revalidateAfter: number;
+    fetcher: () => Promise<T>;
+    initialData?: T;
+}
+/**
+ * Creates an Incremental Static Regeneration (ISR) resource.
+ * Data is fetched initially, then automatically revalidated after the
+ * specified interval using setInterval.
+ */
+declare function createISR<T>(options: ISROptions<T>): {
+    data: () => T | undefined;
+    isStale: () => boolean;
+    revalidate: () => Promise<void>;
+    dispose: () => void;
+};
+
+type ActionFn<T = unknown> = (data: FormData | Record<string, unknown>) => Promise<T>;
+interface ActionResult<T> {
+    data: () => T | undefined;
+    error: () => Error | undefined;
+    loading: () => boolean;
+    submit: (data: FormData | Record<string, unknown>) => Promise<T>;
+}
+/**
+ * Creates a managed action for handling POST/PUT/DELETE-style mutations.
+ * Provides reactive loading, error, and data state via sbSignal.
+ * State updates are batched to avoid redundant notifications.
+ */
+declare function createAction<T>(actionFn: ActionFn<T>): ActionResult<T>;
+
+interface ScrollRestorationOptions {
+    mode?: "auto" | "manual";
+}
+/**
+ * Manages scroll position saving and restoration keyed by route/key.
+ * Uses a Map to store positions and window.scrollTo to restore them.
+ */
+declare function sbScrollRestoration(options?: ScrollRestorationOptions): {
+    save: (key: string) => void;
+    restore: (key: string) => void;
+    getPosition: (key: string) => {
+        x: number;
+        y: number;
+    } | undefined;
+    dispose: () => void;
+};
+
+type MiddlewareFn = (context: {
+    path: string;
+    params: Record<string, string>;
+}, next: () => void | Promise<void>) => void | Promise<void>;
+/**
+ * Composes multiple middleware functions into a single middleware.
+ * Each middleware must call next() to proceed to the next one.
+ */
+declare function composeMiddleware(...fns: MiddlewareFn[]): MiddlewareFn;
+/**
+ * Creates a middleware chain with a builder API.
+ * Use `use()` to add middleware, and `run()` to execute the chain.
+ */
+declare function createMiddlewareChain(): {
+    use: (fn: MiddlewareFn) => void;
+    run: (context: {
+        path: string;
+        params: Record<string, string>;
+    }) => Promise<void>;
+};
+
+interface PluginContext {
+    /** Register a global hook */
+    onInit: (callback: () => void) => void;
+    onMount: (callback: (element: HTMLElement) => void) => void;
+    onUnmount: (callback: (element: HTMLElement) => void) => void;
+    onError: (callback: (error: Error) => void) => void;
+    /** Provide a value globally */
+    provide: (key: string, value: unknown) => void;
+}
+interface SibuPlugin {
+    name: string;
+    install: (ctx: PluginContext, options?: unknown) => void;
+}
+/**
+ * Creates a plugin definition.
+ */
+declare function createPlugin(name: string, install: (ctx: PluginContext, options?: unknown) => void): SibuPlugin;
+/**
+ * Installs a plugin into the application.
+ */
+declare function sbPlugin(plugin: SibuPlugin, options?: unknown): void;
+/**
+ * Retrieve a value provided by a plugin.
+ */
+declare function inject<T = unknown>(key: string, defaultValue?: T): T;
+/**
+ * Trigger mount hooks for an element.
+ */
+declare function triggerPluginMount(element: HTMLElement): void;
+/**
+ * Trigger unmount hooks for an element.
+ */
+declare function triggerPluginUnmount(element: HTMLElement): void;
+/**
+ * Trigger error hooks.
+ */
+declare function triggerPluginError(error: Error): void;
+/**
+ * Reset all plugins (useful for testing).
+ */
+declare function resetPlugins(): void;
+
+/**
+ * Modular distribution utilities for SibuJS.
+ * Enables granular imports and micro-package consumption patterns.
+ */
+/**
+ * Module registry for tracking available modules and their dependencies.
+ * Supports lazy initialization and automatic dependency resolution.
+ */
+declare function createModuleRegistry(): {
+    /** Register a module with its factory function and optional dependencies */
+    register(name: string, factory: () => unknown, deps?: string[]): void;
+    /** Resolve a module, loading its dependencies first */
+    resolve<T = unknown>(name: string): T;
+    /** Check if a module is registered */
+    has(name: string): boolean;
+    /** List all registered module names */
+    list(): string[];
+    /** Get the full dependency graph (transitive) for a module */
+    deps(name: string): string[];
+    /** Reset all loaded modules back to unloaded state (useful for testing) */
+    reset(): void;
+};
+/**
+ * Create a subset bundle containing only specified modules.
+ * Each key maps to a factory function that is invoked lazily on first access.
+ * Returns an object with only the requested exports.
+ */
+declare function createBundle<T extends Record<string, unknown>>(modules: Record<string, () => unknown>): T;
+/**
+ * Lazy module loader that only imports a module when first accessed.
+ * Uses ES module dynamic import under the hood.
+ * Caches the result after the first successful load.
+ */
+declare function lazyModule<T>(loader: () => Promise<T>): {
+    get: () => Promise<T>;
+    loaded: boolean;
+};
+/**
+ * Package metadata for distribution tooling.
+ * Provides entry point information and can generate Node.js subpath exports maps.
+ */
+declare const packageInfo: {
+    name: string;
+    version: string;
+    entryPoints: Record<string, string>;
+    /**
+     * Generate a package.json `exports` map for Node.js subpath exports.
+     * Maps each entry point to its import, require, and types paths.
+     */
+    generateExportsMap(): Record<string, {
+        import: string;
+        require: string;
+        types: string;
+    }>;
+};
+
+/**
+ * Ecosystem integration utilities for SibuJS.
+ * Provides adapters for common testing frameworks, bundlers, and CI/CD pipelines.
+ */
+/**
+ * Create a test harness for SibuJS components.
+ * Works with any testing framework (Vitest, Jest, Mocha).
+ */
+declare function createTestHarness(): {
+    /** Set up a clean DOM container before each test */
+    setup(): HTMLElement;
+    /** Tear down the DOM container after each test */
+    teardown(): void;
+    /** Render a component into the test container */
+    render(component: (() => HTMLElement) | HTMLElement): HTMLElement;
+    /** Get the test container */
+    getContainer(): HTMLElement;
+    /** Wait for reactive updates to settle */
+    flush(): Promise<void>;
+    /** Query within the container */
+    query(selector: string): Element | null;
+    /** Query all matching elements within the container */
+    queryAll(selector: string): Element[];
+    /** Simulate a click event */
+    click(el: Element): void;
+    /** Simulate input value change */
+    input(el: HTMLInputElement, value: string): void;
+};
+/**
+ * Metadata for bundler plugins to consume.
+ * Provides information about SibuJS module structure for tree-shaking optimization.
+ */
+declare const bundlerMetadata: {
+    name: "sibu";
+    sideEffects: false;
+    modules: Record<string, string[]>;
+    /** Generate import map for module resolution */
+    generateImportMap(base?: string): Record<string, string>;
+};
+/**
+ * Health check utility for CI/CD pipelines.
+ * Verifies that the framework is properly installed and configured.
+ */
+declare function healthCheck(): {
+    status: "ok" | "warning" | "error";
+    checks: Array<{
+        name: string;
+        passed: boolean;
+        message: string;
+    }>;
+};
+/**
+ * Environment detection utilities.
+ */
+declare const env: {
+    /** True when running in a browser with a DOM */
+    isBrowser: boolean;
+    /** True when running in Node.js */
+    isNode: boolean;
+    /** True when running inside a Web Worker */
+    isWorker: boolean;
+    /** True when running inside Deno */
+    isDeno: boolean;
+    /** True when running inside Bun */
+    isBun: boolean;
+    /** True when no window object is available (server-side rendering) */
+    isSSR: boolean;
+    /** True when NODE_ENV is not "production" */
+    isDev: boolean;
+    /** True when NODE_ENV is "test" or VITEST is set */
+    isTest: boolean;
+};
+
+/**
+ * Versioning and migration utilities for SibuJS applications.
+ * Provides semantic version management, migration tooling, and compatibility checks.
+ */
+/** Semantic version representation */
+interface SemVer {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease?: string;
+}
+/** Migration definition */
+interface Migration {
+    version: string;
+    description: string;
+    up: () => void | Promise<void>;
+    down?: () => void | Promise<void>;
+}
+/**
+ * Framework version constant.
+ */
+declare const VERSION = "1.0.0";
+/**
+ * Parse a semantic version string into components.
+ */
+declare function parseSemVer(version: string): SemVer;
+/**
+ * Compare two semantic versions.
+ * Returns -1 if a < b, 0 if a === b, 1 if a > b.
+ */
+declare function compareSemVer(a: string | SemVer, b: string | SemVer): -1 | 0 | 1;
+/**
+ * Check if a version satisfies a semver range (supports ^, ~, >=, <=, =).
+ */
+declare function satisfies(version: string, range: string): boolean;
+/**
+ * Create a migration runner for managing schema/state version upgrades.
+ */
+declare function createMigrationRunner(config: {
+    /** Current version of the app/data */
+    currentVersion: string;
+    /** Storage key for persisting applied migration version */
+    storageKey?: string;
+    /** Available migrations, sorted by version */
+    migrations: Migration[];
+}): {
+    /** Get the last applied migration version from storage */
+    getAppliedVersion(): string | null;
+    /** Get pending migrations that haven't been applied */
+    getPending(): Migration[];
+    /** Run all pending migrations in order */
+    migrate(): Promise<{
+        applied: string[];
+        errors: Array<{
+            version: string;
+            error: Error;
+        }>;
+    }>;
+    /** Rollback to a specific version */
+    rollback(targetVersion: string): Promise<{
+        rolledBack: string[];
+    }>;
+};
+/**
+ * Check compatibility between framework version and app version.
+ */
+declare function checkCompatibility(frameworkVersion: string, requiredRange: string): {
+    compatible: boolean;
+    message: string;
+};
+
+/**
+ * Critical resource preloader — ensures key assets are loaded before rendering.
+ * Generates <link rel="preload"> tags for critical resources and appends them
+ * to the document head.
+ */
+declare function preloadCritical(resources: Array<{
+    href: string;
+    as: "script" | "style" | "font" | "image" | "fetch";
+    type?: string;
+    crossOrigin?: "anonymous" | "use-credentials";
+}>): void;
+/**
+ * Prerender a set of routes for instant navigation.
+ * Renders components to HTML using `renderToString` and caches them.
+ * Supports TTL-based expiry and maximum cache size limits.
+ */
+declare function prerenderRoutes(routes: Array<{
+    path: string;
+    component: () => HTMLElement;
+}>, options?: {
+    maxCacheSize?: number;
+    cacheTTL?: number;
+}): {
+    /** Get cached HTML for a route, or undefined if not cached or expired */
+    get(path: string): string | undefined;
+    /** Check if a route has been prerendered and is still valid */
+    has(path: string): boolean;
+    /** Invalidate a cached route */
+    invalidate(path: string): void;
+    /** Clear all cached routes */
+    clear(): void;
+    /** Get cache statistics */
+    stats(): {
+        size: number;
+        routes: string[];
+    };
+};
+/**
+ * SSR response cache for frequently accessed routes.
+ * Supports TTL-based expiry and max size limits.
+ * Tracks hit/miss statistics for monitoring.
+ */
+declare function createSSRCache(config?: {
+    maxSize?: number;
+    defaultTTL?: number;
+}): {
+    /** Get cached HTML for a key, or undefined if not cached or expired */
+    get(key: string): string | undefined;
+    /** Cache an HTML string with an optional TTL override */
+    set(key: string, html: string, ttl?: number): void;
+    /** Check if a key exists in the cache and is still valid */
+    has(key: string): boolean;
+    /** Invalidate a cached entry */
+    invalidate(key: string): void;
+    /** Clear all cached entries and reset statistics */
+    clear(): void;
+    /** Get cache statistics including hit/miss counts */
+    stats(): {
+        size: number;
+        hits: number;
+        misses: number;
+    };
+};
+/**
+ * Measure and optimize Time to Interactive (TTI).
+ * Defers non-critical work until after the main thread is idle.
+ * Uses `requestIdleCallback` when available, falling back to `setTimeout`.
+ */
+declare function deferNonCritical(tasks: Array<() => void>): void;
+/**
+ * Create a boot sequence that orchestrates app initialization.
+ * Critical tasks run first in registration order. Deferred tasks run
+ * afterward using idle scheduling. Returns timing information and
+ * any errors that occurred.
+ */
+declare function createBootSequence(): {
+    /** Add a critical task that runs immediately during boot */
+    critical(name: string, task: () => void | Promise<void>): void;
+    /** Add a deferred task that runs after all critical tasks complete */
+    defer(name: string, task: () => void | Promise<void>): void;
+    /** Execute the boot sequence: critical tasks first, then deferred */
+    boot(): Promise<{
+        timing: Record<string, number>;
+        errors: Array<{
+            name: string;
+            error: Error;
+        }>;
+    }>;
+};
+
+/**
+ * Enable debug mode — enables verbose logging.
+ */
+declare function enableDebug(): void;
+/**
+ * Disable debug mode.
+ */
+declare function disableDebug(): void;
+/**
+ * Check if debug mode is active.
+ */
+declare function isDebugEnabled(): boolean;
+/**
+ * Log a debug message (only when debug mode is enabled).
+ */
+declare function debugLog(component: string, action: string, data?: unknown): void;
+/**
+ * sbPerformance tracks render timing for a component.
+ */
+declare function sbPerformance(label: string): {
+    startMeasure: () => void;
+    endMeasure: () => number;
+    getAverageTime: () => number;
+    getRenderCount: () => number;
+};
+/**
+ * measureRender wraps a component and measures its render time.
+ */
+declare function measureRender<P>(label: string, component: (props: P) => HTMLElement): (props: P) => HTMLElement;
+/**
+ * Get all collected performance data.
+ */
+declare function getPerformanceReport(): Record<string, {
+    count: number;
+    average: number;
+    min: number;
+    max: number;
+    total: number;
+}>;
+/**
+ * Clear all performance data.
+ */
+declare function clearPerformanceData(): void;
+declare function trackCleanup(component: string, cleanup: () => void): void;
+declare function runCleanups(component: string): void;
+declare function checkLeaks(): Record<string, number>;
+
+/**
+ * Sibu DevTools Bridge
+ *
+ * Architecture (React DevTools style):
+ *
+ *   Sibu App                    Chrome Extension
+ *   ┌──────────┐               ┌──────────────┐
+ *   │ sbSignal  │──emit──▶│    │  Content      │
+ *   │ sbDerived │        │    │  Script       │
+ *   │ sbEffect  │        ▼    │   │            │
+ *   │ mount     │   __SIBU_   │   ▼            │
+ *   └──────────┘   DEVTOOLS_  │  Background   │
+ *                  GLOBAL_    │   │            │
+ *                  HOOK__     │   ▼            │
+ *                    │        │  DevTools      │
+ *                    │        │  Panel         │
+ *                    ▼        └──────────────┘
+ *                 Bridge
+ *              (postMessage)
+ *
+ * The hook is injected by the content script BEFORE the app loads.
+ * When initDevTools() is called, the bridge connects to the existing hook
+ * or creates one. Events are buffered until the panel connects.
+ */
+type DevToolsEvent = {
+    type: "state-change";
+    component: string;
+    key: string;
+    oldValue: unknown;
+    newValue: unknown;
+    timestamp: number;
+} | {
+    type: "mount";
+    component: string;
+    element: HTMLElement;
+    timestamp: number;
+} | {
+    type: "unmount";
+    component: string;
+    timestamp: number;
+} | {
+    type: "render";
+    component: string;
+    duration: number;
+    timestamp: number;
+} | {
+    type: "error";
+    component: string;
+    error: Error;
+    timestamp: number;
+};
+interface DevToolsConfig {
+    maxEvents?: number;
+    enabled?: boolean;
+    maxSignals?: number;
+}
+interface ComponentEntry {
+    element: HTMLElement;
+    state?: Record<string, unknown>;
+}
+declare function getActiveDevTools(): ReturnType<typeof initDevTools> | null;
+/**
+ * Initialize Sibu DevTools.
+ * Connects to __SIBU_DEVTOOLS_GLOBAL_HOOK__ and starts tracking signals,
+ * computed values, effects, and components.
+ */
+declare function initDevTools(config?: DevToolsConfig): {
+    record: (event: DevToolsEvent) => void;
+    getEvents: (filter?: {
+        type?: string;
+        component?: string;
+    }) => DevToolsEvent[];
+    clearEvents: () => void;
+    registerComponent: (name: string, element: HTMLElement, state?: Record<string, unknown>) => void;
+    unregisterComponent: (name: string) => void;
+    getComponents: () => Map<string, ComponentEntry>;
+    getSignals: () => Array<{
+        id: number;
+        name: string;
+        type: string;
+        value: unknown;
+        subscriberCount: number;
+    }>;
+    isEnabled: () => boolean;
+    setEnabled: (v: boolean) => void;
+    snapshot: () => Record<string, unknown>;
+    highlightElement: (name: string) => void;
+    destroy: () => void;
+};
+declare function sbDevState<T>(name: string, initial: T): [() => T, (value: T | ((prev: T) => T)) => void];
+
+/**
+ * Hot Module Replacement utilities for SibuJS.
+ * Preserves component state during development reloads.
+ *
+ * During development the HMR runtime keeps a global store of component state
+ * keyed by a developer-supplied ID.  When a module is hot-reloaded the new
+ * component implementation can re-use the preserved state so that the user
+ * does not lose context (form values, scroll position, etc.).
+ *
+ * The utilities integrate with bundlers that expose a `module.hot` or
+ * `import.meta.hot` API (Webpack, Vite, Parcel, etc.).
+ */
+/**
+ * Create an HMR-aware state that persists across module reloads.
+ * During development, state is stored in a global map keyed by a unique `id`.
+ * On the first load the `initial` value is used; on subsequent hot reloads
+ * the previously stored value is restored.
+ *
+ * @param id       Unique identifier for this state (should be stable across reloads)
+ * @param initial  Initial value used on the very first load
+ * @returns A `[getter, setter]` tuple compatible with `sbSignal`
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = sbHMRState("MyCounter.count", 0);
+ * // After a hot reload, `count()` will still return the last known value.
+ * ```
+ */
+declare function sbHMRState<T>(id: string, initial: T): [() => T, (value: T | ((prev: T) => T)) => void];
+/**
+ * Register a component for HMR updates.
+ * When the module is hot-reloaded the component is re-rendered with preserved
+ * state by swapping out the old DOM element for the new one produced by the
+ * updated component function.
+ *
+ * @param id          Stable identifier for the component
+ * @param component   Factory function that returns the component's root element
+ * @param container   Optional container element – if provided the initial element
+ *                    is automatically appended to it
+ * @returns An object with `update` (swap implementation) and `dispose` (clean up)
+ *
+ * @example
+ * ```ts
+ * const hmr = registerHMR("MyWidget", () => MyWidget());
+ *
+ * // On hot update:
+ * hmr.update(() => MyWidgetV2());
+ *
+ * // On full teardown:
+ * hmr.dispose();
+ * ```
+ */
+declare function registerHMR(id: string, component: () => HTMLElement, container?: HTMLElement): {
+    /** Update the component implementation (called on hot reload) */
+    update: (newComponent: () => HTMLElement) => void;
+    /** Dispose the HMR registration */
+    dispose: () => void;
+};
+/**
+ * Create an HMR boundary.
+ * Components within the boundary are hot-reloaded independently.  The boundary
+ * keeps track of accept/dispose callbacks and can wrap a component factory so
+ * that hot updates are handled transparently.
+ *
+ * @param id  Stable boundary identifier
+ * @returns Boundary helpers: `wrap`, `accept`, `dispose`
+ *
+ * @example
+ * ```ts
+ * const boundary = createHMRBoundary("settings-panel");
+ *
+ * const el = boundary.wrap(() => SettingsPanel());
+ * document.body.appendChild(el);
+ *
+ * boundary.accept(() => console.log("Hot update accepted"));
+ * boundary.dispose(() => console.log("Cleaning up old version"));
+ * ```
+ */
+declare function createHMRBoundary(id: string): {
+    /** Wrap a component for HMR support */
+    wrap: (component: () => HTMLElement) => HTMLElement;
+    /** Accept a hot update */
+    accept: (callback?: () => void) => void;
+    /** Dispose callback */
+    dispose: (callback: () => void) => void;
+};
+/**
+ * Clear all HMR state (useful for a full page refresh or test teardown).
+ */
+declare function clearHMRState(): void;
+/**
+ * Check if HMR is available in the current environment.
+ * Returns `true` when any of the common bundler HMR APIs are detected
+ * (`module.hot` for Webpack, `import.meta.hot` for Vite, or the SibuJS
+ * custom hook).
+ */
+declare function isHMRAvailable(): boolean;
+
+/**
+ * Source map and debugging utilities for SibuJS.
+ * Provides enhanced error reporting with component context and stack traces.
+ *
+ * These utilities do not parse `.map` files at runtime; instead they enrich
+ * errors with SibuJS-specific component context so that developers can quickly
+ * identify *which* component failed and *what* props were in play, regardless
+ * of whether source maps are available in the browser.
+ */
+/**
+ * Enhanced error class with component context.
+ *
+ * Extends the native `Error` to carry the component name and the props that
+ * were active when the error was thrown.  The `cause` property (ES2022) is
+ * also forwarded so that the original error is preserved.
+ *
+ * @example
+ * ```ts
+ * throw new SibuError("Render failed", {
+ *   component: "UserCard",
+ *   props: { userId: 42 },
+ *   cause: originalError,
+ * });
+ * ```
+ */
+declare class SibuError extends Error {
+    component?: string;
+    props?: Record<string, unknown>;
+    constructor(message: string, options?: {
+        component?: string;
+        props?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Create a component error reporter that captures stack traces and maps them
+ * to component context.
+ *
+ * The reporter collects errors into an internal list, optionally logs them
+ * to the console, and forwards them to a user-supplied `onError` handler.
+ *
+ * @param options Configuration options
+ * @returns Reporter API
+ *
+ * @example
+ * ```ts
+ * const reporter = createErrorReporter({
+ *   onError: (err) => analytics.track("component_error", err),
+ *   logToConsole: true,
+ *   maxErrors: 200,
+ * });
+ *
+ * reporter.report(new Error("oops"), { component: "Dashboard" });
+ * console.log(reporter.getErrors());
+ * ```
+ */
+declare function createErrorReporter(options?: {
+    /** Custom error handler */
+    onError?: (error: SibuError) => void;
+    /** Whether to log to console (default `true`) */
+    logToConsole?: boolean;
+    /** Max errors to retain */
+    maxErrors?: number;
+}): {
+    /** Report an error with component context */
+    report: (error: Error, context?: {
+        component?: string;
+        props?: Record<string, unknown>;
+    }) => void;
+    /** Get all reported errors */
+    getErrors: () => SibuError[];
+    /** Clear error history */
+    clear: () => void;
+    /** Get error count by component */
+    getErrorsByComponent: () => Map<string, SibuError[]>;
+};
+/**
+ * Wrap a component factory with error tracking.
+ * Catches errors during rendering and reports them via the supplied reporter
+ * (or a default one).  If the component throws, a fallback `<div>` with the
+ * error message is returned so the rest of the page is not broken.
+ *
+ * @param name       Human-readable component name
+ * @param component  Factory function that returns an `HTMLElement`
+ * @param reporter   Optional error reporter (a default is created if omitted)
+ * @returns A wrapped factory function with identical signature
+ *
+ * @example
+ * ```ts
+ * const SafeWidget = withErrorTracking("Widget", () => Widget(), reporter);
+ * document.body.appendChild(SafeWidget());
+ * ```
+ */
+declare function withErrorTracking(name: string, component: () => HTMLElement, reporter?: ReturnType<typeof createErrorReporter>): () => HTMLElement;
+/**
+ * Format an error with enhanced stack trace information.
+ * Adds component context markers to stack traces so that the developer can
+ * immediately see which SibuJS component is involved.
+ *
+ * @param error    The error to format
+ * @param context  Optional context to include in the formatted output
+ * @returns A formatted multi-line string suitable for `console.error`
+ *
+ * @example
+ * ```ts
+ * try {
+ *   render();
+ * } catch (e) {
+ *   console.error(formatError(e, { component: "App" }));
+ * }
+ * ```
+ */
+declare function formatError(error: Error, context?: {
+    component?: string;
+}): string;
+
+/**
+ * Registers a reactive value for DevTools inspection.
+ * The formatter converts the value to a display string (label).
+ * If no formatter is provided, String() is used.
+ */
+declare function sbDebugValue<T>(value: () => T, formatter?: (value: T) => string): void;
+/**
+ * Returns all currently registered debug values.
+ */
+declare function getDebugValues(): Array<{
+    value: unknown;
+    label: string;
+}>;
+/**
+ * Clears all registered debug values.
+ */
+declare function clearDebugValues(): void;
+
+interface ProfilerResult {
+    renderCount: () => number;
+    lastRenderTime: () => number;
+    averageRenderTime: () => number;
+    totalRenderTime: () => number;
+    reset: () => void;
+}
+/**
+ * Creates a component profiler that tracks render counts and timings.
+ * Uses performance.now() for high-resolution timing.
+ * All outputs are reactive via sbSignal.
+ */
+declare function createProfiler(_name: string): ProfilerResult;
+/**
+ * Starts a render measurement for the given profiler.
+ * Returns a stop function that records the elapsed time.
+ */
+declare function startMeasure(profiler: ProfilerResult): () => void;
+
+/**
+ * DevTools introspection utilities for SibuJS.
+ *
+ * These functions allow dev tools to inspect the reactive dependency graph
+ * at runtime. They are designed to be zero-cost when not used — no overhead
+ * is added to the hot path. Information is read from tags already placed
+ * on signals/getters by sbSignal, sbDerived, etc.
+ */
+
+/** Info about a reactive node in the dependency graph */
+interface ReactiveNodeInfo {
+    /** Debug name if provided (e.g., sbSignal(0, { name: "count" })) */
+    name: string | undefined;
+    /** Internal signal reference */
+    signal: ReactiveSignal;
+    /** Number of subscribers */
+    subscriberCount: number;
+}
+/**
+ * Get the debug name of a signal getter function.
+ * Returns undefined if no name was provided.
+ *
+ * @example
+ * const [count] = sbSignal(0, { name: "count" });
+ * getSignalName(count); // "count"
+ */
+declare function getSignalName(getter: () => unknown): string | undefined;
+/**
+ * Get the number of active subscribers for a signal getter.
+ *
+ * @example
+ * const [count] = sbSignal(0);
+ * sbEffect(() => count()); // +1 subscriber
+ * getSubscriberCount(count); // 1
+ */
+declare function getSubscriberCount(getter: () => unknown): number;
+/**
+ * Get the dependency list of an effect or computed subscriber function.
+ * Returns signal references that the subscriber depends on.
+ *
+ * Note: This reads the _deps Set that track.ts maintains on subscriber functions.
+ */
+declare function getDependencies(subscriberFn: () => void): ReactiveSignal[];
+/**
+ * Inspect a signal getter — returns name, signal ref, and subscriber count.
+ */
+declare function inspectSignal(getter: () => unknown): ReactiveNodeInfo | null;
+/**
+ * Walk the full reactive graph starting from a signal getter.
+ * Returns a tree of signal → subscribers → their signals → etc.
+ * Useful for devtools visualization.
+ *
+ * Set maxDepth to limit traversal (default: 10).
+ */
+declare function walkDependencyGraph(getter: () => unknown, maxDepth?: number): {
+    name: string | undefined;
+    subscribers: number;
+    downstream: ReturnType<typeof walkDependencyGraph>[];
+};
+
+interface DevtoolsOverlayOptions {
+    enabled?: boolean;
+    position?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+}
+/**
+ * Creates an in-browser devtools overlay manager.
+ * Manages panels and visibility state reactively.
+ * Does NOT create actual DOM elements — that's the consumer's job.
+ */
+declare function createDevtoolsOverlay(options?: DevtoolsOverlayOptions): {
+    isEnabled: () => boolean;
+    toggle: () => void;
+    addPanel: (name: string, render: () => string) => void;
+    removePanel: (name: string) => void;
+    getPanels: () => Array<{
+        name: string;
+        render: () => string;
+    }>;
+    dispose: () => void;
+};
+
+interface ComboboxOptions<T> {
+    items: T[];
+    filterFn?: (item: T, query: string) => boolean;
+    itemToString?: (item: T) => string;
+}
+declare function createCombobox<T>(options: ComboboxOptions<T>): {
+    query: () => string;
+    setQuery: (q: string) => void;
+    filteredItems: () => T[];
+    selectedItem: () => T | null;
+    select: (item: T) => void;
+    highlightedIndex: () => number;
+    highlightNext: () => void;
+    highlightPrev: () => void;
+    selectHighlighted: () => void;
+    isOpen: () => boolean;
+    open: () => void;
+    close: () => void;
+};
+
+interface TabsOptions {
+    tabs: Array<{
+        id: string;
+        label: string;
+        disabled?: boolean;
+    }>;
+    defaultTab?: string;
+}
+declare function createTabs(options: TabsOptions): {
+    activeTab: () => string;
+    setActiveTab: (id: string) => void;
+    tabs: () => Array<{
+        id: string;
+        label: string;
+        disabled?: boolean;
+        isActive: boolean;
+    }>;
+    nextTab: () => void;
+    prevTab: () => void;
+};
+
+interface AccordionOptions {
+    items: Array<{
+        id: string;
+        label: string;
+    }>;
+    multiple?: boolean;
+    defaultExpanded?: string[];
+}
+declare function createAccordion(options: AccordionOptions): {
+    items: () => Array<{
+        id: string;
+        label: string;
+        isExpanded: boolean;
+    }>;
+    toggle: (id: string) => void;
+    expand: (id: string) => void;
+    collapse: (id: string) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+};
+
+/**
+ * createPopover provides simple state management for positioned floating content.
+ * Manages open/close/toggle without any DOM coupling.
+ */
+declare function createPopover(): {
+    isOpen: () => boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+};
+
+interface SelectOptions<T> {
+    items: T[];
+    multiple?: boolean;
+    itemToString?: (item: T) => string;
+}
+declare function createSelect<T>(options: SelectOptions<T>): {
+    selectedItems: () => T[];
+    selectedItem: () => T | null;
+    select: (item: T) => void;
+    deselect: (item: T) => void;
+    toggle: (item: T) => void;
+    isSelected: (item: T) => boolean;
+    isOpen: () => boolean;
+    open: () => void;
+    close: () => void;
+    highlightedIndex: () => number;
+    highlightNext: () => void;
+    highlightPrev: () => void;
+    selectHighlighted: () => void;
+    clear: () => void;
+};
+
+/**
+ * createTooltip manages tooltip visibility with optional show delay.
+ * Timer cleanup is handled via closure variables per the framework convention.
+ */
+declare function createTooltip(options?: {
+    delay?: number;
+}): {
+    isVisible: () => boolean;
+    show: () => void;
+    hide: () => void;
+    content: () => string;
+    setContent: (text: string) => void;
+};
+
+interface FileUploadOptions {
+    accept?: string;
+    multiple?: boolean;
+    maxSize?: number;
+    onFiles?: (files: File[]) => void;
+}
+declare function createFileUpload(options?: FileUploadOptions): {
+    files: () => File[];
+    addFiles: (fileList: FileList | File[]) => void;
+    removeFile: (index: number) => void;
+    clear: () => void;
+    errors: () => string[];
+    isDragOver: () => boolean;
+    setDragOver: (v: boolean) => void;
+};
+
+/**
+ * sbContentEditable provides reactive binding for contenteditable elements.
+ * Commands call document.execCommand with browser API guards for Node environments.
+ */
+declare function sbContentEditable(): {
+    content: () => string;
+    setContent: (html: string) => void;
+    isFocused: () => boolean;
+    setFocused: (v: boolean) => void;
+    execCommand: (command: string, value?: string) => void;
+    bold: () => void;
+    italic: () => void;
+    underline: () => void;
+};
+
+interface DatePickerOptions {
+    initialDate?: Date;
+    minDate?: Date;
+    maxDate?: Date;
+}
+declare function createDatePicker(options?: DatePickerOptions): {
+    selectedDate: () => Date | null;
+    select: (date: Date) => void;
+    viewDate: () => Date;
+    setViewDate: (date: Date) => void;
+    nextMonth: () => void;
+    prevMonth: () => void;
+    nextYear: () => void;
+    prevYear: () => void;
+    daysInMonth: () => Array<{
+        date: Date;
+        isCurrentMonth: boolean;
+        isToday: boolean;
+        isSelected: boolean;
+        isDisabled: boolean;
+    }>;
+    isDateDisabled: (date: Date) => boolean;
+};
+
+/** MobX autorun disposer function type. */
+type MobXReactionDisposer = () => void;
+interface MobXAdapterOptions {
+    /** MobX's autorun function — passed to avoid importing MobX directly. */
+    autorun: (view: () => void) => MobXReactionDisposer;
+}
+interface MobXAdapterAPI {
+    /**
+     * Bridge a MobX observable into a SibuJS reactive getter.
+     *
+     * Takes a MobX expression (function reading MobX observables)
+     * and returns a SibuJS getter that updates when the observables change.
+     */
+    fromMobX: <T>(expression: () => T) => () => T;
+    /**
+     * Bridge a SibuJS getter into a MobX reaction.
+     *
+     * Runs a callback whenever a SibuJS signal changes.
+     */
+    toMobX: (sibuGetter: () => unknown, callback: (value: unknown) => void) => () => void;
+    /** Dispose all active bridges. */
+    destroy: () => void;
+}
+/**
+ * Creates a MobX adapter plugin for SibuJS.
+ *
+ * Unlike Redux/Zustand, MobX has distributed observables rather than
+ * a single store. The adapter provides `fromMobX()` to bridge any
+ * MobX expression into a SibuJS reactive getter.
+ *
+ * @example
+ * ```ts
+ * import { createMobXAdapter } from "sibu/extras";
+ * import { autorun, makeAutoObservable } from "mobx";
+ *
+ * class TodoStore {
+ *   todos: string[] = [];
+ *   constructor() { makeAutoObservable(this); }
+ *   addTodo(t: string) { this.todos.push(t); }
+ * }
+ *
+ * const todoStore = new TodoStore();
+ * const plugin = createMobXAdapter({ autorun });
+ * sbPlugin(plugin);
+ *
+ * const mobx = inject<MobXAdapterAPI>("mobx");
+ * const todoCount = mobx.fromMobX(() => todoStore.todos.length);
+ * div({ nodes: () => `Todos: ${todoCount()}` });
+ * ```
+ */
+declare function createMobXAdapter(options: MobXAdapterOptions): SibuPlugin;
+
+/** Minimal Redux store interface (peer dependency — no import from redux). */
+interface ReduxStore<S = unknown> {
+    getState(): S;
+    dispatch(action: unknown): unknown;
+    subscribe(listener: () => void): () => void;
+}
+interface ReduxAdapterOptions<S = unknown> {
+    store: ReduxStore<S>;
+}
+interface ReduxAdapterAPI<S = unknown> {
+    /** Full store state as a SibuJS reactive getter */
+    getState: () => S;
+    /** Create a SibuJS reactive getter from a Redux selector */
+    useSelector: <R>(selector: (state: S) => R) => () => R;
+    /** Dispatch an action to the Redux store */
+    dispatch: ReduxStore<S>["dispatch"];
+    /** Unsubscribe from the Redux store */
+    destroy: () => void;
+}
+/**
+ * Creates a Redux adapter plugin for SibuJS.
+ *
+ * Bridges Redux store subscriptions into SibuJS signal-based reactivity.
+ * Each selector becomes a reactive getter that auto-updates when Redux
+ * state changes.
+ *
+ * @example
+ * ```ts
+ * import { createReduxAdapter } from "sibu/extras";
+ * import { createStore } from "redux";
+ *
+ * const reduxStore = createStore(rootReducer);
+ * const reduxPlugin = createReduxAdapter({ store: reduxStore });
+ * sbPlugin(reduxPlugin);
+ *
+ * const redux = inject<ReduxAdapterAPI>("redux");
+ * const count = redux.useSelector(s => s.counter);
+ * div({ nodes: () => `Count: ${count()}` });
+ * ```
+ */
+declare function createReduxAdapter<S>(options: ReduxAdapterOptions<S>): SibuPlugin;
+
+/** Minimal Zustand store interface (peer dependency). */
+interface ZustandStore<S> {
+    getState(): S;
+    setState(partial: Partial<S> | ((state: S) => Partial<S>), replace?: boolean): void;
+    subscribe(listener: (state: S, prevState: S) => void): () => void;
+    destroy(): void;
+}
+interface ZustandAdapterOptions<S> {
+    store: ZustandStore<S>;
+}
+interface ZustandAdapterAPI<S> {
+    /** Full Zustand state as a SibuJS reactive getter */
+    getState: () => S;
+    /** Create a SibuJS reactive getter from a Zustand selector */
+    useSelector: <R>(selector: (state: S) => R) => () => R;
+    /** Set state on the Zustand store */
+    setState: ZustandStore<S>["setState"];
+    /** Destroy the subscription and the Zustand store */
+    destroy: () => void;
+}
+/**
+ * Creates a Zustand adapter plugin for SibuJS.
+ *
+ * @example
+ * ```ts
+ * import { createZustandAdapter } from "sibu/extras";
+ * import { createStore } from "zustand/vanilla";
+ *
+ * const bearStore = createStore((set) => ({
+ *   bears: 0,
+ *   increase: () => set((s) => ({ bears: s.bears + 1 })),
+ * }));
+ *
+ * const plugin = createZustandAdapter({ store: bearStore });
+ * sbPlugin(plugin);
+ *
+ * const zs = inject<ZustandAdapterAPI>("zustand");
+ * const bears = zs.useSelector(s => s.bears);
+ * div({ nodes: () => `Bears: ${bears()}` });
+ * ```
+ */
+declare function createZustandAdapter<S>(options: ZustandAdapterOptions<S>): SibuPlugin;
+
+interface ThemeConfig {
+    /** CSS class prefix for the design system (e.g., "mdc", "ant", "chakra") */
+    prefix: string;
+    /** CSS variables to inject as custom properties */
+    variables?: Record<string, string>;
+    /** Overrides for default class mappings */
+    classOverrides?: Record<string, string>;
+}
+interface ThemeAPI {
+    /** Get the current theme config reactively */
+    config: () => ThemeConfig;
+    /** Update the theme */
+    setTheme: (config: Partial<ThemeConfig>) => void;
+    /** Resolve a component class name using prefix and overrides */
+    resolveClass: (component: string, variant?: string) => string;
+}
+/**
+ * Creates a reactive theme for a UI component library adapter.
+ */
+declare function createTheme(initial: ThemeConfig): ThemeAPI;
+interface ComponentMapping {
+    /** HTML tag to use (default: "div") */
+    tag?: string;
+    /** Base CSS class for this component */
+    baseClass: string;
+    /** Variant-to-class mapping */
+    variants?: Record<string, string>;
+    /** Size-to-class mapping */
+    sizes?: Record<string, string>;
+    /** Additional default props */
+    defaultProps?: Partial<TagProps>;
+}
+interface AdapterConfig {
+    /** Name of the CSS framework */
+    name: string;
+    /** CSS class prefix */
+    prefix: string;
+    /** Component mappings */
+    components: Record<string, ComponentMapping>;
+}
+interface AdaptedComponentProps extends TagProps {
+    /** Component variant (e.g., "primary", "outlined") */
+    variant?: string;
+    /** Component size (e.g., "sm", "md", "lg") */
+    size?: string;
+}
+type AdaptedComponent = (props?: AdaptedComponentProps) => Element;
+/**
+ * Creates a set of SibuJS components from a CSS framework's class mappings.
+ *
+ * @example
+ * ```ts
+ * const adapter = createComponentAdapter({
+ *   name: "material",
+ *   prefix: "mdc",
+ *   components: {
+ *     Button: {
+ *       tag: "button",
+ *       baseClass: "mdc-button",
+ *       variants: { raised: "mdc-button--raised" },
+ *       sizes: { sm: "mdc-button--dense" },
+ *     },
+ *   },
+ * });
+ *
+ * const { Button } = adapter.components;
+ * Button({ variant: "raised", nodes: "Click me" });
+ * ```
+ */
+declare function createComponentAdapter(config: AdapterConfig): {
+    name: string;
+    components: Record<string, AdaptedComponent>;
+    theme: ThemeAPI;
+};
+
+declare const antdAdapter: {
+    name: string;
+    components: Record<string, AdaptedComponent>;
+    theme: ThemeAPI;
+};
+
+declare const chakraAdapter: {
+    name: string;
+    components: Record<string, AdaptedComponent>;
+    theme: ThemeAPI;
+};
+
+declare const materialAdapter: {
+    name: string;
+    components: Record<string, AdaptedComponent>;
+    theme: ThemeAPI;
+};
+
+export { type AccordionOptions, type ActionFn, type ActionResult, type AdaptedComponent, type AdaptedComponentProps, type AdapterConfig, type ChunkConfig, type ComboboxOptions, type ComponentMapping, type CustomElementOptions, DOMPool, type DatePickerOptions, type DevToolsEvent, type DevtoolsOverlayOptions, Features, type FieldConfig, type FileUploadOptions, FocusTrap, type FormConfig, type FormField, type FormReturn, Head, type ISROptions, type IntersectionResult, type MaskOptions, type MicroApp, type MicroAppConfig, type MiddlewareFn, type Migration, type MobXAdapterAPI, type MobXAdapterOptions, type MobXReactionDisposer, type NormalizeResult, type NormalizedEntities, type NormalizedSchema, type NormalizedState, type NormalizedStoreActions, type PluginContext, Priority, type PriorityLevel, type ProfilerResult, type ReactiveNodeInfo, type ReduxAdapterAPI, type ReduxAdapterOptions, type ReduxStore, type SSGOptions, type SSGResult, type ScrollRestorationOptions, type SelectOptions, type SemVer, type ServiceWorkerState, type SharedScope, SibuError, type SibuPlugin, type TabsOptions, type ThemeAPI, type ThemeConfig, type Toast, type UseWorkerFnReturn, type UseWorkerReturn, VERSION, type ValidatorFn, VirtualList, type VirtualListProps, type WasmConfig, type WasmModuleState, type WorkerPool, type ZustandAdapterAPI, type ZustandAdapterOptions, type ZustandStore, announce, antdAdapter, bindAttrs, bindBoolAttr, bindData, block, bundlerMetadata, chakraAdapter, checkCompatibility, checkLeaks, clearDebugValues, clearHMRState, clearPerformanceData, clearWasmCache, cloneTemplate, collectStream, compareSemVer, composeMiddleware, conditional, createAccordion, createAction, createBootSequence, createBundle, createChunkRegistry, createCombobox, createComponentAdapter, createDatePicker, createDevtoolsOverlay, createErrorReporter, createEventBus, createFileUpload, createHMRBoundary, createISR, createMicroApp, createMiddlewareChain, createMigrationRunner, createMobXAdapter, createModuleRegistry, createNormalizedStore, createPlugin, createPopover, createProfiler, createReduxAdapter, createSSRCache, createSelect, createSharedScope, createTabs, createTestHarness, createTheme, createTooltip, createWasmBridge, createWorkerPool, createZustandAdapter, creditCardMask, custom, dateMask, debugLog, deferNonCritical, defineElement, defineRemoteComponent, denormalize, deserializeState, devOnly, disableDebug, domPool, email, enableDebug, env, flushScheduler, formatError, generateStaticSite, getActiveDevTools, getDebugValues, getDependencies, getPerformanceReport, getSignalName, getSubscriberCount, healthCheck, hoistable, hydrate, hydrateIslands, hydrateProgressively, initDevTools, inject, inspectSignal, isDebugEnabled, isHMRAvailable, isWasmCached, island, lazyChunk, lazyLoad, lazyModule, loadRemoteModule, loadWasmModule, matchesPattern, materialAdapter, max, maxLength, measureRender, min, minLength, noSideEffect, normalize, packageInfo, parseSemVer, pendingTasks, phoneMask, precompile, prefetch, preloadCritical, preloadImage, preloadModule, preloadModules, preloadResource, preloadWasm, prerenderRoutes, processInChunks, pure, registerHMR, removeScopedStyle, renderToDocument, renderToReadableStream, renderToStream, renderToString, renderToSuspenseStream, required, resetIdCounter, resetPlugins, resetSSRState, runCleanups, satisfies, sbAria, sbContentEditable, sbDebugValue, sbDeferredValue, sbDevState, sbDialog, sbFocus, sbForm, sbHMRState, sbHotkey, sbId, sbInfiniteScroll, sbInputMask, sbIntersection, sbPagination, sbPerformance, sbPlugin, sbScrollRestoration, sbServiceWorker, sbToast, sbTransitionState, sbWasm, sbWorker, sbWorkerFn, scheduleUpdate, scopedStyle, serializeState, setCanonical, setIdPrefix, setStructuredData, ssnMask, ssrSuspense, startMeasure, startTransition, staticTemplate, suspenseSwapScript, svgElement, timeMask, trackCleanup, triggerPluginError, triggerPluginMount, triggerPluginUnmount, walkDependencyGraph, withErrorTracking, withScopedStyle, yieldToMain, zipMask };