sibujs 4.14.0 → 4.15.0

package/dist/index.d.cts

@@ -1,9 +1,10 @@
 import { a as NodeChild, C as Component, N as NodeChildren } from './types-CJFViL6Q.cjs';
 export { D as Dispose } from './types-CJFViL6Q.cjs';
-import { T as TagProps, a as TagFunction, D as DerivedAccessor } from './tagFactory-DkytnJws.cjs';
-export { S as SVG_NS, b as StyleMap, c as StyleObject, d as TagEventHandlers, e as derived, t as tagFactory } from './tagFactory-DkytnJws.cjs';
 import { A as Accessor } from './signal-EotCj4hS.cjs';
 export { D as DisposableAccessor, E as ExternalSource, S as SignalOptions, e as external, s as signal } from './signal-EotCj4hS.cjs';
+import { T as TagProps, a as TagFunction, D as DerivedAccessor } from './tagFactory-BfEh69VF.cjs';
+export { S as SVG_NS, b as StyleMap, c as StyleObject, d as TagEventHandlers, e as derived, t as tagFactory } from './tagFactory-BfEh69VF.cjs';
+import { s as suspendTracking, r as resumeTracking, i as isTrackingSuspended, u as untracked$1, a as retrack$1, t as track$1, b as reactiveBinding, c as recordDependency, d as cleanup, e as setMaxSubscriberRepeats, f as setMaxDrainIterations$1, g as drainNotificationQueue, q as queueSignalNotification, n as notifySubscribers, h as getSubscriberCount, j as getSubscriberDeps, k as forEachSubscriber, l as getOwnerScope, m as runWithOwnerScope, o as bindOwnerScope, p as structuralBinding, v as captureFrozen, w as holdSubtree, H as HeldCheck } from './track-core-DN5fYLWi.cjs';
 export { V as EachBindings, W as EachEventBindings, X as EnhanceContext, Y as EnhanceSetup, Z as IslandLoader, _ as IslandRegistration, $ as IslandStrategy, a0 as LazyIslandLoader, a1 as MountIslandsOptions, T as TrustedHTML, a2 as enhance, a3 as enhanceAll, a4 as lazyIsland, a5 as mountIslands, a6 as registerIsland, u as trustHTML, a7 as unregisterIsland } from './ssr-JpGpHnpC.cjs';
 import { R as ReactiveSignal } from './signal-BnWpq6WB.cjs';
 
@@ -476,6 +477,92 @@ declare function createId(prefix?: string): string;
  */
 declare function __resetIdCounter(): void;
 
+/**
+ * Animate the branches of a `when()` / `match()`. See `DirectiveOptions.transition`.
+ *
+ * `enterClass` and `leaveClass` are the option names (and types) of
+ * `transition()` in `sibujs/motion`.
+ */
+interface DirectiveTransition {
+    /** Class added to the branch's elements when it is inserted, removed when its animation / transition ends. */
+    enterClass?: string;
+    /** Class added to the outgoing branch's elements; the branch is removed when their animation / transition ends. */
+    leaveClass?: string;
+    /**
+     * How a branch switch is sequenced:
+     * - `"both"` (default): the new branch is inserted (and enters) immediately,
+     *   while the old one leaves alongside it.
+     * - `"out-in"`: the new branch is built and inserted only once every
+     *   outgoing branch has finished leaving.
+     * - `"in-out"`: the new branch is inserted and enters first; the old one
+     *   starts leaving when the enter has finished.
+     */
+    mode?: "both" | "out-in" | "in-out";
+    /**
+     * Custom JS leave (Web Animations, a library). Receives the branch's
+     * top-level nodes; the branch is removed when the returned promise settles,
+     * or right away when it returns nothing. Takes precedence over `leaveClass`.
+     */
+    leave?: (nodes: Node[]) => Promise<void> | void;
+    /** Custom JS enter; see `leave`. Takes precedence over `enterClass`. */
+    enter?: (nodes: Node[]) => Promise<void> | void;
+    /**
+     * Safety cap for one enter or leave, in ms. By default a phase waits for its
+     * end events, or for the longest computed animation / transition (delay +
+     * duration x iteration count) + 50 ms. Never more than 5000 ms.
+     */
+    maxDuration?: number;
+    /** Also play the enter on the directive's first render. Default `false`. */
+    appear?: boolean;
+    /**
+     * Opt-in, in ms: let content that arrives later enter WITH the branch, if
+     * it is committed within this time, counted from the switch and never more
+     * than 5000 ms. Default: not waited for. The content waited for is the
+     * PENDING content inside the entering branch, wherever it sits: the initial
+     * content (or error view) of every `Suspense` boundary (the router's and
+     * the core one), `lazy()` component and route outlet (`Route`, `Outlet`,
+     * `KeepAliveRoute`), and what the application registers with
+     * `pendingContent()`. An outlet is pending until its CURRENT navigation
+     * commits a page, an error view or nothing at all — a superseded pass, or
+     * one waiting for its anchor to be attached, settles nothing.
+     *
+     * - A class-based enter starts at once and stays open for that content
+     *   until it has settled or the time is up: each piece joins the enter when
+     *   it is committed, and the enter ends when the animations do, within the
+     *   enter's own `maxDuration` / 5 s cap. Content that reveals more pending
+     *   content (an outer boundary whose result holds an inner one, a layout
+     *   holding an outlet) keeps the enter open for that too.
+     * - A custom `enter` is called once the content has settled — the content
+     *   it revealed included — or when the time is up, with the nodes present
+     *   then.
+     * - What is pending is taken from the branch as it is: again whenever a
+     *   registration begins or settles, and whenever a node moves into or out
+     *   of the branch while the enter waits. Content joins only if it is inside
+     *   the branch when it settles, and only if it was committed — a cancelled
+     *   registration (or one dropped with its location) enrolls nothing.
+     * - Nothing moves the deadline; it ends when its own timer fires, whatever
+     *   the wall clock does. Content committed after it, or after the enter
+     *   ended, appears without an enter: an enter never replays, and nothing is
+     *   loaded again for it. An enclosing branch that is paused when it ends
+     *   still holds a custom `enter` until it resumes.
+     *
+     * What joins a class-based enter, automatically: elements a top-level range
+     * of the branch (an `each()`, a nested directive) adds while it runs —
+     * whatever this setting — and the content committed for a pending
+     * registration. Either is skipped when it lies inside an element of the
+     * enter whose own animation is still running: it already moves with that
+     * element, and a second copy of the animation would compound (twice the
+     * offset, the opacity squared). Once that animation has finished, content
+     * arriving inside it enters on its own. A nested directive's own
+     * `transition` is never affected.
+     *
+     * With `mode: "in-out"` the outgoing branch starts leaving when this enter
+     * ends, so it waits as long. The first render takes part only with
+     * `appear: true`.
+     */
+    waitForContent?: number;
+}
+
 /**
  * What a rebuild does with focus it discarded. Set per directive through the
  * `focus` option of `when()` / `match()`.
@@ -531,7 +618,127 @@ interface DirectiveOptions {
      * `<body>` when the rebuilt branch has no counterpart.
      */
     focus?: FocusPolicy;
