@getforma/core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1382 @@
+import { S as SignalGetter } from './signal-CfLDwMyg.cjs';
+export { c as createSignal } from './signal-CfLDwMyg.cjs';
+
+declare function createEffect(fn: () => void | (() => void)): () => void;
+
+/**
+ * Forma Reactive - Computed
+ *
+ * Lazy, cached derived value that participates in the reactive graph.
+ * Backed by alien-signals for automatic dependency tracking
+ * and cache invalidation.
+ *
+ * TC39 Signals equivalent: Signal.Computed
+ */
+/**
+ * Create a lazy, cached computed value.
+ *
+ * ```ts
+ * const [count, setCount] = createSignal(0);
+ * const doubled = createComputed(() => count() * 2);
+ * console.log(doubled()); // 0
+ * setCount(5);
+ * console.log(doubled()); // 10
+ * ```
+ */
+declare function createComputed<T>(fn: () => T): () => T;
+
+/**
+ * Forma Reactive - Memo
+ *
+ * Alias for createComputed with SolidJS/React-familiar naming.
+ * A memoized derived value that only recomputes when its dependencies change.
+ *
+ * TC39 Signals equivalent: Signal.Computed
+ */
+
+/**
+ * Create a memoized computed value.
+ * Identical to `createComputed` — provided for React/SolidJS familiarity.
+ *
+ * The computation runs lazily and caches the result. It only recomputes
+ * when a signal it reads during computation changes.
+ *
+ * ```ts
+ * const [count, setCount] = createSignal(0);
+ * const doubled = createMemo(() => count() * 2);
+ * console.log(doubled()); // 0
+ * setCount(5);
+ * console.log(doubled()); // 10
+ * ```
+ */
+declare const createMemo: typeof createComputed;
+
+/**
+ * Forma Reactive - Batch
+ *
+ * Groups multiple signal updates and defers effect execution until the
+ * outermost batch completes. Prevents intermediate re-renders.
+ * Backed by alien-signals.
+ *
+ * TC39 Signals: no built-in batch — this is a userland optimization.
+ */
+/**
+ * Group multiple signal updates so that effects only run once after all
+ * updates have been applied.
+ *
+ * ```ts
+ * batch(() => {
+ *   setA(1);
+ *   setB(2);
+ *   // effects that depend on A and B won't run yet
+ * });
+ * // effects run here, once
+ * ```
+ *
+ * Batches are nestable — only the outermost batch triggers the flush.
+ */
+declare function batch(fn: () => void): void;
+
+/**
+ * Forma Reactive - Untrack
+ *
+ * Read signals without subscribing to them in the reactive graph.
+ * Essential for reading values inside effects without creating dependencies.
+ *
+ * TC39 Signals equivalent: Signal.subtle.untrack()
+ */
+/**
+ * Execute a function without tracking signal reads.
+ * Any signals read inside `fn` will NOT become dependencies of the
+ * surrounding effect or computed.
+ *
+ * ```ts
+ * createEffect(() => {
+ *   const a = count();           // tracked — effect re-runs when count changes
+ *   const b = untrack(() => other()); // NOT tracked — effect ignores other changes
+ * });
+ * ```
+ */
+declare function untrack<T>(fn: () => T): T;
+
+/**
+ * Forma Reactive - Root
+ *
+ * Explicit reactive ownership scope. All effects created inside a root
+ * are automatically disposed when the root is torn down.
+ *
+ * Replaces the module-level disposalBag pattern in mount.ts.
+ */
+/**
+ * Create a reactive root scope.
+ *
+ * All effects created (via `createEffect`) inside the callback are tracked.
+ * The returned `dispose` function tears them all down.
+ *
+ * ```ts
+ * const dispose = createRoot(() => {
+ *   createEffect(() => console.log(count()));
+ *   createEffect(() => console.log(name()));
+ * });
+ * // later: dispose() stops both effects
+ * ```
+ */
+declare function createRoot<T>(fn: (dispose: () => void) => T): T;
+
+/**
+ * Register a cleanup function in the current reactive scope.
+ * The cleanup runs before the effect re-executes and on disposal.
+ *
+ * More composable than returning a cleanup from the effect function,
+ * since it can be called from helper functions.
+ *
+ * ```ts
+ * createEffect(() => {
+ *   const timer = setInterval(tick, 1000);
+ *   onCleanup(() => clearInterval(timer));
+ * });
+ * ```
+ */
+declare function onCleanup(fn: () => void): void;
+
+/**
+ * Forma Reactive - On
+ *
+ * Explicit dependency tracking for effects.
+ * Only re-runs when the specified signals change, ignoring all other reads.
+ *
+ * SolidJS equivalent: on()
+ * Vue equivalent: watch() with explicit deps
+ * React equivalent: useEffect dependency array
+ */
+/**
+ * Create a tracked effect body that only fires when specific dependencies change.
+ *
+ * Wraps a function so that only the `deps` signals are tracked.
+ * All signal reads inside `fn` are untracked (won't cause re-runs).
+ *
+ * Use with `createEffect`:
+ *
+ * ```ts
+ * const [a, setA] = createSignal(1);
+ * const [b, setB] = createSignal(2);
+ *
+ * // Only re-runs when `a` changes, NOT when `b` changes:
+ * createEffect(on(a, (value, prev) => {
+ *   console.log(`a changed: ${prev} → ${value}, b is ${b()}`);
+ * }));
+ *
+ * setA(10);  // fires: "a changed: 1 → 10, b is 2"
+ * setB(20);  // does NOT fire
+ * ```
+ *
+ * Multiple dependencies:
+ * ```ts
+ * createEffect(on(
+ *   () => [a(), b()] as const,
+ *   ([aVal, bVal], prev) => { ... }
+ * ));
+ * ```
+ */
+declare function on<T, U>(deps: () => T, fn: (value: T, prev: T | undefined) => U, options?: {
+    defer?: boolean;
+}): () => U | undefined;
+
+/**
+ * Forma Reactive - Ref
+ *
+ * Mutable container that does NOT trigger reactivity.
+ * Use for DOM references, previous values, instance variables —
+ * anything that needs to persist across effect re-runs without
+ * causing re-execution.
+ *
+ * React equivalent: useRef
+ * SolidJS equivalent: (none — uses plain variables in setup)
+ */
+interface Ref<T> {
+    current: T;
+}
+/**
+ * Create a mutable ref container.
+ *
+ * Unlike signals, writing to `.current` does NOT trigger effects.
+ * Use when you need a stable reference across reactive scopes.
+ *
+ * ```ts
+ * const timerRef = createRef<number | null>(null);
+ *
+ * createEffect(() => {
+ *   timerRef.current = setInterval(tick, 1000);
+ *   onCleanup(() => clearInterval(timerRef.current!));
+ * });
+ *
+ * // DOM ref pattern:
+ * const elRef = createRef<HTMLElement | null>(null);
+ * h('div', { ref: (el) => { elRef.current = el; } });
+ * ```
+ */
+declare function createRef<T>(initialValue: T): Ref<T>;
+
+/**
+ * Forma Reactive - Reducer
+ *
+ * State machine pattern — dispatch actions to a pure reducer function.
+ * Fine-grained: only the resulting state signal is reactive.
+ *
+ * React equivalent: useReducer
+ * SolidJS equivalent: (none — uses createSignal + helpers)
+ */
+
+type Dispatch<A> = (action: A) => void;
+/**
+ * Create a reducer — predictable state updates via dispatched actions.
+ *
+ * The reducer function must be pure: `(state, action) => newState`.
+ * Returns a [state, dispatch] tuple.
+ *
+ * ```ts
+ * type Action = { type: 'increment' } | { type: 'decrement' } | { type: 'reset' };
+ *
+ * const [count, dispatch] = createReducer(
+ *   (state: number, action: Action) => {
+ *     switch (action.type) {
+ *       case 'increment': return state + 1;
+ *       case 'decrement': return state - 1;
+ *       case 'reset': return 0;
+ *     }
+ *   },
+ *   0,
+ * );
+ *
+ * dispatch({ type: 'increment' }); // count() === 1
+ * dispatch({ type: 'increment' }); // count() === 2
+ * dispatch({ type: 'reset' });     // count() === 0
+ * ```
+ */
+declare function createReducer<S, A>(reducer: (state: S, action: A) => S, initialState: S): [state: SignalGetter<S>, dispatch: Dispatch<A>];
+
+/**
+ * Forma Reactive - Resource
+ *
+ * Async data fetching primitive with reactive loading/error state.
+ * Tracks a source signal and refetches when it changes.
+ *
+ * SolidJS equivalent: createResource
+ * React equivalent: use() + Suspense (React 19), or useSWR/react-query
+ */
+
+interface Resource<T> {
+    /** The resolved data (or undefined while loading). */
+    (): T | undefined;
+    /** True while the fetcher is running. */
+    loading: SignalGetter<boolean>;
+    /** The error if the fetcher rejected (or undefined). */
+    error: SignalGetter<unknown>;
+    /** Manually refetch with the current source value. */
+    refetch: () => void;
+    /** Manually set the data (overrides fetcher result). */
+    mutate: (value: T | undefined) => void;
+}
+interface ResourceOptions<T> {
+    /** Initial value before first fetch resolves. */
+    initialValue?: T;
+}
+/**
+ * Create an async resource that fetches data reactively.
+ *
+ * When `source` changes, the fetcher re-runs automatically.
+ * Provides reactive `loading` and `error` signals.
+ *
+ * ```ts
+ * const [userId, setUserId] = createSignal(1);
+ *
+ * const user = createResource(
+ *   userId,                                    // source signal
+ *   (id) => fetch(`/api/users/${id}`).then(r => r.json()), // fetcher
+ * );
+ *
+ * internalEffect(() => {
+ *   if (user.loading()) console.log('Loading...');
+ *   else if (user.error()) console.log('Error:', user.error());
+ *   else console.log('User:', user());
+ * });
+ *
+ * setUserId(2); // automatically refetches
+ * ```
+ *
+ * Without a source signal (static fetch):
+ * ```ts
+ * const posts = createResource(
+ *   () => true,  // constant source — fetches once
+ *   () => fetch('/api/posts').then(r => r.json()),
+ * );
+ * ```
+ */
+declare function createResource<T, S = true>(source: SignalGetter<S>, fetcher: (source: S) => Promise<T>, options?: ResourceOptions<T>): Resource<T>;
+
+type ErrorHandler = (error: unknown, info?: {
+    source?: string;
+}) => void;
+/**
+ * Install a global error handler for FormaJS reactive errors.
+ * Called when effects, computeds, or event handlers throw.
+ *
+ * ```ts
+ * onError((err, info) => {
+ *   console.error(`[${info?.source}]`, err);
+ *   Sentry.captureException(err);
+ * });
+ * ```
+ */
+declare function onError(handler: ErrorHandler): void;
+
+/**
+ * Forma DOM - Element
+ *
+ * Hyperscript-style element factory (`h`) and Fragment helper.
+ * Backed by alien-signals via forma/reactive.
+ *
+ * Supports both HTML and SVG elements with automatic namespace detection.
+ * Provides event listener cleanup via AbortController.
+ */
+/**
+ * Remove all event listeners previously attached via `h()` on the given element.
+ *
+ * Calls `AbortController.abort()` for the element, which automatically removes
+ * every listener that was registered with its signal. The controller is then
+ * deleted so a fresh one is created if the element is reused.
+ */
+declare function cleanup(el: Element): void;
+/**
+ * Create a real DOM element with optional props and children.
+ *
+ * Supports both HTML and SVG elements. SVG tags are detected automatically
+ * and created with the correct SVG namespace. Inside a `foreignObject`,
+ * children switch back to the HTML namespace.
+ *
+ * Event listeners are attached with an AbortController signal so they can
+ * be removed in bulk via `cleanup(el)`.
+ *
+ * Hyperscript-style API:
+ * ```ts
+ * h('div', { class: 'container', onClick: handleClick },
+ *   h('span', null, 'Hello'),
+ *   h('span', null, name),  // name is a signal getter
+ * )
+ *
+ * h('svg', { viewBox: '0 0 24 24', fill: 'none' },
+ *   h('path', { d: 'M12 2L2 22h20L12 2z', stroke: 'currentColor' }),
+ * )
+ * ```
+ */
+declare function h(tag: string, props?: Record<string, unknown> | null, ...children: unknown[]): HTMLElement;
+/**
+ * Create a DocumentFragment from children.
+ *
+ * ```ts
+ * fragment(
+ *   h('li', null, 'one'),
+ *   h('li', null, 'two'),
+ * )
+ * ```
+ */
+declare function fragment(...children: unknown[]): DocumentFragment;
+
+/**
+ * Forma DOM - Text
+ *
+ * Creates static or reactive Text nodes.
+ * Zero dependencies -- native browser APIs only.
+ */
+/**
+ * Create a Text node that is either static or reactively bound.
+ *
+ * - If `value` is a string, creates a plain Text node.
+ * - If `value` is a function (signal getter), creates a Text node and sets up
+ *   an effect that auto-updates `textContent` whenever the signal changes.
+ *
+ * @returns The Text node.
+ */
+declare function createText(value: string | (() => string)): Text;
+
+/**
+ * Forma DOM - Mount
+ *
+ * Mounts a component function into a DOM container, returning an unmount handle.
+ * Uses createRoot() for automatic effect disposal — no global state.
+ *
+ * When the container has `data-forma-ssr`, uses hydrateIsland() for zero-flash
+ * descriptor-based hydration instead of tearing down and rebuilding the DOM.
+ */
+/**
+ * Mount a component into a DOM container.
+ *
+ * All effects created during the component's render are tracked via
+ * `createRoot()` and automatically disposed when unmount is called.
+ *
+ * When `data-forma-ssr` is present on the container, the component runs
+ * inside `createRoot` in hydration mode — h() returns descriptors that are
+ * walked against SSR DOM to attach handlers and reactive bindings.
+ *
+ * @param component  A function returning an HTMLElement or DocumentFragment.
+ * @param container  An HTMLElement or a CSS selector string.
+ * @returns An unmount function that removes the DOM and disposes all effects.
+ *
+ * ```ts
+ * const unmount = mount(() => h('h1', null, 'Hello'), '#app');
+ * // later…
+ * unmount();
+ * ```
+ */
+declare function mount(component: () => HTMLElement | DocumentFragment, container: HTMLElement | string): () => void;
+
+/**
+ * Forma DOM - List
+ *
+ * Keyed list reconciliation with Longest Increasing Subsequence (LIS).
+ * The LIS tells us the maximum set of DOM nodes that can stay in place;
+ * only the remaining nodes need to be moved. This minimises DOM operations
+ * to exactly `n - LIS_length` moves — provably optimal.
+ *
+ * Algorithm used by ivi, Inferno, and (with variations) Solid, Vue 3, Svelte.
+ *
+ * Uses comment-node markers instead of a wrapper <div>, so the list can be
+ * placed inside <table>, <ul>, <select>, etc. without breaking semantics.
+ *
+ * Total module budget: <2KB minified.
+ */
+interface ReconcileResult<T> {
+    nodes: Node[];
+    items: T[];
+}
+interface ListTransitionHooks {
+    onInsert?: (node: Node) => void;
+    onBeforeRemove?: (node: Node, done: () => void) => void;
+}
+interface CreateListOptions {
+    /**
+     * How to handle same-key items whose object identity changed.
+     * - 'none' (default): keep the existing row node for maximum throughput.
+     * - 'rerender': re-render changed rows and patch static row DOM in place.
+     */
+    updateOnItemChange?: 'none' | 'rerender';
+}
+/**
+ * Find the longest increasing subsequence.
+ * Returns indices into the input array.
+ * O(n log n) time, O(n) space.
+ */
+declare function longestIncreasingSubsequence(arr: number[]): number[];
+/**
+ * Reconcile a DOM parent's children to match a new array of items.
+ * Uses keyed reconciliation with LIS for minimum DOM operations.
+ *
+ * For small lists (< 32 items), uses a flat array scan path that avoids
+ * Map/Set hash overhead and provides better cache locality.
+ *
+ * @param parent     - The container DOM element
+ * @param oldItems   - Previous array (from last reconciliation)
+ * @param newItems   - New array to render
+ * @param oldNodes   - Previous DOM nodes array
+ * @param keyFn      - Extracts a unique key from each item
+ * @param createFn   - Creates a new DOM node for an item
+ * @param updateFn   - Updates an existing DOM node with new item data
+ * @param beforeNode - Optional boundary marker. When provided, new nodes are
+ *                     inserted before this node instead of appended to parent.
+ *                     This allows the reconciler to operate within a range
+ *                     delimited by comment markers.
+ * @returns Object with new nodes array and items array for next call
+ */
+declare function reconcileList<T>(parent: Node, oldItems: T[], newItems: T[], oldNodes: Node[], keyFn: (item: T) => string | number, createFn: (item: T) => Node, updateFn: (node: Node, item: T) => void, beforeNode?: Node | null, hooks?: ListTransitionHooks): ReconcileResult<T>;
+/**
+ * Create a reactively-bound list of DOM elements with keyed reconciliation.
+ *
+ * Returns a `DocumentFragment` containing two comment markers
+ * (`<!--forma-list-start-->` and `<!--forma-list-end-->`) that delimit the
+ * list's range in the DOM. All managed elements live between these markers.
+ *
+ * This avoids a wrapper `<div>` which would break `<table>`, `<ul>`,
+ * `<select>` semantics and pollute the DOM.
+ *
+ * When the `items` signal changes, only the minimal set of DOM mutations is
+ * performed using the LIS algorithm:
+ * - New keys: create elements via `renderFn`
+ * - Removed keys: remove elements from DOM
+ * - Moved keys: reorder elements using minimum moves (n - LIS)
+ * - Same keys: keep row nodes and update index signals
+ *   (or re-render row content when `updateOnItemChange: 'rerender'`)
+ *
+ * @param items    Signal getter returning the current array of items.
+ * @param keyFn    Extracts a unique key from each item.
+ * @param renderFn Renders a single item. Receives the item and a reactive index getter.
+ * @returns A DocumentFragment to insert into the DOM. The fragment includes
+ *          start/end comment markers and any initial list items.
+ *
+ * ```ts
+ * const frag = createList(
+ *   todos,
+ *   (t) => t.id,
+ *   (todo, index) => h('li', null, () => `${index() + 1}. ${todo.text}`),
+ * );
+ * container.appendChild(frag);
+ * ```
+ */
+declare function createList<T>(items: () => T[], keyFn: (item: T) => string | number, renderFn: (item: T, index: () => number) => HTMLElement, options?: CreateListOptions): DocumentFragment;
+
+/**
+ * Forma DOM - Show (Conditional Rendering)
+ *
+ * Surgically swaps a single DOM node based on a boolean signal.
+ * Uses comment markers (like createList) for zero-wrapper rendering.
+ * When condition changes, only ONE node is removed and ONE inserted.
+ *
+ * Each branch is rendered inside createRoot + untrack so that:
+ *  1. Inner effects survive when the show effect re-runs (alien-signals
+ *     would otherwise dispose child effects linked to the parent).
+ *  2. Inner effects are explicitly disposed when the branch changes.
+ *
+ * SolidJS equivalent: <Show when={} fallback={}>
+ */
+/**
+ * Conditionally render content based on a reactive boolean.
+ *
+ * ```ts
+ * const [show, setShow] = createSignal(true);
+ * const fragment = createShow(
+ *   show,
+ *   () => h('div', null, 'Visible!'),
+ *   () => h('div', null, 'Hidden fallback'),
+ * );
+ * container.appendChild(fragment);
+ * ```
+ *
+ * Returns a DocumentFragment with comment markers. The content between
+ * markers is swapped reactively when `when()` changes.
+ */
+declare function createShow(when: () => unknown, thenFn: () => Node, elseFn?: () => Node): DocumentFragment;
+
+/**
+ * Forma DOM - Switch (Multi-branch Conditional)
+ *
+ * Maps a reactive value to one of N render branches.
+ * Caches previously rendered nodes for instant swap-back.
+ *
+ * Each cached branch gets its own reactive root (ownership scope) so that:
+ *  1. Inner effects survive when the switch effect re-runs (alien-signals
+ *     would otherwise dispose child effects linked to the parent).
+ *  2. Inner effects are explicitly disposed when the branch is evicted
+ *     from the cache or the switch itself is torn down.
+ *
+ * SolidJS equivalent: <Switch><Match when={}>
+ */
+interface SwitchCase<T> {
+    match: T;
+    render: () => Node;
+}
+/**
+ * Multi-branch conditional rendering with node caching.
+ *
+ * ```ts
+ * const [tab, setTab] = createSignal('home');
+ * const fragment = createSwitch(tab, [
+ *   { match: 'home', render: () => h('div', null, 'Home page') },
+ *   { match: 'about', render: () => h('div', null, 'About page') },
+ *   { match: 'contact', render: () => h('div', null, 'Contact page') },
+ * ], () => h('div', null, '404'));
+ * ```
+ *
+ * Previously rendered branches are cached — switching back to a tab
+ * re-inserts the cached node without re-rendering.
+ */
+declare function createSwitch<T>(value: () => T, cases: SwitchCase<T>[], fallback?: () => Node): DocumentFragment;
+
+/**
+ * Forma DOM - Portal
+ *
+ * Renders children into a different DOM container than the parent.
+ * Useful for modals, tooltips, dropdowns that need to escape overflow.
+ *
+ * SolidJS equivalent: <Portal mount={}>
+ */
+/**
+ * Render content into an external DOM container.
+ *
+ * ```ts
+ * const modal = createPortal(
+ *   () => h('div', { class: 'modal' }, 'Modal content'),
+ *   document.body,
+ * );
+ * ```
+ *
+ * Returns a comment node placeholder. The actual content is rendered
+ * into the target container. Cleanup removes content from target.
+ */
+declare function createPortal(children: () => Node, target?: Element | string): Comment;
+
+/**
+ * Forma DOM - Error Boundary
+ *
+ * Catches errors during rendering and shows a fallback UI.
+ * Provides a retry function to re-attempt the original render.
+ *
+ * SolidJS equivalent: <ErrorBoundary fallback={}>
+ */
+/**
+ * Wrap a render function with error recovery.
+ *
+ * ```ts
+ * const fragment = createErrorBoundary(
+ *   () => h('div', null, riskyComponent()),
+ *   (error, retry) => h('div', { class: 'error' },
+ *     h('p', null, `Error: ${error.message}`),
+ *     h('button', { onClick: retry }, 'Retry'),
+ *   ),
+ * );
+ * ```
+ *
+ * If `tryFn` throws, `catchFn` is called with the error and a retry function.
+ * Calling `retry()` re-runs `tryFn`.
+ */
+declare function createErrorBoundary(tryFn: () => Node, catchFn: (error: Error, retry: () => void) => Node): DocumentFragment;
+
+/**
+ * Forma DOM - Suspense
+ *
+ * A Suspense boundary that shows fallback content while async resources
+ * inside the children function are loading. Uses comment markers
+ * (like createShow, createList) for zero-wrapper rendering.
+ *
+ * When all resources resolve, the fallback is swapped for the real content.
+ * If a resource errors, the fallback remains (pair with createErrorBoundary
+ * for error handling).
+ *
+ * SolidJS equivalent: <Suspense fallback={}>
+ */
+
+/**
+ * Create a Suspense boundary that shows fallback content while async resources
+ * inside the children function are loading.
+ *
+ * Uses comment markers: `<!--forma-suspense-->` / `<!--/forma-suspense-->`
+ *
+ * When all resources resolve, the fallback is swapped for the real content.
+ * If a resource errors, the fallback remains (pair with createErrorBoundary
+ * for errors).
+ *
+ * ```ts
+ * const frag = createSuspense(
+ *   () => h('div', null, 'Loading...'),
+ *   () => {
+ *     const data = createResource(source, fetcher);
+ *     return h('div', null, () => data()?.name ?? '');
+ *   },
+ * );
+ * container.appendChild(frag);
+ * ```
+ */
+declare function createSuspense(fallback: () => Node, children: () => Node): DocumentFragment;
+
+/**
+ * Hydrate an SSR island in-place. Runs the component in hydration mode so
+ * h() returns descriptors, then walks the descriptor tree against the SSR DOM
+ * to attach event handlers and reactive bindings. No DOM elements are created.
+ *
+ * The component function MUST be called inside a reactive root (createRoot)
+ * so that effects created during adoption are properly tracked.
+ *
+ * Returns the active root element — usually `target`, but may be a replacement
+ * element when the CSR fallback fires (empty island shell replaced by the
+ * component's own root element).
+ *
+ * @param component  A function that builds the UI (calls h(), createShow, etc.)
+ * @param target     The container element with `data-forma-ssr` attribute
+ */
+declare function hydrateIsland(component: () => unknown, target: Element): Element;
+
+/**
+ * Forma DOM - Island Activation
+ *
+ * Discovers SSR-rendered islands via [data-forma-island] attributes,
+ * loads props (inline or script_tag), and hydrates each island inside
+ * an independent createRoot scope with try/catch error isolation.
+ */
+/** Function that creates a component's DOM tree (same for CSR and hydration). */
+type IslandHydrateFn = (props: Record<string, unknown> | null) => unknown;
+/**
+ * Discover and activate all SSR-rendered islands on the page.
+ *
+ * Each island is activated inside its own createRoot scope with try/catch
+ * isolation — a broken island never takes down its siblings.
+ *
+ * @param registry  Map of component names to hydration functions.
+ */
+declare function activateIslands(registry: Record<string, IslandHydrateFn>): void;
+
+/**
+ * Forma Component - Define
+ *
+ * Component definition system where the setup function runs ONCE.
+ * Reactivity comes from signals, not re-rendering.
+ * Backed by alien-signals via forma/reactive.
+ */
+type CleanupFn = () => void;
+type SetupFn = () => HTMLElement | DocumentFragment;
+interface ComponentDef {
+    setup: SetupFn;
+    name?: string;
+}
+/**
+ * Register a callback that runs after the component's setup completes.
+ * If the callback returns a function, that function is called on unmount.
+ * Must be called inside a setup function.
+ */
+declare function onMount(fn: () => void | CleanupFn): void;
+/**
+ * Register a callback that runs when the component is disposed.
+ * Must be called inside a setup function.
+ */
+declare function onUnmount(fn: () => void): void;
+/**
+ * Define a component from a setup function or definition object.
+ * Returns a factory function that, when called, produces a DOM element
+ * with attached lifecycle and disposal logic.
+ *
+ * The setup function runs ONCE per factory call. Reactivity is driven
+ * by signals, not by re-running setup.
+ */
+declare function defineComponent(setupOrDef: SetupFn | ComponentDef): () => HTMLElement | DocumentFragment;
+/**
+ * Dispose a component that was created via defineComponent.
+ * This runs all onUnmount callbacks and disposes all tracked effects.
+ */
+declare function disposeComponent(dom: HTMLElement | DocumentFragment): void;
+/**
+ * Track an effect disposal within the current component's lifecycle.
+ * Call this inside a setup function to ensure effects are cleaned up
+ * when the component is disposed.
+ */
+declare function trackDisposer(dispose: () => void): void;
+
+/**
+ * Forma Component - Context
+ *
+ * Dependency injection via stack-based context.
+ * Simpler than React's Provider component tree: provide() pushes a value,
+ * inject() reads the top, component teardown pops automatically.
+ * Zero dependencies -- native browser APIs only.
+ */
+interface Context<T> {
+    /** Unique identifier for this context. */
+    readonly id: symbol;
+    /** Value returned when no provider is active. */
+    readonly defaultValue: T;
+}
+/**
+ * Create a new context with a default value.
+ *
+ * ```ts
+ * const ThemeCtx = createContext('light');
+ * ```
+ */
+declare function createContext<T>(defaultValue: T): Context<T>;
+/**
+ * Provide a value for a context.
+ * The value is pushed onto the context's stack and will be returned by
+ * inject() until it is removed via unprovide() or overridden by a nested provide().
+ *
+ * ```ts
+ * provide(ThemeCtx, 'dark');
+ * ```
+ */
+declare function provide<T>(ctx: Context<T>, value: T): void;
+/**
+ * Read the current value of a context.
+ * Returns the most recently provided value, or the default if none was provided.
+ *
+ * ```ts
+ * const theme = inject(ThemeCtx); // 'dark' if provided, else 'light'
+ * ```
+ */
+declare function inject<T>(ctx: Context<T>): T;
+/**
+ * Remove the most recent provided value for a context.
+ * Used during component teardown to restore the previous scope.
+ *
+ * ```ts
+ * unprovide(ThemeCtx);
+ * ```
+ */
+declare function unprovide<T>(ctx: Context<T>): void;
+
+/**
+ * Forma State - Store
+ *
+ * Deep reactive store with path-based signal granularity.
+ * Every property path (e.g. `user.name`, `items.0.done`) gets its own signal,
+ * so only effects that read a specific path are notified when it changes.
+ *
+ * Inspired by SolidJS's createStore and Vue's reactive(), with:
+ * - Lazy proxy wrapping (child objects proxied on first access)
+ * - Structural sharing (replacing an object invalidates child signals)
+ * - Array mutation batching (push/pop/splice/sort etc. batch their signals)
+ *
+ * Backed by alien-signals via forma/reactive.
+ */
+type StoreSetter<T extends object> = (partial: Partial<T> | ((prev: T) => Partial<T>)) => void;
+/**
+ * Create a deep reactive store.
+ *
+ * Returns a tuple of `[getter proxy, setter function]`.
+ * The getter proxy tracks reads at every property path via dedicated signals.
+ * Setting a property (either via `setState()` or direct mutation like
+ * `state.user.name = 'Bob'`) only notifies effects that actually read that
+ * specific path.
+ *
+ * ```ts
+ * const [state, setState] = createStore({
+ *   count: 0,
+ *   user: { name: 'Alice', age: 30 },
+ *   items: [{ text: 'Buy milk', done: false }],
+ * });
+ *
+ * // Fine-grained reads
+ * state.user.name;          // tracked at path "user.name"
+ * state.items[0].done;      // tracked at path "items.0.done"
+ *
+ * // Setter API (batched)
+ * setState({ count: 1 });
+ * setState(prev => ({ count: prev.count + 1 }));
+ *
+ * // Direct mutation (via Proxy set trap)
+ * state.user.name = 'Bob';  // only "user.name" subscribers notified
+ * state.items[0].done = true;
+ *
+ * // Array mutations
+ * state.items.push({ text: 'Walk dog', done: false });
+ * ```
+ */
+declare function createStore<T extends object>(initial: T): [get: T, set: StoreSetter<T>];
+
+/**
+ * Forma State - History
+ *
+ * Undo/redo for any signal. Tracks changes and maintains undo/redo stacks
+ * with reactive canUndo/canRedo signals.
+ * Zero dependencies -- native browser APIs only.
+ */
+interface HistoryControls<T> {
+    /** Undo the last change, restoring the previous value. */
+    undo: () => void;
+    /** Redo the last undone change. */
+    redo: () => void;
+    /** Reactive getter: true if undo is available. */
+    canUndo: () => boolean;
+    /** Reactive getter: true if redo is available. */
+    canRedo: () => boolean;
+    /** Reactive getter: the full history stack (past + current + future). */
+    history: () => T[];
+    /** Reactive getter: current position in the history stack (0-based). */
+    cursor: () => number;
+    /** Clear all history, keeping only the current value. */
+    clear: () => void;
+}
+/**
+ * Create undo/redo history tracking for a signal.
+ *
+ * ```ts
+ * const [count, setCount] = createSignal(0);
+ * const h = createHistory([count, setCount], { maxLength: 50 });
+ *
+ * setCount(1);
+ * setCount(2);
+ * h.undo();            // count() === 1
+ * h.redo();            // count() === 2
+ * h.canUndo();         // true (reactive)
+ * ```
+ */
+declare function createHistory<T>(source: [get: () => T, set: (v: T) => void], options?: {
+    maxLength?: number;
+}): HistoryControls<T>;
+
+/**
+ * Forma State - Persist
+ *
+ * Auto-persist a signal to localStorage (or any Storage-compatible backend).
+ * Reads stored value on creation; writes on every signal change.
+ * Zero dependencies -- native browser APIs only.
+ */
+interface PersistOptions<T> {
+    /** Storage backend. Defaults to localStorage. */
+    storage?: Storage;
+    /** Custom serializer. Defaults to JSON.stringify. */
+    serialize?: (v: T) => string;
+    /** Custom deserializer. Defaults to JSON.parse. */
+    deserialize?: (s: string) => T;
+}
+/**
+ * Persist a signal's value to storage.
+ *
+ * On creation, reads the stored value (if any) and hydrates the signal.
+ * Then sets up an effect to write to storage whenever the signal changes.
+ *
+ * ```ts
+ * const [theme, setTheme] = createSignal('light');
+ * persist([theme, setTheme], 'app:theme');
+ *
+ * setTheme('dark'); // auto-saved to localStorage under key 'app:theme'
+ * ```
+ */
+declare function persist<T>(source: [get: () => T, set: (v: T) => void], key: string, options?: PersistOptions<T>): void;
+
+interface EventBus<T extends Record<string, any>> {
+    on<K extends keyof T>(event: K, handler: (payload: T[K]) => void): () => void;
+    once<K extends keyof T>(event: K, handler: (payload: T[K]) => void): () => void;
+    emit<K extends keyof T>(event: K, payload: T[K]): void;
+    off<K extends keyof T>(event: K, handler: (payload: T[K]) => void): void;
+    clear(): void;
+}
+declare function createBus<T extends Record<string, any> = Record<string, any>>(): EventBus<T>;
+
+declare function delegate<K extends keyof HTMLElementEventMap>(container: HTMLElement | Document, selector: string, event: K, handler: (e: HTMLElementEventMap[K], matchedEl: HTMLElement) => void, options?: AddEventListenerOptions): () => void;
+
+type KeyCombo = string;
+interface KeyOptions {
+    target?: EventTarget;
+    preventDefault?: boolean;
+}
+declare function onKey(combo: KeyCombo, handler: (e: KeyboardEvent) => void, options?: KeyOptions): () => void;
+
+declare function $<T extends HTMLElement = HTMLElement>(selector: string, parent?: ParentNode): T | null;
+declare function $$<T extends HTMLElement = HTMLElement>(selector: string, parent?: ParentNode): T[];
+
+declare function addClass(el: HTMLElement, ...classes: string[]): void;
+declare function removeClass(el: HTMLElement, ...classes: string[]): void;
+declare function toggleClass(el: HTMLElement, className: string, force?: boolean): boolean;
+declare function setStyle(el: HTMLElement, styles: Partial<CSSStyleDeclaration>): void;
+declare function setAttr(el: HTMLElement, attrs: Record<string, string | boolean | null>): void;
+declare function setText(el: HTMLElement, text: string): void;
+declare function setHTML(el: HTMLElement, html: string): void;
+
+declare function closest<T extends HTMLElement = HTMLElement>(el: HTMLElement, selector: string): T | null;
+declare function children<T extends HTMLElement = HTMLElement>(el: HTMLElement, selector?: string): T[];
+declare function siblings<T extends HTMLElement = HTMLElement>(el: HTMLElement, selector?: string): T[];
+declare function parent<T extends HTMLElement = HTMLElement>(el: HTMLElement): T | null;
+declare function nextSibling<T extends HTMLElement = HTMLElement>(el: HTMLElement, selector?: string): T | null;
+declare function prevSibling<T extends HTMLElement = HTMLElement>(el: HTMLElement, selector?: string): T | null;
+
+declare function onResize(el: HTMLElement, handler: (entry: ResizeObserverEntry) => void): () => void;
+declare function onIntersect(el: HTMLElement, handler: (entry: IntersectionObserverEntry) => void, options?: IntersectionObserverInit): () => void;
+declare function onMutation(el: HTMLElement, handler: (mutations: MutationRecord[]) => void, options?: MutationObserverInit): () => void;
+
+/**
+ * Forma Storage - Local
+ *
+ * Typed localStorage wrapper with graceful error handling.
+ * Zero dependencies — native browser APIs only.
+ */
+interface TypedStorage$1<T> {
+    get(): T | null;
+    set(value: T): void;
+    remove(): void;
+    key: string;
+}
+interface StorageOptions$1<T> {
+    serialize?: (v: T) => string;
+    deserialize?: (s: string) => T;
+}
+/**
+ * Create a typed localStorage wrapper for the given key.
+ *
+ * ```ts
+ * const store = createLocalStorage<{ name: string }>('user');
+ * store.set({ name: 'Alice' });
+ * store.get(); // { name: 'Alice' }
+ * store.remove();
+ * ```
+ */
+declare function createLocalStorage<T>(key: string, options?: StorageOptions$1<T>): TypedStorage$1<T>;
+
+/**
+ * Forma Storage - Session
+ *
+ * Typed sessionStorage wrapper with graceful error handling.
+ * Zero dependencies — native browser APIs only.
+ */
+interface TypedStorage<T> {
+    get(): T | null;
+    set(value: T): void;
+    remove(): void;
+    key: string;
+}
+interface StorageOptions<T> {
+    serialize?: (v: T) => string;
+    deserialize?: (s: string) => T;
+}
+/**
+ * Create a typed sessionStorage wrapper for the given key.
+ *
+ * ```ts
+ * const store = createSessionStorage<{ token: string }>('auth');
+ * store.set({ token: 'abc123' });
+ * store.get(); // { token: 'abc123' }
+ * store.remove();
+ * ```
+ */
+declare function createSessionStorage<T>(key: string, options?: StorageOptions<T>): TypedStorage<T>;
+
+/**
+ * Forma Storage - IndexedDB
+ *
+ * Simplified IndexedDB wrapper with lazy connection and promise-based API.
+ * Zero dependencies — native browser APIs only.
+ */
+interface IDBStore<T> {
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    getAll(): Promise<T[]>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+}
+/**
+ * Create a simplified IndexedDB store.
+ *
+ * ```ts
+ * const store = createIndexedDB<User>('myApp', 'users');
+ * await store.set('u1', { name: 'Alice' });
+ * const user = await store.get('u1'); // { name: 'Alice' }
+ * ```
+ */
+declare function createIndexedDB<T>(dbName: string, storeName?: string): IDBStore<T>;
+
+/**
+ * Forma HTTP - Fetch
+ *
+ * Typed fetch wrapper with reactive signal integration.
+ * Zero dependencies — native browser APIs only.
+ */
+interface FetchOptions<T> extends Omit<RequestInit, 'signal'> {
+    base?: string;
+    params?: Record<string, string>;
+    timeout?: number;
+    transform?: (data: unknown) => T;
+}
+interface FetchResult<T> {
+    data: () => T | null;
+    error: () => Error | null;
+    loading: () => boolean;
+    refetch: () => Promise<void>;
+    abort: () => void;
+}
+/**
+ * Create a reactive fetch that exposes data/error/loading as signals.
+ *
+ * If `url` is a signal getter (function), an effect auto-refetches when it
+ * changes.
+ *
+ * ```ts
+ * const { data, loading, error, refetch, abort } = createFetch<User[]>('/api/users');
+ * ```
+ */
+declare function createFetch<T>(url: string | (() => string), options?: FetchOptions<T>): FetchResult<T>;
+/**
+ * One-shot fetch that returns parsed JSON.
+ *
+ * ```ts
+ * const users = await fetchJSON<User[]>('/api/users');
+ * ```
+ */
+declare function fetchJSON<T>(url: string, options?: RequestInit): Promise<T>;
+
+/**
+ * Forma HTTP - Server-Sent Events
+ *
+ * Reactive SSE wrapper with signal integration.
+ * Zero dependencies — native browser APIs only.
+ */
+interface SSEOptions {
+    withCredentials?: boolean;
+    headers?: Record<string, string>;
+}
+interface SSEConnection<T = unknown> {
+    data: () => T | null;
+    error: () => Event | null;
+    connected: () => boolean;
+    close: () => void;
+    on(event: string, handler: (data: unknown) => void): () => void;
+}
+/**
+ * Create a reactive Server-Sent Events connection.
+ *
+ * ```ts
+ * const sse = createSSE<{ message: string }>('/api/events');
+ * createEffect(() => {
+ *   const msg = sse.data();
+ *   if (msg) console.log(msg.message);
+ * });
+ * ```
+ */
+declare function createSSE<T = unknown>(url: string, options?: SSEOptions): SSEConnection<T>;
+
+/**
+ * Forma HTTP - WebSocket
+ *
+ * Reactive WebSocket wrapper with auto-reconnect and signal integration.
+ * Zero dependencies — native browser APIs only.
+ */
+type WSStatus = 'connecting' | 'open' | 'closed' | 'error';
+interface WSOptions {
+    protocols?: string | string[];
+    reconnect?: boolean;
+    reconnectInterval?: number;
+    maxReconnects?: number;
+}
+interface WSConnection<TSend = unknown, TReceive = unknown> {
+    data: () => TReceive | null;
+    status: () => WSStatus;
+    send(data: TSend): void;
+    close(): void;
+    on(handler: (data: TReceive) => void): () => void;
+}
+/**
+ * Create a reactive WebSocket connection with auto-reconnect.
+ *
+ * ```ts
+ * const ws = createWebSocket<string, ChatMessage>('wss://chat.example.com');
+ * ws.send('hello');
+ * createEffect(() => {
+ *   const msg = ws.data();
+ *   if (msg) console.log(msg);
+ * });
+ * ```
+ */
+declare function createWebSocket<TSend = unknown, TReceive = unknown>(url: string, options?: WSOptions): WSConnection<TSend, TReceive>;
+
+/**
+ * FormaJS Server - Action
+ *
+ * Creates an action that wraps a server function with optimistic UI support.
+ * The action immediately applies an optimistic update, then reconciles when
+ * the server responds (or rolls back on error).
+ */
+
+interface ActionOptions<Args extends unknown[], Result> {
+    /**
+     * Apply an optimistic update immediately when the action is called.
+     * This runs BEFORE the server function.
+     * Store whatever you need to roll back in the return value or via closures.
+     */
+    optimistic?: (...args: Args) => void;
+    /**
+     * Called when the server function resolves successfully.
+     * Use this to apply the server result to local state.
+     */
+    onSuccess?: (result: Result, ...args: Args) => void;
+    /**
+     * Called when the server function rejects.
+     * Use this to roll back the optimistic update.
+     */
+    onError?: (error: unknown, ...args: Args) => void;
+    /**
+     * Resources to refetch after the action completes successfully.
+     * Used with single-flight mutations: if the server response includes
+     * revalidation data, these resources are updated without a refetch.
+     */
+    invalidates?: Resource<unknown>[];
+}
+interface Action<Args extends unknown[], Result> {
+    /** Execute the action. */
+    (...args: Args): Promise<Result>;
+    /** Whether the action is currently in-flight. */
+    pending: () => boolean;
+    /** The last error from the action (or undefined). */
+    error: () => unknown;
+    /** Clear the error state. */
+    clearError: () => void;
+}
+/**
+ * Create an action that wraps a server function with optimistic UI.
+ *
+ * ```ts
+ * const addTodo = createAction(
+ *   serverCreateTodo,
+ *   {
+ *     optimistic: (text) => {
+ *       // Immediately add to local list
+ *       setTodos(prev => [...prev, { text, done: false, id: 'temp' }]);
+ *     },
+ *     onSuccess: (result) => {
+ *       // Replace temp item with server result
+ *       setTodos(prev => prev.map(t => t.id === 'temp' ? result : t));
+ *     },
+ *     onError: (err, text) => {
+ *       // Remove the optimistic item
+ *       setTodos(prev => prev.filter(t => t.id !== 'temp'));
+ *     },
+ *     invalidates: [todosResource],
+ *   },
+ * );
+ *
+ * // Use:
+ * await addTodo('Buy milk');
+ * ```
+ */
+declare function createAction<Args extends unknown[], Result>(serverFn: (...args: Args) => Promise<Result>, options?: ActionOptions<Args, Result>): Action<Args, Result>;
+
+/**
+ * FormaJS Server - Mutation
+ *
+ * Single-flight mutation pattern: the server response carries both the
+ * mutation result AND fresh data for dependent resources in one round trip.
+ *
+ * Without single-flight:
+ *   Client -> Server: createTodo("Buy milk")
+ *   Server -> Client: { id: 1, text: "Buy milk" }
+ *   Client -> Server: GET /api/todos (refetch to update list)
+ *   Server -> Client: [all todos]
+ *
+ * With single-flight:
+ *   Client -> Server: createTodo("Buy milk")
+ *   Server -> Client: { data: {...}, __revalidate: { "/api/todos": [all todos] } }
+ *   (No second request needed!)
+ */
+
+interface MutationResponse<T> {
+    /** The mutation result. */
+    data: T;
+    /**
+     * Fresh data for dependent resources, keyed by resource identifier.
+     * When present, the client updates these resources directly instead of refetching.
+     */
+    __revalidate?: Record<string, unknown>;
+}
+/**
+ * Register a resource with a key so it can be revalidated by single-flight mutations.
+ *
+ * ```ts
+ * const todos = createResource(
+ *   () => true,
+ *   () => fetch('/api/todos').then(r => r.json()),
+ * );
+ * registerResource('/api/todos', todos);
+ * ```
+ */
+declare function registerResource(key: string, resource: Resource<unknown>): void;
+/**
+ * Unregister a resource (call on cleanup/unmount).
+ */
+declare function unregisterResource(key: string): void;
+/**
+ * Apply revalidation data from a single-flight mutation response.
+ * For each key in the revalidate map, find the matching resource
+ * and mutate it directly with the fresh data (skipping a refetch).
+ */
+declare function applyRevalidation(revalidateData: Record<string, unknown>): void;
+/**
+ * Listen for revalidation events dispatched by $$serverFunction.
+ * Call this once during app initialization to enable automatic
+ * single-flight mutation handling.
+ *
+ * ```ts
+ * // In your app entry:
+ * import { enableAutoRevalidation } from 'forma/server/mutation';
+ * enableAutoRevalidation();
+ * ```
+ */
+declare function enableAutoRevalidation(): () => void;
+/**
+ * Wrap a server function response to include revalidation data.
+ * Use this on the server side to enable single-flight mutations.
+ *
+ * ```ts
+ * // Server-side:
+ * async function createTodo(text: string) {
+ *   "use server";
+ *   const newTodo = await db.insert('todos', { text, done: false });
+ *   const allTodos = await db.query('todos');
+ *   return withRevalidation(newTodo, {
+ *     '/api/todos': allTodos,
+ *   });
+ * }
+ * ```
+ */
+declare function withRevalidation<T>(data: T, revalidate: Record<string, unknown>): MutationResponse<T>;
+
+/**
+ * FormaJS Server - RPC Client
+ *
+ * Provides the client-side stub function that replaces "use server" function
+ * bodies after compilation. Each call becomes a fetch POST to the server endpoint.
+ */
+/**
+ * Create an RPC stub function for a server function.
+ * This replaces the original function body on the client side.
+ *
+ * @param endpoint - The RPC endpoint path (e.g. "/rpc/createTodo_a1b2c3")
+ * @returns An async function that sends args to the server and returns the result
+ */
+declare function $$serverFunction<T extends (...args: any[]) => Promise<any>>(endpoint: string): T;
+
+/**
+ * FormaJS Server - RPC Handler
+ *
+ * Server-side registry and request handler for "use server" functions.
+ * Framework-agnostic — works with any Node.js HTTP server, Express, Hono, etc.
+ */
+type ServerFunction = (...args: unknown[]) => Promise<unknown>;
+/**
+ * Register a server function at a specific endpoint.
+ * Called by the server-side compiled output.
+ */
+declare function registerServerFunction(endpoint: string, fn: ServerFunction): void;
+/**
+ * Get a registered server function by endpoint.
+ */
+declare function getServerFunction(endpoint: string): ServerFunction | undefined;
+/**
+ * Get all registered server function endpoints.
+ */
+declare function getRegisteredEndpoints(): string[];
+interface RPCRequest {
+    args: unknown[];
+}
+interface RPCResponse {
+    data?: unknown;
+    error?: string;
+    __revalidate?: Record<string, unknown>;
+}
+declare function handleRPC(endpoint: string, body: RPCRequest, revalidateData?: Record<string, unknown>): Promise<RPCResponse>;
+/**
+ * Create a middleware-style handler for use with Express-like frameworks.
+ *
+ * ```ts
+ * import { createRPCMiddleware } from 'forma/server/rpc-handler';
+ * app.use('/rpc', createRPCMiddleware());
+ * ```
+ */
+declare function createRPCMiddleware(): (req: {
+    url: string;
+    method: string;
+    body?: unknown;
+}, res: {
+    json: (data: unknown) => void;
+    status: (code: number) => {
+        json: (data: unknown) => void;
+    };
+}) => Promise<void>;
+
+declare global {
+    interface Window {
+        __FORMA_WASM__?: {
+            loader: string;
+            binary: string;
+            ir: string;
+        };
+    }
+}
+/** Full page render via WASM. */
+declare function renderLocal(slotsJson: string): Promise<string>;
+/** Fragment render (single island) via WASM. */
+declare function renderIsland(slotsJson: string, islandId: number): Promise<string>;
+
+export { $, $$, $$serverFunction, type Action, type ActionOptions, type IslandHydrateFn, type MutationResponse, type RPCRequest, type RPCResponse, activateIslands, addClass, applyRevalidation, batch, children, cleanup, closest, createAction, createBus, createComputed, createContext, createEffect, createErrorBoundary, createFetch, createHistory, createIndexedDB, createList, createLocalStorage, createMemo, createPortal, createRPCMiddleware, createReducer, createRef, createResource, createRoot, createSSE, createSessionStorage, createShow, createStore, createSuspense, createSwitch, createText, createWebSocket, defineComponent, delegate, disposeComponent, enableAutoRevalidation, fetchJSON, fragment, getRegisteredEndpoints, getServerFunction, h, handleRPC, hydrateIsland, inject, longestIncreasingSubsequence, mount, nextSibling, on, onCleanup, onError, onIntersect, onKey, onMount, onMutation, onResize, onUnmount, parent, persist, prevSibling, provide, reconcileList, registerResource, registerServerFunction, removeClass, renderIsland, renderLocal, setAttr, setHTML, setStyle, setText, siblings, toggleClass, trackDisposer, unprovide, unregisterResource, untrack, withRevalidation };