sibujs 3.4.0 → 4.0.0

package/dist/index.d.cts

@@ -1,12 +1,16 @@
 import { N as NodeChild, a as NodeChildren, T as TagProps } from './tagFactory-Bzupt4Pj.cjs';
 export { D as Dispose, S as SVG_NS, t as tagFactory } from './tagFactory-Bzupt4Pj.cjs';
-export { T as TrustedHTML, t as trustHTML } from './ssr-D62yFwuw.cjs';
+export { T as TrustedHTML, t as trustHTML } from './ssr-BiPRdZ6n.cjs';
 import { R as ReactiveSignal } from './signal-BnWpq6WB.cjs';
 
 interface ErrorBoundaryOptions {
     /**
-     * Fallback renderer given an Error and retry callback.
-     * Memoized internally — only re-created when the error changes.
+     * Fallback renderer, called with this boundary's Error and its own `retry`.
+     *
+     * Safe to share one fallback function across many boundaries: the Error and
+     * the retry callback always belong to the boundary that invoked it, even when
+     * two boundaries fail with identical messages. It is re-invoked whenever the
+     * boundary re-renders its error state; do not rely on it running only once.
      */
     fallback?: (error: Error, retry: () => void) => Element;
     /**
@@ -14,11 +18,27 @@ interface ErrorBoundaryOptions {
      */
     onError?: (error: Error) => void;
     /**
-     * A list of reactive getters. Whenever any of these values change
-     * after an error has been caught, the boundary automatically resets
-     * (clears the error and re-renders). Useful for recovering from a
-     * failed render after the user navigates, changes filters, or
-     * otherwise picks a new input that might not fail this time.
+     * A list of reactive getters. Whenever any of these VALUES changes AFTER an
+     * error has been caught, the boundary automatically resets (clears the error
+     * and re-renders). Useful for recovering from a failed render after the user
+     * navigates, changes filters, or otherwise picks a new input that might not
+     * fail this time.
+     *
+     * Getters are selectors, compared by `Object.is` against the values captured
+     * when the error was caught. Replacing the source object without changing the
+     * selected result does not reset the boundary:
+     *
+     * ```ts
+     * resetKeys: [() => route().pathname]   // only the pathname matters
+     * ```
+     *
+     * "After" is literal: a key change that is itself the reason the children
+     * threw belongs to that failure and will not undo it. Only a change observed
+     * once the boundary is already showing its fallback triggers recovery.
+     *
+     * The getters are evaluated only while the boundary is failed, so a getter
+     * that throws is reported through the runtime error pipeline at that point
+     * rather than at construction.
      *
      * @example
      * ```ts
@@ -44,7 +64,8 @@ type ErrorBoundaryProps = ErrorBoundaryOptions;
  *   `unhandledrejection` events instead.
  * - Supports nested ErrorBoundaries (inner catches first, outer catches propagation)
  * - Retry functionality to clear error and re-render children
- * - Memoized fallback to avoid re-creating fallback UI on every render
+ * - Fallback state is per-boundary: a shared fallback function never leaks one
+ *   boundary's Error or retry callback into another
  * - onError callback for logging/telemetry
  * - Improved CSS styling
  */
@@ -122,6 +143,77 @@ interface LoadingProps {
  */
 declare function Loading(props?: LoadingProps): HTMLElement;
 
+/**
+ * Central runtime error pipeline.
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * The reactive runtime has to *contain* application exceptions: a subscriber
+ * that throws must not abort the notification drain, or one broken component
+ * would freeze every unrelated binding on the page. Containment, however, was
+ * previously implemented as a bare `catch` that only warned when a dev-mode
+ * flag was on — so in a production build an application exception thrown from
+ * an effect re-run became literally nothing: no log, no handler, no signal that
+ * anything had happened.
+ *
+ * Containment is not silence. This module keeps the containment and makes the
+ * failure observable, with ONE resolution order for every phase of the runtime:
+ *
+ *   1. the nearest `ErrorBoundary`, but only if it EXPLICITLY claims the error
+ *   2. the application's configured runtime error handler
+ *   3. `console.error` — in production builds too, never gated on dev mode
+ *
+ * Every `catch` in the runtime that is not re-thrown routes here, so
+ * applications have exactly one place to install reporting/telemetry.
+ */
+/** The runtime activity that was executing when the error escaped. */
+type RuntimeErrorPhase = "effect" | "binding" | "derived" | "cleanup" | "event" | "async" | "render" | "scheduler";
+interface RuntimeErrorContext {
+    /** Which part of the runtime was executing. */
+    phase: RuntimeErrorPhase;
+    /** Debug label of the failing effect/computed/binding, when it has one. */
+    name?: string;
+    /**
+     * DOM node the failure is associated with, when one is known. Given a node,
+     * an enclosing `ErrorBoundary` gets first refusal — but only a boundary that
+     * explicitly claims the error stops the fallback chain. See `reportError`.
+     */
+    node?: unknown;
+}
+type RuntimeErrorHandler = (error: unknown, context: RuntimeErrorContext) => void;
+/**
+ * Install an application-wide handler for errors the runtime caught and
+ * contained. Returns the previously installed handler so callers can restore
+ * it (tests, nested frameworks). Pass `null` to clear.
+ *
+ * The handler replaces the default `console.error` reporting. Throwing from
+ * inside the handler falls back to the default, so a broken reporter cannot
+ * itself silence the runtime.
+ *
+ * This is application/runtime-global state, NOT request-scoped: under SSR it is
+ * shared by every concurrent request in the process. Install it once at startup
+ * and derive any request-specific detail from the error/context instead.
+ */
+declare function setRuntimeErrorHandler(handler: RuntimeErrorHandler | null): RuntimeErrorHandler | null;
+/** The currently installed runtime error handler, if any. */
+declare function getRuntimeErrorHandler(): RuntimeErrorHandler | null;
+/**
+ * Report an error the runtime caught and contained.
+ *
+ * Resolution order: nearest claiming `ErrorBoundary` → configured runtime
+ * handler → `console.error`. Exactly one of those runs for a given report.
+ *
+ * Never throws — callers are inside `catch`/`finally` blocks where a secondary
+ * failure would corrupt teardown or abort a drain.
+ *
+ * @public Framework primitive, also usable by plugin/integration code that
+ * catches an application exception on SibuJS's behalf (custom rendering
+ * primitives, adapters) and wants it to follow the same boundary/handler
+ * resolution as a built-in one. Ordinary application code should prefer
+ * `ErrorBoundary` or `setRuntimeErrorHandler`.
+ */
+declare function reportError(error: unknown, context: RuntimeErrorContext): void;
+
 /**
  * An action is a reusable element-level behavior.
  * It receives the element and an optional parameter, and may return
@@ -163,6 +255,7 @@ declare function getAction<T = unknown>(name: string): ActionFn<T> | undefined;
  * ```
  */
 declare function action<T>(element: HTMLElement, action: ActionFn<T> | string, param: T): void;
+declare function action<T>(element: HTMLElement, action: ActionFn<T | undefined> | string): void;
 declare function action(element: HTMLElement, action: ActionFn<void> | string): void;
 /**
  * Fires a callback when the user clicks outside the element.
@@ -414,11 +507,50 @@ declare function when<T>(condition: () => T, thenBranch: () => NodeChild, elseBr
  */
 declare function match<T extends string | number>(value: () => T, cases: Record<string, () => NodeChild>, fallback?: () => NodeChild): Comment;
 
+/**
+ * Safety ceiling on the **total number of teardowns a single drain may execute**.
+ *
+ * A cleanup registering another cleanup is legitimate — a parent teardown
+ * releasing a child, a lifecycle hook re-arming — so a drain keeps going until
+ * the queue is stable, and ordinary finite chains of practical depth complete.
+ *
+ * The ceiling counts total teardown executions, not iterations over the queue.
+ * Capping iterations abandons finite work purely for crossing the boundary,
+ * which is indistinguishable from a leak; capping total work distinguishes
+ * ordinary reentrant chains from typical runaway behaviour far better.
+ *
+ * It is nonetheless an **absolute work bound**, not a recursion detector. It
+ * primarily protects against cleanup production that does not terminate — most
+ * often recursive self-registration — but an exceptionally large *finite* chain
+ * needing more than this many executions reaches it just the same. Either way
+ * the condition is reported rather than silently swallowed, so bounded
+ * protection never passes as completed cleanup — see {@link reportDrainRunaway}.
+ */
+declare const MAX_DRAIN_TEARDOWNS = 10000;
+/**
+ * Report a cleanup queue that did not stabilise within {@link MAX_DRAIN_TEARDOWNS}.
+ *
+ * Uses the existing console-based lifecycle convention; deliberately not a new
+ * public error API. Reported unconditionally (not dev-gated) because it means
+ * the framework stopped doing teardown work it was asked to do.
+ */
+declare function reportDrainRunaway(label: string, executed: number, remaining: number): void;
 /**
  * Register a teardown function for a DOM node.
  * When dispose(node) is called, all registered teardowns run.
  */
 declare function registerDisposer(node: Node, teardown: () => void): void;
+/**
+ * Drop a previously registered teardown for a node without running it.
+ *
+ * For owners that can be released independently of their node — an enhancement
+ * disposed while its server markup stays on the page, and possibly re-enhanced
+ * afterwards — the node-level entry would otherwise accumulate one dead closure
+ * per generation, since `dispose()` is the only thing that clears the map.
+ * The teardown is assumed to have already run (or to be deliberately abandoned);
+ * this only releases the reference.
+ */
+declare function unregisterDisposer(node: Node, teardown: () => void): void;
 /**
  * Run all registered teardowns for a node and its descendants,
  * cleaning up reactive subscriptions to prevent memory leaks.
@@ -428,6 +560,25 @@ declare function registerDisposer(node: Node, teardown: () => void): void;
  * on deeply nested DOM trees.
  */
 declare function dispose(node: Node): void;
+/**
+ * Replace every child of `parent` with `next`, disposing the outgoing children
+ * first.
+ *
+ * Native `replaceChildren()` detaches nodes without running SibuJS teardown, so
+ * any reactive binding, lifecycle hook, or listener inside the removed subtree
+ * survives as an unreachable zombie: it keeps firing against detached DOM and
+ * is never collected. This helper enforces the disposal invariant — a
+ * SibuJS-owned node removed permanently from the DOM is disposed exactly once.
+ *
+ * **A node in `next` is never disposed, even when it currently sits somewhere
+ * inside an outgoing subtree.** Native `replaceChildren()` would move such a
+ * node out of the content being replaced and keep it alive, and this helper
+ * preserves those semantics: incoming nodes are detached *before* the outgoing
+ * roots are disposed, so the dispose-walk cannot reach them. Everything else in
+ * those outgoing subtrees is still torn down, so preserving one descendant does
+ * not leak its former siblings or ancestors.
+ */
+declare function replaceChildrenSafely(parent: ParentNode, ...next: Node[]): void;
 /**
  * Check for potential binding leaks. Returns the number of active DOM bindings.
  * In dev mode, logs a warning if the count exceeds the threshold.
@@ -499,9 +650,19 @@ declare function DynamicComponent(is: () => string | Component$1): HTMLElement;
  *    skipping DOM operations for nodes that are part of the LIS.
  *
  * The render callback receives reactive getters `() => T` and `() => number`
- * instead of plain values. This ensures the callback always reads fresh data
- * when a keyed item's data changes but its key stays the same, since the DOM
- * is reused without re-calling render.
+ * instead of plain values. Each keyed row owns its own item and index cells,
+ * written by reconciliation when the row is reused. `render` therefore runs
+ * exactly ONCE per key — identity is preserved across updates — while anything
+ * inside the row that reads `item()` or `index()` re-runs when reconciliation
+ * assigns that row a new item or position.
+ *
+ * Identity is not value freshness: a row keeps its DOM node when its key is
+ * unchanged, and still updates its contents when the item behind that key is
+ * replaced.
+ *
+ * Reading `item()` subscribes to the ROW's cell, not to the whole-array signal,
+ * so a row only re-renders when its own item/index actually changes — mutating
+ * an unrelated row does not disturb it.
  *
  * @param getArray A reactive getter returning an array.
  * @param render A function that receives reactive item and index getters and returns a NodeChild.
@@ -1105,8 +1266,26 @@ interface AsyncDerivedState<T> {
     loading: () => boolean;
     /** The last caught error, or `null`. */
     error: () => unknown | null;
-    /** Manually re-run the async computation. */
+    /** Manually re-run the async computation. No-op after `dispose()`. */
     refresh: () => void;
+    /**
+     * Stop the derivation permanently: unsubscribe from every tracked source,
+     * abort the in-flight run, and ignore any promise that resolves afterwards.
+     *
+     * Idempotent. An `asyncDerived` created inside a component or route must be
+     * disposed when that scope tears down — otherwise it stays subscribed to its
+     * sources for the lifetime of the page and keeps re-running.
+     */
+    dispose: () => void;
+}
+/** Per-run context handed to the factory. */
+interface AsyncDerivedContext {
+    /**
+     * Aborted when a newer run supersedes this one, or when the derivation is
+     * disposed. Forward it to `fetch` (or any abortable API) to cancel work that
+     * can no longer affect the result.
+     */
+    signal: AbortSignal;
 }
 /**
  * `asyncDerived` is the async counterpart of `derived`: it takes a factory
@@ -1116,7 +1295,35 @@ interface AsyncDerivedState<T> {
  *
  * Stale responses are dropped: if a new run starts before an older one
  * resolves, the older one's result is ignored. This prevents flicker when
- * dependencies change rapidly (e.g. typing in a search box).
+ * dependencies change rapidly (e.g. typing in a search box). The superseded
+ * run's `AbortSignal` is also aborted, so abortable work (e.g. `fetch`) is
+ * cancelled rather than merely ignored. The run-id guard is retained
+ * regardless, because not every async API honours `AbortSignal` — aborting
+ * alone does not close the stale-completion race.
+ *
+ * ## Dependency tracking and `await`
+ *
+ * Reactive reads are tracked **synchronously**, so only the reads that happen
+ * BEFORE the factory's first `await` become dependencies:
+ *
+ * ```ts
+ * asyncDerived(async () => {
+ *   const a = sourceA();      // tracked — runs synchronously
+ *   await something();
+ *   const b = sourceB();      // NOT tracked — the tracking context is gone
+ * });
+ * ```
+ *
+ * This is a property of synchronous tracking, not a bug: SibuJS does not
+ * install async-context machinery to follow reads across suspension points.
+ * Read every dependency up front (before the first `await`) if the derivation
+ * must react to it, or call `refresh()` explicitly.
+ *
+ * ## Ownership
+ *
+ * `asyncDerived` subscribes to its sources until `dispose()` is called. It is
+ * not attached to an enclosing scope automatically — dispose it from the
+ * owning component's cleanup.
  *
  * Unlike `query()` or `resource()`, `asyncDerived` has no caching or retry
  * logic — it's a minimal async-reactivity primitive suited for ad-hoc
@@ -1136,7 +1343,7 @@ interface AsyncDerivedState<T> {
  * }, []);
  * ```
  */
-declare function asyncDerived<T>(factory: () => Promise<T>, initial: T): AsyncDerivedState<T>;
+declare function asyncDerived<T>(factory: (context: AsyncDerivedContext) => Promise<T>, initial: T): AsyncDerivedState<T>;
 
 /**
  * Deep equality comparison for objects and arrays.
@@ -1179,13 +1386,23 @@ declare function deepSignal<T>(initial: T): [Accessor<T>, (next: T | ((prev: T)
  *   derived-of-derived chains propagate correctly without paying the full
  *   Set-delete + re-add cost of track()'s cleanup phase.
  *
- * NOTE: a previous revision experimented with three-color (CLEAN/CHECK/DIRTY)
- * state for read-side value-change short-circuiting. It regressed every
- * benchmark except Memory (Deep Chain +122%, Component Tree +20%) because
- * the workloads always produce a new downstream value and CHECK had no
- * work to skip — only overhead to add. Keeping the simpler boolean flag
- * here; revisit CHECK propagation when we have benchmarks that exercise
- * stabilisation on diamond / conditional-branch patterns.
+ * STABILIZATION — why a dirty flag is enough:
+ *
+ * A dirty computed does NOT imply a changed value. Downstream effects are
+ * enqueued by `propagateDirty` at write time, before this computed has had a
+ * chance to recompute and compare. Rather than adding a three-color
+ * (CLEAN/CHECK/DIRTY) propagation pass — which an earlier revision measured as
+ * a regression on every benchmark, because the extra state has nothing to skip
+ * when values genuinely change — the engine settles the question lazily at
+ * DRAIN time: `cs._validate` recomputes a dirty computed and `cs.__v` is bumped
+ * ONLY when the new value differs under this computed's comparator. The
+ * scheduler compares that version against what each subscriber last observed
+ * and suppresses the run when nothing changed (see `depsChanged` in
+ * ../../reactivity/track-core.ts).
+ *
+ * That keeps the cheap boolean dirty flag AND makes `equals` actually stop
+ * propagation, with recomputation still fully lazy: `_validate` only ever runs
+ * when an effect is genuinely about to observe the value.
  */
 declare function derived<T>(getter: () => T, options?: {
     name?: string;
@@ -1373,10 +1590,6 @@ declare function writable<T>(get: () => T, set: (value: T) => void, options?: {
  *   withSSR(() => renderToString(...));
  *   runInSSRContext(() => renderToString(...));
  */
-/**
- * Per-request SSR store. Currently holds the SSR flag plus a
- * suspense-id counter so concurrent streaming renders never collide.
- */
 interface SSRStore {
     ssr: boolean;
     suspenseIdCounter: number;
@@ -1386,6 +1599,17 @@ interface SSRStore {
      * server renders. Typed loosely to avoid a dependency cycle with data/.
      */
     caches?: Map<string, Map<string, unknown>>;
+    /**
+     * The locale this request has selected, or `undefined` when it has not
+     * chosen one and should follow the application default.
+     *
+     * A plain string rather than a signal: reactive locale switching is a client
+     * concern (one page, one active locale, subscribers to notify), while a
+     * server render reads the value once per request and never re-renders. Giving
+     * every request its own signal would allocate subscriber machinery nothing
+     * will ever use. See `plugins/i18n.ts`.
+     */
+    locale?: string;
 }
 /** Returns the active store (ALS or fallback). */
 declare function getSSRStore(): SSRStore;
@@ -1503,9 +1727,26 @@ type EnhanceSetup = (ctx: EnhanceContext) => void | (() => void);
  * replacing it. Returns a dispose function; disposal is also wired to the
  * element, so removing its subtree cleans everything up.
  *
+ * **Setup is a transaction.** If `setup` throws, every binding, listener and
+ * cleanup it registered through the {@link EnhanceContext} is torn down and the
+ * original error is rethrown unchanged — the element is left exactly as
+ * unenhanced as it started, so a retry is legal. The rollback covers
+ * framework-owned resources only (`ctx.on`, `ctx.text`, `ctx.attr`,
+ * `ctx.classed`, `ctx.show`, `ctx.model`, `ctx.cleanup`, and a cleanup returned
+ * from setup); work the setup performed outside those helpers — `innerHTML`
+ * writes, network calls, global mutation — cannot be reversed generically, so
+ * register its undo with `ctx.cleanup()` as you go.
+ *
+ * **Ownership.** A successfully enhanced root is marked
+ * `data-sibu-enhanced="true"`; disposal removes it. The marker tracks *current*
+ * ownership rather than history, so a **disposed root can be enhanced again**,
+ * while enhancing a root that is still active is refused (dev-warns) to prevent
+ * two competing sets of bindings. See `docs/architecture/enhancement-lifecycle.md`.
+ *
  * @param target An `Element` or a CSS selector resolved against `document`
  *   (the first match is used; see {@link enhanceAll} for many).
  * @param setup  Wires reactivity via the {@link EnhanceContext}.
+ * @throws Whatever `setup` throws, after rolling its resources back.
  *
  * @example
  * ```ts
@@ -1521,6 +1762,19 @@ declare function enhance(target: Element | string, setup: EnhanceSetup): () => v
 /**
  * Enhance every element matching a selector. Returns a single dispose that
  * tears down all of them.
+ *
+ * The whole collection is one transaction: if any element's setup throws, the
+ * elements already enhanced are rolled back (newest first, mirroring stack
+ * unwinding) and the original error is rethrown. A caller that never received
+ * the aggregate disposer is therefore never left holding live enhancements it
+ * has no way to release. A teardown that fails during that rollback is reported
+ * and skipped — it neither aborts the remaining rollback nor replaces the
+ * original setup error.
+ *
+ * The returned disposer is idempotent, and the collection may be enhanced again
+ * afterwards (see {@link enhance} on marker lifetime).
+ *
+ * @throws Whatever the failing element's setup threw, after rolling back.
  */
 declare function enhanceAll(selector: string, setup: EnhanceSetup): () => void;
 
@@ -1575,6 +1829,23 @@ interface MountIslandsOptions {
  *   - `visible`     — when the element scrolls into view (IntersectionObserver).
  *   - `interaction` — on first pointer/focus/key/touch interaction.
  *   - `media`       — when `data-sibu-media` (a media query) matches.
+ *
+ * **Error isolation is lifecycle isolation.** Each island is one `enhance()`
+ * transaction, so an island whose setup throws is reported and leaves zero live
+ * bindings and zero live listeners; siblings activate normally, and the failed
+ * island can be mounted again once its setup is fixed.
+ *
+ * **Remounting is supported.** Cleanup disposes each island and releases its
+ * `data-sibu-enhanced` marker, so the same server markup can be mounted again
+ * with a fresh generation. Mounting twice *without* cleanup is also safe:
+ * islands that currently own an enhancement are skipped, never double-wired.
+ *
+ * Activation can never outlive its owner. Cleanup landing before a lazy chunk
+ * resolves prevents activation entirely, and cleanup landing *during* a setup
+ * disposes the island rather than stranding it — DISPOSED never becomes ACTIVE.
+ * `data-sibu-hydrated` is hydration provenance rather than ownership, and is
+ * therefore not cleared on disposal; see
+ * `docs/architecture/enhancement-lifecycle.md`.
  */
 declare function mountIslands(root?: ParentNode | null, options?: MountIslandsOptions): () => void;
 
@@ -1710,7 +1981,7 @@ declare function isTrackingSuspended(): boolean;
 declare function untracked$1<T>(fn: () => T): T;
 declare function retrack$1(effectFn: () => void, subscriber: Subscriber): void;
 declare function track(effectFn: () => void, subscriber?: Subscriber): () => void;
-declare function reactiveBinding(commit: () => void): () => void;
+declare function reactiveBinding(commit: () => void, ownerNode?: unknown): () => void;
 declare function recordDependency(signal: ReactiveSignal): void;
 declare function cleanup(subscriber: Subscriber): void;
 declare function setMaxSubscriberRepeats(n: number): number;
@@ -1750,4 +2021,4 @@ declare const untracked: ReactiveApi["untracked"];
 declare const retrack: ReactiveApi["retrack"];
 declare const setMaxDrainIterations: ReactiveApi["setMaxDrainIterations"];
 
-export { type Accessor, type ActionFn, type AnchorProps, type ArrayActions, type AsyncDerivedState, type AudioProps, type ButtonProps, type Context, DynamicComponent, type EffectBody, type EffectOptions, type EnhanceContext, type EnhanceSetup, ErrorBoundary, type ErrorBoundaryOptions, type ErrorBoundaryProps, ErrorDisplay, type ErrorDisplayProps, type ErrorSeverity, type FormProps, Fragment, type ImgProps, type InputProps, type InputType, type IslandLoader, type IslandRegistration, type IslandStrategy, KeepAlive, type KeepAliveOptions, type LabelProps, Loading, type LoadingProps, type LongPressOptions, type MediaProps, type MountIslandsOptions, NodeChild, NodeChildren, type OnCleanup, type OptionProps, Portal, type Ref, type SSRStore, type SelectProps, type SignalOptions, type SlotFn, type Slots, type StoreActions, Suspense, type SuspenseProps, TagProps, type TextareaProps, type TypedTagFunction, type VideoProps, __resetIdCounter, a, abbr, action, address, area, array, article, aside, asyncDerived, audio, autoResize, b, base, batch, bdi, bdo, bindDynamic, blockquote, body, br, button, canvas, caption, catchError, catchErrorAsync, center, checkLeaks, circle, cite, clickOutside, clipPath, code, col, colgroup, context, copyOnClick, createId, customElement, data, datalist, dd, deepEqual, deepSignal, defer, defs, del, derived, details, dfn, dialog, disableSSR, dispose, div, dl, dt, each, effect, ellipse, em, embed, enableSSR, enhance, enhanceAll, enqueueBatchedSignal, fieldset, figcaption, figure, font, footer, form, g, getAction, getRequestScopedCache, getSSRStore, getSlot, h1, h2, h3, h4, h5, h6, head, header, hr, html, i, iframe, img, input, ins, isBatching, isSSR, kbd, label, lazy, lazyIsland, legend, li, line, linearGradient, link, longPress, main, map, mark, marker, marquee, mask, match, math, menu, meta, meter, mount, mountIslands, nav, nextTick, noscript, object, ol, on, onCleanup, onMount, onUnmount, optgroup, option, output, p, param, path, pattern, picture, polygon, polyline, portal, pre, progress, q, radialGradient, reactiveArray, rect, ref, registerAction, registerComponent, registerDisposer, registerIsland, resolveComponent, retrack, rp, rt, ruby, runInSSRContext, s, samp, script, section, select, setGlobalErrorHandler, setMaxDrainIterations, show, signal, slot, small, source, span, stop, store, strict, strictEffect, strong, style, sub, summary, sup, svg, symbol, table, takePendingError, tbody, td, template, text, textarea, tfoot, th, thead, time, title, tr, track$1 as track, transition, trapFocus, tspan, u, ul, unregisterComponent, unregisterIsland, untracked, use, var_, video, watch, when, withSSR, writable };
+export { type Accessor, type ActionFn, type AnchorProps, type ArrayActions, type AsyncDerivedContext, type AsyncDerivedState, type AudioProps, type ButtonProps, type Context, DynamicComponent, type EffectBody, type EffectOptions, type EnhanceContext, type EnhanceSetup, ErrorBoundary, type ErrorBoundaryOptions, type ErrorBoundaryProps, ErrorDisplay, type ErrorDisplayProps, type ErrorSeverity, type FormProps, Fragment, type ImgProps, type InputProps, type InputType, type IslandLoader, type IslandRegistration, type IslandStrategy, KeepAlive, type KeepAliveOptions, type LabelProps, Loading, type LoadingProps, type LongPressOptions, MAX_DRAIN_TEARDOWNS, type MediaProps, type MountIslandsOptions, NodeChild, NodeChildren, type OnCleanup, type OptionProps, Portal, type Ref, type RuntimeErrorContext, type RuntimeErrorHandler, type RuntimeErrorPhase, type SSRStore, type SelectProps, type SignalOptions, type SlotFn, type Slots, type StoreActions, Suspense, type SuspenseProps, TagProps, type TextareaProps, type TypedTagFunction, type VideoProps, __resetIdCounter, a, abbr, action, address, area, array, article, aside, asyncDerived, audio, autoResize, b, base, batch, bdi, bdo, bindDynamic, blockquote, body, br, button, canvas, caption, catchError, catchErrorAsync, center, checkLeaks, circle, cite, clickOutside, clipPath, code, col, colgroup, context, copyOnClick, createId, customElement, data, datalist, dd, deepEqual, deepSignal, defer, defs, del, derived, details, dfn, dialog, disableSSR, dispose, div, dl, dt, each, effect, ellipse, em, embed, enableSSR, enhance, enhanceAll, enqueueBatchedSignal, fieldset, figcaption, figure, font, footer, form, g, getAction, getRequestScopedCache, getRuntimeErrorHandler, getSSRStore, getSlot, h1, h2, h3, h4, h5, h6, head, header, hr, html, i, iframe, img, input, ins, isBatching, isSSR, kbd, label, lazy, lazyIsland, legend, li, line, linearGradient, link, longPress, main, map, mark, marker, marquee, mask, match, math, menu, meta, meter, mount, mountIslands, nav, nextTick, noscript, object, ol, on, onCleanup, onMount, onUnmount, optgroup, option, output, p, param, path, pattern, picture, polygon, polyline, portal, pre, progress, q, radialGradient, reactiveArray, rect, ref, registerAction, registerComponent, registerDisposer, registerIsland, replaceChildrenSafely, reportDrainRunaway, reportError, resolveComponent, retrack, rp, rt, ruby, runInSSRContext, s, samp, script, section, select, setGlobalErrorHandler, setMaxDrainIterations, setRuntimeErrorHandler, show, signal, slot, small, source, span, stop, store, strict, strictEffect, strong, style, sub, summary, sup, svg, symbol, table, takePendingError, tbody, td, template, text, textarea, tfoot, th, thead, time, title, tr, track$1 as track, transition, trapFocus, tspan, u, ul, unregisterComponent, unregisterDisposer, unregisterIsland, untracked, use, var_, video, watch, when, withSSR, writable };