+    /**
+     * Animate branch changes. Without it (the default) the outgoing branch is
+     * removed and disposed at the moment of the switch.
+     *
+     * ```ts
+     * when(() => step() === "done", () => Done(), () => Generating(), {
+     *   transition: { enterClass: "fade-in", leaveClass: "fade-out" },
+     * });
+     * ```
+     *
+     * With a transition, at the switch the outgoing branch:
+     * - is FROZEN: its reactive bindings and effects stop, so it keeps showing
+     *   its last state instead of reacting to state the new branch now owns;
+     * - gets `inert` and `aria-hidden="true"`, so it cannot be clicked or
+     *   focused while it fades (focus inside it follows the `focus` policy, as
+     *   on any rebuild);
+     * - plays its leave (`leaveClass`, or a custom `leave`) where it is in the
+     *   DOM, and is removed and disposed when that ends: once every animation
+     *   and transition its elements actually started has finished (read with
+     *   `getAnimations()`; end events where it is missing), when the custom
+     *   `leave` promise settles, or at a timeout computed from its styles,
+     *   capped by `maxDuration` and never more than 5 s. Zero durations (no animation, a
+     *   reduced-motion stylesheet, `display: none`) remove it synchronously.
+     *
+     * Its `onUnmount` callbacks and `registerDisposer` teardowns run when it is
+     * actually removed, so a component can keep a canvas or a
+     * `requestAnimationFrame` loop running until it has faded out.
+     *
+     * Switching again while a branch is leaving does not interrupt it; several
+     * branches may be leaving at once. Switching back to a bare element (or
+     * fragment) branch that is still leaving cancels its leave and re-attaches
+     * it. The first render plays no enter unless `appear: true`. An enter waits
+     * for the first render of a top-level `each()` or nested directive (a few
+     * microtask turns at most), so those rows enter with the branch; rows such a
+     * range adds while a class-based enter runs join it, and rows it adds while
+     * the branch leaves join the leave. Content that arrives later (a
+     * `Suspense` boundary, a route outlet, a `pendingContent()` registration)
+     * is not waited for unless `waitForContent` says how long to wait.
+     * Disposing the directive removes leaving branches at once. Server renders
+     * ignore transitions entirely.
+     *
+     * A branch the directive built has its own lifecycle either way (see
+     * `lifecycleScope`): without a transition it ends at the switch, with one it
+     * pauses for the leave and ends when the branch is released.
+     */
+    transition?: DirectiveTransition;
 }
+/**
+ * Conditional rendering directive. Renders content only when condition is true.
+ * When false, renders nothing (comment placeholder). Re-evaluates reactively.
+ *
+ * Each branch may be a THUNK (rebuilt on every condition change) or a bare
+ * element/value (attached as-is, and re-attached unchanged on every later
+ * change). Both shapes are accepted so that `when` and {@link show} take the
+ * same arguments; a bare element used to be accepted and then silently render
+ * nothing, because the directive called it as a function only.
+ *
+ * A branch may be SEVERAL sibling nodes: return a `Fragment([...])` (or any
+ * `DocumentFragment`). No wrapper element is needed, and on every switch all of
+ * its nodes — including what its reactive children, an `each()` or a nested
+ * `when` / `match` at its top level render now — are removed and disposed
+ * together. Cleanup registered on the fragment itself runs then too.
+ *
+ * The branch is rebuilt whenever the condition's VALUE changes (`Object.is`),
+ * not only when its truthiness flips, so
+ * `when(() => selectedUser(), () => UserCard(selectedUser()!))` rebuilds the
+ * card for each different user. To rebuild only when truthiness flips, return
+ * a boolean: `when(() => !!x(), …)`. For rebuilds keyed on something other
+ * than the value itself (an id, a mode), use {@link match}.
+ *
+ * @param condition Reactive getter; its value is compared to decide the branch
+ * @param thenBranch Element, value, fragment, or function returning one, used when truthy
+ * @param elseBranch Optional counterpart used when falsy. May be omitted in
+ * favour of `options` (`when(cond, then, { focus: "discard" })`).
+ * @param options Optional {@link DirectiveOptions}: focus policy and transitions
+ * @returns A Comment anchor that manages the conditional content
+ *
+ * @example
+ * ```ts
+ * when(
+ *   () => isLoggedIn(),
+ *   () => div("Welcome!"),
+ *   () => div("Please log in")
+ * );
+ * when(() => isLoggedIn(), div("Welcome!"));   // also valid
+ *
+ * // Two sibling buttons, no wrapper element:
+ * when(() => confirming(), () => Fragment([button("Yes"), button("No")]));
+ *
+ * // Fade the outgoing branch out before it is removed:
+ * when(() => ready(), () => Result(), () => Spinner(), {
+ *   transition: { leaveClass: "fade-out" },
+ * });
+ * ```
+ *
+ * GOTCHA — branch factories rebuild only when `condition` changes. A branch
+ * factory runs untracked, so a signal read *eagerly* inside it is captured once
+ * and never updates:
+ * ```ts
+ * when(() => show(), () => div(`Count: ${count()}`));        // ✗ frozen at first count
+ * when(() => show(), () => div(() => `Count: ${count()}`));  // ✓ reactive text child
+ * ```
+ * Drive per-branch reactivity with a nested getter (or a reactive child), not a
+ * bare read in the factory body.
+ *
+ * TRAP — a rebuild DESTROYS the outgoing branch, so focus, selection and any
+ * in-progress IME composition inside it are lost. The runtime restores focus
+ * when the rebuilt branch contains an element with the same `id`, `name`, or
+ * `data-focus-key`, and warns in dev when it cannot. For a subtree holding a
+ * live edit, prefer {@link match} keyed on a shape key so the subtree is
+ * rebuilt only when the shape genuinely changes. When dropping focus is the
+ * point (Escape closes a panel), say so with `{ focus: "discard" }`, or route
+ * it with `{ focus: { restoreTo: triggerEl } }`.
+ *
+ * A branch switch disposes the outgoing branch BEFORE any binding inside it can
+ * re-run in the same flush, so a binding that is only valid while its branch is
+ * mounted (`() => selected()!.name` under `when(() => selected(), …)`) never
+ * observes the state that removed it. With a `transition`, the outgoing branch
+ * is frozen at that same point instead, and disposed when its leave ends — see
+ * {@link DirectiveOptions.transition}.
+ */
 declare function when<T>(condition: () => T, thenBranch: NodeChild, elseBranch?: NodeChild | DirectiveOptions, options?: DirectiveOptions): Comment;
 /**
  * Pattern matching directive. Renders content based on matching a reactive value
@@ -541,7 +748,8 @@ declare function when<T>(condition: () => T, thenBranch: NodeChild, elseBranch?:
  * @param cases Object mapping values to render functions
  * @param fallback Optional default case if no match found. May be omitted in
  * favour of `options`.
- * @param options Optional {@link DirectiveOptions} (`focus` policy, as in `when`)
+ * @param options Optional {@link DirectiveOptions} (`focus` policy and
+ * `transition`, as in `when`)
  * @returns A Comment anchor that manages the matched content
  *
  * @example
@@ -576,7 +784,17 @@ declare function when<T>(condition: () => T, thenBranch: NodeChild, elseBranch?:
  *
  * Cases and the fallback accept a bare element as well as a factory, matching
  * {@link when} and {@link show}. A bare element is re-attached rather than
- * rebuilt, so it keeps whatever state it accumulated.
+ * rebuilt, so it keeps whatever state it accumulated. A case may return a
+ * `Fragment([...])` to render several sibling nodes, and `transition` animates
+ * case changes exactly as in `when`:
+ *
+ * ```ts
+ * match(() => screen(), {
+ *   attract: () => Attract(),
+ *   draw: () => Fragment([Canvas(), Toolbar()]),
+ *   done: () => Done(),
+ * }, { transition: { enterClass: "screen-in", leaveClass: "screen-out", mode: "out-in" } });
+ * ```
  */
 declare function match<T extends string | number>(value: () => T, cases: Record<string, NodeChild>, fallback?: NodeChild | DirectiveOptions, options?: DirectiveOptions): Comment;
 
@@ -713,6 +931,31 @@ declare function resolveComponent<El extends Element = HTMLElement>(name: string
  */
 declare function DynamicComponent(is: () => string | Component): HTMLDivElement;
 
+/**
+ * The item getter `each()` passes to `render`: a reactive accessor for the
+ * row's CURRENT item, plus `peek()`.
+ *
+ * Calling it inside a binding (`() => item().name`) or an effect subscribes to
+ * the row, so the binding re-runs when reconciliation assigns the row's key a
+ * replacement item. Calling it directly in the body of `render` is a one-time
+ * read: `render` runs once per key, untracked, so what it read goes stale when
+ * the item behind the key is replaced (and dev builds warn when that happens).
+ */
+type EachItem<T> = Accessor<T> & {
+    /**
+     * Read the current item WITHOUT subscribing and without the dev staleness
+     * warning: the explicit form of an intentional one-time read in `render`
+     * (an initial value, an id that is part of the key). `untracked(() => item())`
+     * does not serve here: `render` is already untracked, so that read is still
+     * reported as one that may go stale.
+     */
+    peek(): T;
+};
+/** The index getter `each()` passes to `render`; see {@link EachItem}. */
+type EachIndex = Accessor<number> & {
+    /** Read the current index without subscribing and without the dev staleness warning. */
+    peek(): number;
+};
 /**
  * Renders a list of nodes efficiently with key-based diffing and
  * LIS-based move minimization.
@@ -746,6 +989,21 @@ declare function DynamicComponent(is: () => string | Component): HTMLDivElement;
  * down (`Row({ item, index })`) or read them inside bindings
  * (`() => item().name`) and effects created by the row.
  *
+ * ```ts
+ * each(products, (p) => img({ src: p().url }), { key: (p) => p.name });        // ✗ src frozen per key
+ * each(products, (p) => img({ src: () => p().url }), { key: (p) => p.name });  // ✓ follows the item
+ * each(products, (p) => Row({ id: p.peek().id }), { key: (p) => p.id });       // ✓ deliberate one-time read
+ * ```
+ *
+ * In development, a row whose `render` read `item()` (or `index()`) directly
+ * warns once per call site when that read actually goes stale: when its key is
+ * handed a different item (`!Object.is`), or the row moves. A list whose items
+ * are never replaced never warns. `item.peek()` / `index.peek()` read the
+ * current value without subscribing and are never reported; use them to mark a
+ * one-time read as intentional. (`untracked(() => item())` is not an
+ * alternative here: `render` is already untracked.) The check and its message
+ * are compiled out of production builds.
+ *
  * A binding that reads `item()` subscribes to the ROW's cell, not to the
  * whole-array signal. `render` never re-runs for an existing key; only the
  * bindings and effects that read that row's `item()` / `index()` re-run, and
@@ -753,11 +1011,11 @@ declare function DynamicComponent(is: () => string | Component): HTMLDivElement;
  * 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.
+ * @param render Receives the row's reactive item and index getters ({@link EachItem}, {@link EachIndex}) and returns a NodeChild. Runs once per key.
  * @param options A key function for unique identity of items.
  * @returns A Comment node serving as the anchor for the list.
  */
-declare function each<T>(getArray: () => T[], render: (item: () => T, index: () => number) => NodeChild, options: {
+declare function each<T>(getArray: () => T[], render: (item: EachItem<T>, index: EachIndex) => NodeChild, options: {
     key: (item: T) => string | number;
 }): Comment;
 
@@ -770,6 +1028,12 @@ declare function each<T>(getArray: () => T[], render: (item: () => T, index: ()
  * change. The binding is owned by that placeholder, so disposing the parent the
  * fragment was appended to (or unmounting a mounted fragment) stops it.
  *
+ * A fragment is a valid `when()` / `match()` branch: the directive records the
+ * fragment's nodes before inserting it (insertion empties a DocumentFragment)
+ * and removes and disposes all of them on the next switch, including whatever
+ * its reactive children have rendered since. Several sibling nodes need no
+ * wrapper element (and no `display: contents` span).
+ *
  * @example
  * ```ts
  * div([
@@ -778,6 +1042,8 @@ declare function each<T>(getArray: () => T[], render: (item: () => T, index: ()
  *     () => `Count: ${count()}`,
  *   ])
  * ]);
+ *
+ * when(() => editing(), () => Fragment([button("Save"), button("Cancel")]));
  * ```
  *
  * @param nodes Array of child nodes to include in the fragment
@@ -1006,7 +1272,7 @@ declare const area: TagFunction<HTMLAreaElement, TagProps<HTMLAreaElement>>;
 declare const audio: TypedTagFunction<AudioProps, HTMLAudioElement>;
 declare const img: TypedTagFunction<ImgProps, HTMLImageElement>;
 declare const map: TagFunction<HTMLMapElement, TagProps<HTMLMapElement>>;
-declare const track$1: TagFunction<HTMLTrackElement, TagProps<HTMLTrackElement>>;
+declare const track: TagFunction<HTMLTrackElement, TagProps<HTMLTrackElement>>;
 declare const video: TypedTagFunction<VideoProps, HTMLVideoElement>;
 declare const embed: TagFunction<HTMLEmbedElement, TagProps<HTMLEmbedElement>>;
 declare const iframe: TagFunction<HTMLIFrameElement, TagProps<HTMLIFrameElement>>;
@@ -1157,7 +1423,30 @@ declare function takePendingError(node: Element): Error | undefined;
  *
  * The returned component renders either the loading container (a `div`) or,
  * once loaded, the component's own root — its return type is the union, so an
- * SVG component stays usable without a cast.
+ * SVG component stays usable without a cast. A component returning a
+ * `DocumentFragment` is rendered in the container either way: a fragment is
+ * no root its instance could be disposed with. Cleanup registered on the
+ * fragment itself still runs, once, when the instance is disposed — after its
+ * children's.
+ *
+ * The loaded component belongs to the lifecycle the placeholder was rendered
+ * in (a `when()` branch, a route instance, a `Suspense`'s content): while that
+ * lifecycle is paused — a branch playing its leave, a
+ * `KeepAliveRoute({ suspendInactive: true })` page that is hidden — the module
+ * is kept and nothing is built or committed until it resumes; if it ends,
+ * nothing is. The loaded module is cached either way.
+ *
+ * Every instance has the same lifetime, whether its module was loaded already
+ * or not: the component is built under its own lifecycle, nested in the one
+ * it renders in. A `lifecycleScope()` it captures pauses with that one, and
+ * ends — its scoped effects and watches disposed — when the instance is
+ * disposed: the container, or the component's own root when a cached module
+ * renders it directly.
+ *
+ * A synchronous throw from `importFn` propagates to the caller; nothing is
+ * left registered for the container that was never returned. So does a throw
+ * from a cached component, rendered synchronously: what it registered is
+ * rolled back and its lifecycle ended.
  *
  * @param importFn Dynamic import function returning `{ default: Component }`
  * @returns A component function that lazy-loads on first call
@@ -1190,6 +1479,15 @@ interface SuspenseProps {
  * Render `fallback` until the async `nodes` factory resolves, then swap it for
  * the resolved content.
  *
+ * `fallback()` and `nodes()` each run under their own lifecycle, nested in the
+ * one the boundary renders in: a `lifecycleScope()` captured in the fallback
+ * ends — its scoped effects and watches disposed — when the content replaces
+ * the fallback, or with the boundary; one captured in the content ends with
+ * the boundary — or as soon as the content is abandoned: `nodes()` threw, or
+ * the content it built could not be inserted (the boundary and its fallback
+ * stay). A throwing `fallback()` propagates, with what it registered rolled
+ * back.
+ *
  * @param props `nodes` is the async content factory; `fallback` builds the
  * placeholder shown while it is pending.
  * @returns The live container element, already holding the fallback.
@@ -1300,6 +1598,327 @@ declare function mount(component: Component<void, Node> | Node, container: Eleme
     unmount: () => void;
 };
 
+interface ReactiveApi {
+    suspendTracking: typeof suspendTracking;
+    resumeTracking: typeof resumeTracking;
+    isTrackingSuspended: typeof isTrackingSuspended;
+    untracked: typeof untracked$1;
+    retrack: typeof retrack$1;
+    track: typeof track$1;
+    reactiveBinding: typeof reactiveBinding;
+    recordDependency: typeof recordDependency;
+    cleanup: typeof cleanup;
+    setMaxSubscriberRepeats: typeof setMaxSubscriberRepeats;
+    setMaxDrainIterations: typeof setMaxDrainIterations$1;
+    drainNotificationQueue: typeof drainNotificationQueue;
+    queueSignalNotification: typeof queueSignalNotification;
+    notifySubscribers: typeof notifySubscribers;
+    getSubscriberCount: typeof getSubscriberCount;
+    getSubscriberDeps: typeof getSubscriberDeps;
+    forEachSubscriber: typeof forEachSubscriber;
+    getOwnerScope?: typeof getOwnerScope;
+    runWithOwnerScope?: typeof runWithOwnerScope;
+    bindOwnerScope?: typeof bindOwnerScope;
+    structuralBinding?: typeof structuralBinding;
+    captureFrozen?: typeof captureFrozen;
+    holdSubtree?: typeof holdSubtree;
+    version: string;
+    __dupWarned?: boolean;
+}
+declare const untracked: ReactiveApi["untracked"];
+declare const retrack: ReactiveApi["retrack"];
+declare const setMaxDrainIterations: ReactiveApi["setMaxDrainIterations"];
+
+/** Options for effect */
+interface EffectOptions {
+    /** Error handler for exceptions thrown during effect execution. */
+    onError?: (error: unknown) => void;
+    /**
+     * Also run during a server render. By default an effect is a client-only
+     * side effect and does nothing under SSR. With `server: true` it runs on the
+     * server exactly as in the browser — reactively, until the render is
+     * disposed — which is what a data primitive needs to start a fetch the server
+     * render then awaits. Browser APIs are still off limits inside it.
+     */
+    server?: boolean;
+}
+/**
+ * Creates a callback that only tracks the specified dependencies,
+ * running the handler in an untracked context. Use with `effect()`
+ * to control exactly which signals trigger re-execution.
+ *
+ * @param deps Getter(s) whose return values are tracked as dependencies
+ * @param handler Called with the current dependency value(s) whenever they change
+ * @returns A function suitable for passing to `effect()`
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = signal(0);
+ * const [label, setLabel] = signal("clicks");
+ *
+ * // Only re-runs when count changes, NOT when label changes
+ * effect(on(() => count(), (c) => {
+ *   console.log(`${c} ${label()}`);  // label() read but not tracked
+ * }));
+ * ```
+ */
+declare function on<T>(deps: () => T, handler: (value: T, prev: T | undefined) => void): () => void;
+/** Registers a function to run before the effect re-runs or is disposed.
+ *  Called with the same signature inside every invocation. */
+type OnCleanup = (fn: () => void) => void;
+/** The user's effect body — may accept an `onCleanup` callback to register
+ *  teardown that runs before the next re-run or on dispose. */
+type EffectBody = (onCleanup: OnCleanup) => void;
+/**
+ * effect runs the provided effectFn immediately and re-runs it whenever
+ * any reactive dependency changes.
+ * Returns a cleanup function to stop further executions.
+ *
+ * In SSR mode, effect is a no-op — side effects should not run on the server.
+ *
+ * @example addEventListener pattern with built-in teardown:
+ * ```ts
+ * effect((onCleanup) => {
+ *   const handler = (e: Event) => { ... };
+ *   window.addEventListener("resize", handler);
+ *   onCleanup(() => window.removeEventListener("resize", handler));
+ * });
+ * ```
+ *
+ * @returns A dispose function that stops the effect and releases its
+ * dependencies. Idempotent.
+ */
+declare function effect(effectFn: EffectBody | (() => void), options?: EffectOptions): () => void;
+
+/** Where a {@link LifecycleScope} is in its life. */
+type LifecycleState = "active" | "paused" | "ended";
+/**
+ * The lifecycle a component was rendered in, captured so work created LATER —
+ * after an `await` — can still belong to it. See {@link lifecycleScope}.
+ *
+ * Every registration made through it follows the same contract:
+ *
+ * - active: it behaves exactly like the plain primitive;
+ * - paused: a new registration is created only when the lifecycle resumes; an
+ *   existing one does not run, and what changed meanwhile is caught up in ONE
+ *   run on resume, against the current state;
+ * - ended: it is disposed — subscriptions released, cleanups run once — in
+ *   the disposal that ends the lifecycle, before any other reactive work can
+ *   run, and never runs again. A registration made after the end does nothing.
+ *
+ * Each method returns an idempotent disposer that works at any point: before
+ * the registration was created (it then never is), while paused, or after.
+ */
+interface LifecycleScope {
+    /**
+     * `"active"`: the subtree renders normally. `"paused"`: it is leaving (a
+     * `when()` / `match()` branch playing its leave transition) and may still be
+     * taken back. `"ended"`: it was released.
+     */
+    state(): LifecycleState;
+    /**
+     * `effect()`, owned by the captured lifecycle. Paused, changes are
+     * coalesced into one run on resume (its cleanups first, as always).
+     */
+    effect(fn: EffectBody | (() => void), options?: EffectOptions): () => void;
+    /**
+     * `watch()`, owned by the captured lifecycle. It keeps `watch`'s contract —
+     * `callback(current, previous)` when the getter's value changed, compared
+     * with `Object.is` — so while paused the values in between are not
+     * delivered: on resume the callback runs once, with the current value and
+     * the last one it delivered, and not at all if the value came back to it.
+     * Created while paused, it reads its initial value when the lifecycle
+     * resumes.
+     */
+    watch<T>(getter: () => T, callback: (value: T, prev: T | undefined) => void): () => void;
+    /**
+     * The general form: run `register` as owned by the captured lifecycle and
+     * dispose what it returns when the lifecycle ends. Every effect, watcher or
+     * binding `register` creates synchronously is paused and resumed with the
+     * lifecycle; the disposer it returns is called once — at the end, or by the
+     * disposer this returns. Paused, `register` itself waits for the resume.
+     *
+     * If `register` throws, nothing is kept for it: the registration is rolled
+     * back (its lifecycle listeners dropped) and the error is rethrown — or,
+     * for a registration deferred to a resume, reported like an effect error.
+     * Resources `register` acquired before throwing are its own to release:
+     * it never returned the disposer that would have done it.
+     */
+    own(register: () => () => void): () => void;
+    /**
+     * Call `callback` each time the lifecycle pauses (a branch begins its leave,
+     * a `KeepAliveRoute({ suspendInactive: true })` page is cached), a
+     * microtask after it does. Reactive work owned by the scope pauses on its
+     * own; this is for what does not — timers, sockets, media, requests — so it
+     * can be suspended explicitly. Dropped when the lifecycle ends; returns a
+     * function that drops it sooner.
+     *
+     * The callback runs in the context the scope captured — `route()` is the
+     * route of the page that is pausing, not of the page navigated to — and
+     * with the captured lifecycle as owner of what it creates. A pause and a
+     * resume in the same task deliver neither. A callback that throws is
+     * reported; the others still run.
+     */
+    onPause(callback: () => void): () => void;
+    /** Call `callback` each time the lifecycle resumes after a pause; see {@link onPause}. */
+    onResume(callback: () => void): () => void;
+}
+/** The owner check a scope captured. @internal */
+declare function scopeOwner(scope: LifecycleScope): HeldCheck | undefined;
+/**
+ * Capture the current lifecycle — the structural owner and route scope the
+ * calling code renders in — for work created after an `await`.
+ *
+ * An `effect()` or `watch()` called after an `await` runs outside the render
+ * that started the work, so it belongs to no lifecycle: it keeps running while
+ * its component's branch is paused for a leave transition, and only a
+ * disposer you registered yourself stops it. Nothing can find it from the
+ * outside either: it has no DOM node, so holding a detached subtree does not
+ * reach it, and registering its disposer on a node gives teardown, not
+ * ownership. Capture the lifecycle synchronously, before the first `await`,
+ * and create the work through it:
+ *
+ * ```ts
+ * function Profile(id: string) {
+ *   const scope = lifecycleScope();          // during render
+ *   const el = div("loading…");
+ *   load(id).then((user) => {
+ *     scope.effect(() => {                   // owned by Profile's lifecycle
+ *       el.textContent = `${user.name} (${status()})`;
+ *     });
+ *     scope.watch(() => user.online(), (online) => notify(online));
+ *   });
+ *   return el;
+ * }
+ * ```
+ *
+ * Nothing is installed globally across the `await`: each scope is an explicit
+ * object, so concurrent work never inherits another's lifecycle.
+ *
+ * Which lifecycle is captured:
+ * - in a `when()` / `match()` branch the directive built, the branch's: it
+ *   ends when the branch is replaced — at the switch, or with a `transition`
+ *   when its leave ends; it pauses while the branch leaves and resumes if the
+ *   branch is taken back. A bare node handed to the directive is the
+ *   caller's, so the scope is that of the code that built it;
+ * - in a route component (cached, lazy, unwrapped from a module), the route
+ *   instance's: it ends when the instance is replaced or disposed, and pauses
+ *   with the branch holding the outlet — and, with
+ *   `KeepAliveRoute({ suspendInactive: true })`, while the page is cached;
+ * - in `Suspense`'s `nodes()` (or `fallback`), the boundary's content (or
+ *   fallback): it ends with the boundary (or when the fallback is replaced),
+ *   and the content's as soon as that content is abandoned — `nodes()` threw
+ *   or rejected, or what it returned could not be inserted;
+ * - outside any render: none. The scope is always active and never ends; its
+ *   registrations behave like the plain primitives.
+ *
+ * Only what goes through the scope is owned. An `effect()` created after an
+ * `await` without it is unowned, and stays so: nothing is installed across
+ * the `await`, and ownership is never inferred from what rendered last.
+ * `registerDisposer(node, stop)` gives such work teardown with that node, not
+ * pause and resume.
+ *
+ * @returns The captured {@link LifecycleScope}.
+ */
+declare function lifecycleScope(): LifecycleScope;
+
+/** A registration made by {@link pendingContent}. */
+interface PendingContent {
+    /**
+     * The content is committed: settle the registration. Call it AFTER the
+     * content is in the DOM — readiness means "on the page", not "the request
+     * returned". `committed` names what joins a running enter; by default it is
+     * what the location renders then (the children of an element, the range
+     * after an anchor). A failure that commits an error view settles the same
+     * way, with that view.
+     */
+    done(committed?: Node | readonly Node[]): void;
+    /**
+     * The operation was cancelled or superseded: settle WITHOUT content.
+     * Nothing joins a running enter for it — not even what its location shows
+     * now (a loading placeholder). Disposing the location, or the end of the
+     * lifecycle it was registered on, cancels it the same way.
+     */
+    cancel(): void;
+    /** Whether it has settled (done, cancelled, or dropped with its location). */
+    readonly settled: boolean;
+}
+/**
+ * Register content that will arrive later, so a `when()` / `match()` enter
+ * with `waitForContent` waits for it. Nothing becomes pending on its own — a
+ * `fetch`, a promise or an `asyncDerived` is not tracked until the application
+ * says so here — and each call is one independent registration: several at
+ * the same location stay pending until each one settles, and settling one
+ * (a stale request completing late) never settles another.
+ *
+ * `at` places it:
+ * - a node (an element, or a range anchor): it takes part in an enter while
+ *   the node lies inside the entering branch. Moving it into the branch, or
+ *   out of it, while the enter waits is noticed when it happens: attached, it
+ *   holds the enter (and its content joins when it is done); removed, it no
+ *   longer does. Disposing the node cancels it;
+ * - a {@link LifecycleScope}: it takes part when that lifecycle lies inside
+ *   the entering branch (captured in it, or in a route instance or `Suspense`
+ *   below it). The lifecycle ending cancels it. This is the form to use when
+ *   the content is pending BEFORE the node it will render into exists — a
+ *   component that starts a request, then builds its DOM when it returns:
+ *   capture the scope while rendering and register on it. A scope captured
+ *   outside any render belongs to no branch and never ends: a registration
+ *   on it holds no enter, and stays until it is settled.
+ *
+ * Settle it exactly when the outcome is committed: `done()` after inserting
+ * the content (or an error view), `cancel()` when the operation is abandoned
+ * or superseded — a cancelled registration enrolls nothing in the enter. Both
+ * are idempotent; the first call wins, so a stale `done()` after a
+ * `cancel()` (or after the location was disposed) does nothing. A registration
+ * made while an enter is waiting is picked up by it, but the enter's
+ * deadline, fixed at the switch, never moves: content committed later
+ * appears without an enter.
+ *
+ * Server renders play no transitions: there it registers nothing and returns
+ * an inert handle (already settled), so the same code runs in both places.
+ *
+ * ```ts
+ * function Results(query: string) {
+ *   const list = ul({ class: "results" }, li("Loading…"));
+ *   const pending = pendingContent(list);
+ *   fetch(`/api/search?q=${query}`)
+ *     .then((r) => r.json())
+ *     .then((rows) => {
+ *       list.replaceChildren(...rows.map((row) => li(row.title)));
+ *       pending.done();                       // committed: the rows join the enter
+ *     })
+ *     .catch((err) => {
+ *       list.replaceChildren(li({ class: "error" }, String(err)));
+ *       pending.done();                       // the error view is the outcome
+ *     });
+ *   return list;
+ * }
+ * ```
+ *
+ * Content driven by reactive state is committed by its bindings; settle once
+ * the state that feeds them has arrived. Readiness is read a microtask after
+ * `done()`, after the bindings of the same update have run:
+ *
+ * ```ts
+ * function Profile() {
+ *   const scope = lifecycleScope();
+ *   const user = asyncDerived(() => loadUser(), null);
+ *   const card = div({ class: "card" }, () => user.value()?.name ?? "Loading…");
+ *   const pending = pendingContent(card);
+ *   scope.watch(() => user.loading(), (loading) => {
+ *     if (!loading) pending.done();           // value (or error) rendered
+ *   });
+ *   scope.own(() => user.dispose);
+ *   return card;
+ * }
+ * ```
+ *
+ * @param at The node, range anchor or captured lifecycle the content belongs to.
+ * @returns The registration's handle.
+ */
+declare function pendingContent(at: Node | LifecycleScope): PendingContent;
+
 /**
  * Portal renders nodes into a DOM node outside the parent component hierarchy.
  * Useful for modals, tooltips, dropdowns, and overlays.
@@ -1537,67 +2156,6 @@ declare function deepEqual(a: unknown, b: unknown, seen?: Map<object, Set<object
  */
 declare function deepSignal<T>(initial: T): [Accessor<T>, (next: T | ((prev: T) => T)) => void];
 
-/** Options for effect */
-interface EffectOptions {
-    /** Error handler for exceptions thrown during effect execution. */
-    onError?: (error: unknown) => void;
-    /**
-     * Also run during a server render. By default an effect is a client-only
-     * side effect and does nothing under SSR. With `server: true` it runs on the
-     * server exactly as in the browser — reactively, until the render is
-     * disposed — which is what a data primitive needs to start a fetch the server
-     * render then awaits. Browser APIs are still off limits inside it.
-     */
-    server?: boolean;
-}
-/**
- * Creates a callback that only tracks the specified dependencies,
- * running the handler in an untracked context. Use with `effect()`
- * to control exactly which signals trigger re-execution.
- *
- * @param deps Getter(s) whose return values are tracked as dependencies
- * @param handler Called with the current dependency value(s) whenever they change
- * @returns A function suitable for passing to `effect()`
- *
- * @example
- * ```ts
- * const [count, setCount] = signal(0);
- * const [label, setLabel] = signal("clicks");
- *
- * // Only re-runs when count changes, NOT when label changes
- * effect(on(() => count(), (c) => {
- *   console.log(`${c} ${label()}`);  // label() read but not tracked
- * }));
- * ```
- */
-declare function on<T>(deps: () => T, handler: (value: T, prev: T | undefined) => void): () => void;
-/** Registers a function to run before the effect re-runs or is disposed.
- *  Called with the same signature inside every invocation. */
-type OnCleanup = (fn: () => void) => void;
-/** The user's effect body — may accept an `onCleanup` callback to register
- *  teardown that runs before the next re-run or on dispose. */
-type EffectBody = (onCleanup: OnCleanup) => void;
-/**
- * effect runs the provided effectFn immediately and re-runs it whenever
- * any reactive dependency changes.
- * Returns a cleanup function to stop further executions.
- *
- * In SSR mode, effect is a no-op — side effects should not run on the server.
- *
- * @example addEventListener pattern with built-in teardown:
- * ```ts
- * effect((onCleanup) => {
- *   const handler = (e: Event) => { ... };
- *   window.addEventListener("resize", handler);
- *   onCleanup(() => window.removeEventListener("resize", handler));
- * });
- * ```
- *
- * @returns A dispose function that stops the effect and releases its
- * dependencies. Idempotent.
- */
-declare function effect(effectFn: EffectBody | (() => void), options?: EffectOptions): () => void;
-
 /**
  * ref creates a mutable reference object with a reactive `current` property.
  *
@@ -2005,145 +2563,4 @@ declare function transition(): TransitionState;
  */
 declare function nextTick(): Promise<void>;
 
-type Subscriber = () => void;
-/**
- * Stop recording dependency edges until the matching {@link resumeTracking}.
- * Nestable — the depth is counted, so an inner pair does not resume early.
- *
- * Prefer {@link untracked}, which pairs the two calls for you even when the
- * body throws. Reach for the raw pair only when the suspended region cannot be
- * expressed as a single function.
- *
- * @returns Nothing.
- */
-declare function suspendTracking(): void;
-/**
- * Undo one {@link suspendTracking}. Dependency recording resumes only when the
- * outermost pair closes.
- *
- * @returns Nothing.
- */
-declare function resumeTracking(): void;
-/** Read the "tracking suspended" flag (used by derived's lazy path). */
-declare function isTrackingSuspended(): boolean;
-/**
- * Run `fn` without recording anything it reads as a dependency.
- *
- * The suspension is released even if `fn` throws, which is the reason to prefer
- * this over a manual suspend/resume pair.
- *
- * @param fn Function to run outside dependency tracking.
- * @returns Whatever `fn` returns.
- */
-declare function untracked$1<T>(fn: () => T): T;
-/** The owner scope in effect right now (`null` when there is none). @internal */
-declare function getOwnerScope(): unknown;
-/**
- * Run `fn` with `scope` as the current owner scope, restoring the previous
- * scope afterwards (even if `fn` throws). @internal
- */
-declare function runWithOwnerScope<T>(scope: unknown, fn: () => T): T;
-/**
- * Capture the current owner scope into `fn`, for work that runs later (a
- * deferred first render, a lifecycle callback). Returns `fn` itself when there
- * is no scope to carry. @internal
- */
-declare function bindOwnerScope<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R;
-declare function retrack$1(effectFn: () => void, subscriber: Subscriber): void;
-declare function track(effectFn: () => void, subscriber?: Subscriber): () => void;
-declare function reactiveBinding(commit: () => void, ownerNode?: unknown, structural?: boolean): () => void;
-/**
- * Handle returned by {@link structuralBinding}.
- * @internal
- */
-interface StructuralBinding {
-    /** Dispose the binding. Idempotent. */
-    stop: () => void;
-    /**
-     * Run `fn` with this binding as the structural owner, for a render that
-     * happens outside the binding's own run (a directive's deferred first
-     * render), so what it builds is owned exactly as a later rebuild would be.
-     */
-    run: <T>(fn: () => T) => T;
-}
-/**
- * A {@link reactiveBinding} whose run may REPLACE the subtree it renders —
- * the binding behind `when`, `match`, `each` and `KeepAlive`. Subscribers
- * created while it runs are owned by it, and the drain runs it before any of
- * them when both are pending (see "Structural ownership").
- * @internal
- */
-declare function structuralBinding(commit: () => void, ownerNode?: unknown): StructuralBinding;
-declare function recordDependency(signal: ReactiveSignal): void;
-declare function cleanup(subscriber: Subscriber): void;
-/**
- * Cap how many times one subscriber may re-run within a single drain before it
- * is quarantined as a runaway cycle. A safety valve, not a tuning knob.
- *
- * @param n New limit; ignored unless finite and positive.
- * @returns The previous limit, so a caller can restore it.
- */
-declare function setMaxSubscriberRepeats(n: number): number;
-/**
- * Cap how many passes one notification drain may make before giving up on a
- * self-refeeding update cycle.
- *
- * @param n New limit; ignored unless finite and positive.
- * @returns The previous limit, so a caller can restore it.
- */
-declare function setMaxDrainIterations$1(n: number): number;
-/**
- * Flush queued signal notifications, running every dirty subscriber.
- *
- * Re-entrant calls are ignored: a write performed from inside a subscriber adds
- * to the queue the current drain is already working through, rather than
- * starting a nested one.
- *
- * @returns Nothing.
- */
-declare function drainNotificationQueue(): void;
-declare function queueSignalNotification(signal: ReactiveSignal): void;
-/**
- * Mark every subscriber of `signal` dirty and queue them for the next drain.
- *
- * @param signal The signal that changed.
- * @returns Nothing.
- */
-declare function notifySubscribers(signal: ReactiveSignal): void;
-/** O(1) subscriber count for devtools / introspection. */
-declare function getSubscriberCount(signal: ReactiveSignal): number;
-/** Return the signals a subscriber currently depends on, in record order. */
-declare function getSubscriberDeps(subscriber: Subscriber): ReactiveSignal[];
-/** Iterate subscribers of a signal (devtools graph walk). */
-declare function forEachSubscriber(signal: ReactiveSignal, visit: (sub: Subscriber) => void): void;
-
-interface ReactiveApi {
-    suspendTracking: typeof suspendTracking;
-    resumeTracking: typeof resumeTracking;
-    isTrackingSuspended: typeof isTrackingSuspended;
-    untracked: typeof untracked$1;
-    retrack: typeof retrack$1;
-    track: typeof track;
-    reactiveBinding: typeof reactiveBinding;
-    recordDependency: typeof recordDependency;
-    cleanup: typeof cleanup;
-    setMaxSubscriberRepeats: typeof setMaxSubscriberRepeats;
-    setMaxDrainIterations: typeof setMaxDrainIterations$1;
-    drainNotificationQueue: typeof drainNotificationQueue;
-    queueSignalNotification: typeof queueSignalNotification;
-    notifySubscribers: typeof notifySubscribers;
-    getSubscriberCount: typeof getSubscriberCount;
-    getSubscriberDeps: typeof getSubscriberDeps;
-    forEachSubscriber: typeof forEachSubscriber;
-    getOwnerScope?: typeof getOwnerScope;
-    runWithOwnerScope?: typeof runWithOwnerScope;
-    bindOwnerScope?: typeof bindOwnerScope;
-    structuralBinding?: typeof structuralBinding;
-    version: string;
-    __dupWarned?: boolean;
-}
-declare const untracked: ReactiveApi["untracked"];
-declare const retrack: ReactiveApi["retrack"];
-declare const setMaxDrainIterations: ReactiveApi["setMaxDrainIterations"];
-
-export { Accessor, type ActionFn, type AnchorProps, type ArrayActions, type AsyncDerivedContext, type AsyncDerivedState, type AudioProps, type ButtonProps, ClientOnly, type ClientOnlyOptions, Component, type Context, DerivedAccessor, type DirectiveOptions, DynamicComponent, type EffectBody, type EffectOptions, ErrorBoundary, type ErrorBoundaryOptions, type ErrorBoundaryProps, ErrorDisplay, type ErrorDisplayProps, type ErrorSeverity, type FocusPolicy, type FormProps, Fragment, type ImgProps, type InputProps, type InputType, KeepAlive, type KeepAliveOptions, type LabelProps, Loading, type LoadingProps, type LongPressOptions, MAX_DRAIN_TEARDOWNS, type MediaProps, NodeChild, NodeChildren, type OnCleanup, type OptionProps, Portal, type Ref, type RuntimeErrorContext, type RuntimeErrorHandler, type RuntimeErrorPhase, type SSRStore, type SelectProps, type SlotFn, type Slots, type StoreActions, Suspense, type SuspenseProps, TagFunction, TagProps, type TextareaProps, type TypedTagFunction, type VideoProps, __renderParsedTemplate, __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, details, dfn, dialog, disableSSR, dispose, div, dl, dt, each, effect, ellipse, em, embed, enableSSR, 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, isClient, isSSR, isServer, kbd, label, lazy, legend, li, line, linearGradient, link, longPress, main, map, mark, marker, marquee, mask, match, math, menu, meta, meter, mount, 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, replaceChildrenSafely, reportDrainRunaway, reportError, resolveComponent, retrack, rp, rt, ruby, runInSSRContext, s, samp, script, section, select, setGlobalErrorHandler, setMaxDrainIterations, setRuntimeErrorHandler, show, 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, untracked, use, var_, video, watch, when, withSSR, writable };
+export { Accessor, type ActionFn, type AnchorProps, type ArrayActions, type AsyncDerivedContext, type AsyncDerivedState, type AudioProps, type ButtonProps, ClientOnly, type ClientOnlyOptions, Component, type Context, DerivedAccessor, type DirectiveOptions, type DirectiveTransition, DynamicComponent, type EachIndex, type EachItem, type EffectBody, type EffectOptions, ErrorBoundary, type ErrorBoundaryOptions, type ErrorBoundaryProps, ErrorDisplay, type ErrorDisplayProps, type ErrorSeverity, type FocusPolicy, type FormProps, Fragment, type ImgProps, type InputProps, type InputType, KeepAlive, type KeepAliveOptions, type LabelProps, type LifecycleScope, type LifecycleState, Loading, type LoadingProps, type LongPressOptions, MAX_DRAIN_TEARDOWNS, type MediaProps, NodeChild, NodeChildren, type OnCleanup, type OptionProps, type PendingContent, Portal, type Ref, type RuntimeErrorContext, type RuntimeErrorHandler, type RuntimeErrorPhase, type SSRStore, type SelectProps, type SlotFn, type Slots, type StoreActions, Suspense, type SuspenseProps, TagFunction, TagProps, type TextareaProps, type TypedTagFunction, type VideoProps, __renderParsedTemplate, __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, details, dfn, dialog, disableSSR, dispose, div, dl, dt, each, effect, ellipse, em, embed, enableSSR, 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, isClient, isSSR, isServer, kbd, label, lazy, legend, li, lifecycleScope, line, linearGradient, link, longPress, main, map, mark, marker, marquee, mask, match, math, menu, meta, meter, mount, nav, nextTick, noscript, object, ol, on, onCleanup, onMount, onUnmount, optgroup, option, output, p, param, path, pattern, pendingContent, picture, polygon, polyline, portal, pre, progress, q, radialGradient, reactiveArray, rect, ref, registerAction, registerComponent, registerDisposer, replaceChildrenSafely, reportDrainRunaway, reportError, resolveComponent, retrack, rp, rt, ruby, runInSSRContext, s, samp, scopeOwner, script, section, select, setGlobalErrorHandler, setMaxDrainIterations, setRuntimeErrorHandler, show, 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, transition, trapFocus, tspan, u, ul, unregisterComponent, unregisterDisposer, untracked, use, var_, video, watch, when, withSSR, writable };