@qwik.dev/core 2.0.0-beta.31 → 2.0.0-beta.34

package/dist/backpatch/index.mjs

@@ -1,5 +1,5 @@
-const QWIK_BACKPATCH_EXECUTOR_MINIFIED = "const t='script[type=\"qwik/backpatch\"]',e=document.currentScript;if(e){const o=e.closest(\"[q\\\\:container]:not([q\\\\:container=html]):not([q\\\\:container=text])\");if(o){const e=o.querySelector(t);if(e){const t=JSON.parse(e.textContent||\"[]\"),n=document.createTreeWalker(o,NodeFilter.SHOW_ELEMENT);let r=n.currentNode,c=r.hasAttribute(\":\")?0:-1;for(let e=0;e<t.length;e+=3){const o=t[e],i=t[e+1];let s=t[e+2];for(;c<o&&(r=n.nextNode(),r);)r.hasAttribute(\":\")&&c++;const l=r;null==s||!1===s?l.removeAttribute(i):(\"boolean\"==typeof s&&(s=\"\"),l.setAttribute(i,s))}}}}";
-const QWIK_BACKPATCH_EXECUTOR_DEBUG = "const BACKPATCH_DATA_SELECTOR = 'script[type=\"qwik/backpatch\"]';\nconst executorScript = document.currentScript;\nif (executorScript) {\n  const container = executorScript.closest(\n    \"[q\\\\:container]:not([q\\\\:container=html]):not([q\\\\:container=text])\"\n  );\n  if (container) {\n    const script = container.querySelector(BACKPATCH_DATA_SELECTOR);\n    if (script) {\n      const data = JSON.parse(script.textContent || \"[]\");\n      const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT);\n      let currentNode = walker.currentNode;\n      let currentNodeIdx = currentNode.hasAttribute(\":\") ? 0 : -1;\n      for (let i = 0; i < data.length; i += 3) {\n        const elementIdx = data[i];\n        const attrName = data[i + 1];\n        let value = data[i + 2];\n        while (currentNodeIdx < elementIdx) {\n          currentNode = walker.nextNode();\n          if (!currentNode) {\n            break;\n          }\n          if (currentNode.hasAttribute(\":\")) {\n            currentNodeIdx++;\n          }\n        }\n        const element = currentNode;\n        if (value == null || value === false) {\n          element.removeAttribute(attrName);\n        } else {\n          if (typeof value === \"boolean\") {\n            value = \"\";\n          }\n          element.setAttribute(attrName, value);\n        }\n      }\n    }\n  }\n}";
+const QWIK_BACKPATCH_EXECUTOR_MINIFIED = "const t='script[type=\"qwik/backpatch\"]';function e(e,n){const o=n||e.querySelector(\"[q\\\\:container]:not([q\\\\:container=html]):not([q\\\\:container=text])\");if(o){const n=o.querySelector(t);if(n){const t=JSON.parse(n.textContent||\"[]\"),r=e.createTreeWalker(o,NodeFilter.SHOW_ELEMENT);let c=r.currentNode,i=c.hasAttribute(\":\")?0:-1;for(let e=0;e<t.length;e+=3){const n=t[e],o=t[e+1];let s=t[e+2];for(;i<n&&(c=r.nextNode(),c);)c.hasAttribute(\":\")&&i++;const a=c;null==s||!1===s?a.removeAttribute(o):(\"boolean\"==typeof s&&(s=\"\"),a.setAttribute(o,s))}}}}const n=document.currentScript;if(n){const t=n.closest(\"[q\\\\:container]:not([q\\\\:container=html]):not([q\\\\:container=text])\");t&&e(document,t)}";
+const QWIK_BACKPATCH_EXECUTOR_DEBUG = "const BACKPATCH_DATA_SELECTOR = 'script[type=\"qwik/backpatch\"]';\nfunction executeBackpatch(doc, containerElement) {\n  const container = containerElement || doc.querySelector(\"[q\\\\:container]:not([q\\\\:container=html]):not([q\\\\:container=text])\");\n  if (container) {\n    const script = container.querySelector(BACKPATCH_DATA_SELECTOR);\n    if (script) {\n      const data = JSON.parse(script.textContent || \"[]\");\n      const walker = doc.createTreeWalker(container, NodeFilter.SHOW_ELEMENT);\n      let currentNode = walker.currentNode;\n      let currentNodeIdx = currentNode.hasAttribute(\":\") ? 0 : -1;\n      for (let i = 0; i < data.length; i += 3) {\n        const elementIdx = data[i];\n        const attrName = data[i + 1];\n        let value = data[i + 2];\n        while (currentNodeIdx < elementIdx) {\n          currentNode = walker.nextNode();\n          if (!currentNode) {\n            break;\n          }\n          if (currentNode.hasAttribute(\":\")) {\n            currentNodeIdx++;\n          }\n        }\n        const element = currentNode;\n        if (value == null || value === false) {\n          element.removeAttribute(attrName);\n        } else {\n          if (typeof value === \"boolean\") {\n            value = \"\";\n          }\n          element.setAttribute(attrName, value);\n        }\n      }\n    }\n  }\n}\nconst executorScript = document.currentScript;\nif (executorScript) {\n  const container = executorScript.closest(\n    \"[q\\\\:container]:not([q\\\\:container=html]):not([q\\\\:container=text])\"\n  );\n  if (container) {\n    executeBackpatch(document, container);\n  }\n}";
 globalThis.QWIK_BACKPATCH_EXECUTOR_MINIFIED = QWIK_BACKPATCH_EXECUTOR_MINIFIED;
 globalThis.QWIK_BACKPATCH_EXECUTOR_DEBUG = QWIK_BACKPATCH_EXECUTOR_DEBUG;
 export { QWIK_BACKPATCH_EXECUTOR_MINIFIED, QWIK_BACKPATCH_EXECUTOR_DEBUG };

package/dist/backpatch/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwik.dev/core/backpatch",
-  "version": "2.0.0-beta.31-dev+906321a",
+  "version": "2.0.0-beta.34-dev+8b055bb",
   "main": "index.mjs",
   "types": "index.d.ts",
   "private": true,

package/dist/backpatch-executor.debug.js

@@ -1,14 +1,11 @@
 const BACKPATCH_DATA_SELECTOR = 'script[type="qwik/backpatch"]';
-const executorScript = document.currentScript;
-if (executorScript) {
-  const container = executorScript.closest(
-    "[q\\:container]:not([q\\:container=html]):not([q\\:container=text])"
-  );
+function executeBackpatch(doc, containerElement) {
+  const container = containerElement || doc.querySelector("[q\\:container]:not([q\\:container=html]):not([q\\:container=text])");
   if (container) {
     const script = container.querySelector(BACKPATCH_DATA_SELECTOR);
     if (script) {
       const data = JSON.parse(script.textContent || "[]");
-      const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT);
+      const walker = doc.createTreeWalker(container, NodeFilter.SHOW_ELEMENT);
       let currentNode = walker.currentNode;
       let currentNodeIdx = currentNode.hasAttribute(":") ? 0 : -1;
       for (let i = 0; i < data.length; i += 3) {
@@ -37,3 +34,12 @@ if (executorScript) {
     }
   }
 }
+const executorScript = document.currentScript;
+if (executorScript) {
+  const container = executorScript.closest(
+    "[q\\:container]:not([q\\:container=html]):not([q\\:container=text])"
+  );
+  if (container) {
+    executeBackpatch(document, container);
+  }
+}

package/dist/backpatch-executor.js

@@ -1 +1 @@
-const t='script[type="qwik/backpatch"]',e=document.currentScript;if(e){const o=e.closest("[q\\:container]:not([q\\:container=html]):not([q\\:container=text])");if(o){const e=o.querySelector(t);if(e){const t=JSON.parse(e.textContent||"[]"),n=document.createTreeWalker(o,NodeFilter.SHOW_ELEMENT);let r=n.currentNode,c=r.hasAttribute(":")?0:-1;for(let e=0;e<t.length;e+=3){const o=t[e],i=t[e+1];let s=t[e+2];for(;c<o&&(r=n.nextNode(),r);)r.hasAttribute(":")&&c++;const l=r;null==s||!1===s?l.removeAttribute(i):("boolean"==typeof s&&(s=""),l.setAttribute(i,s))}}}}
+const t='script[type="qwik/backpatch"]';function e(e,n){const o=n||e.querySelector("[q\\:container]:not([q\\:container=html]):not([q\\:container=text])");if(o){const n=o.querySelector(t);if(n){const t=JSON.parse(n.textContent||"[]"),r=e.createTreeWalker(o,NodeFilter.SHOW_ELEMENT);let c=r.currentNode,i=c.hasAttribute(":")?0:-1;for(let e=0;e<t.length;e+=3){const n=t[e],o=t[e+1];let s=t[e+2];for(;i<n&&(c=r.nextNode(),c);)c.hasAttribute(":")&&i++;const a=c;null==s||!1===s?a.removeAttribute(o):("boolean"==typeof s&&(s=""),a.setAttribute(o,s))}}}}const n=document.currentScript;if(n){const t=n.closest("[q\\:container]:not([q\\:container=html]):not([q\\:container=text])");t&&e(document,t)}

package/dist/build/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwik.dev/core/build",
-  "version": "2.0.0-beta.31-dev+906321a",
+  "version": "2.0.0-beta.34-dev+8b055bb",
   "main": "index.mjs",
   "types": "index.d.ts",
   "private": true,

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/cli 2.0.0-beta.31-dev+906321a
+ * @qwik.dev/core/cli 2.0.0-beta.34-dev+8b055bb
  * Copyright QwikDev. All Rights Reserved.
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://github.com/QwikDev/qwik/blob/main/LICENSE
@@ -12953,7 +12953,7 @@ async function printHelp(app) {
   await runCommand2(Object.assign(app, { task: args[0], args }));
 }
 function printVersion() {
-  console.log("2.0.0-beta.31-dev+906321a");
+  console.log("2.0.0-beta.34-dev+8b055bb");
 }
 export {
   runCli,

package/dist/core-internal.d.ts

@@ -381,7 +381,7 @@ declare type AsyncCtx<T = unknown> = {
     /** The result of the previous computation, if any */
     readonly previous: T | undefined;
     /** Extra info passed to `invalidate(info)` for this computation, if any. */
-    readonly info: unknown;
+    readonly info?: unknown;
 };
 
 /**
@@ -396,16 +396,16 @@ export declare type AsyncFn<T> = (ctx: AsyncCtx) => ValueOrPromise<T>;
 /** Retains job metadata and also serves as the argument for the compute function */
 declare class AsyncJob<T> implements AsyncCtx<T> {
     readonly $signal$: AsyncSignalImpl<T>;
-    readonly info: unknown;
-    readonly $infoVersion$: number;
     /** First holds the compute promise and then the cleanup promise */
-    $promise$: Promise<void> | null;
+    $promise$: Promise<void> | null | void;
     $cleanupRequested$: boolean;
     $canWrite$: boolean;
     $track$: AsyncCtx<T>['track'] | undefined;
     $cleanups$: Parameters<AsyncCtx<T>['cleanup']>[0][] | undefined;
     $abortController$: AbortController | undefined;
-    constructor($signal$: AsyncSignalImpl<T>, info: unknown, $infoVersion$: number);
+    info: unknown;
+    $infoVersion$: number | undefined;
+    constructor($signal$: AsyncSignalImpl<T>, info: unknown, $infoVersion$: number | undefined);
     get track(): AsyncCtx<T>['track'];
     get abortSignal(): AbortSignal;
     /** Backward compatible cache method for resource */
@@ -451,18 +451,40 @@ export declare interface AsyncSignal<T = unknown> extends ComputedSignal<T> {
      * ```
      */
     loading: boolean;
+    /**
+     * Lets you read the loading state without subscribing to `.loading` updates. It also triggers
+     * lazy loading of the signal.
+     *
+     * Setting it will trigger listeners for `.loading`.
+     */
+    untrackedLoading: boolean;
     /**
      * The error that occurred while computing the signal, if any. This will be cleared when the
-     * signal is successfully computed.
+     * signal is successfully computed. It does not trigger lazy loading of the signal.
      */
     error: Error | undefined;
     /**
-     * Staleness/poll interval in ms. Writable and immediately effective.
+     * Lets you read the error state without subscribing to `.error` updates. It does not trigger lazy
+     * loading of the signal.
      *
-     * - **Positive**: Poll — re-compute after this many ms when subscribers exist.
-     * - **Negative**: Stale-only — mark stale after `|interval|` ms, no auto-recompute.
-     * - **`0`**: No staleness tracking or polling.
+     * Setting it will trigger listeners for `.error`.
      */
+    untrackedError: Error | undefined;
+    /**
+     * Expiration time in ms. Writable and immediately effective.
+     *
+     * When set, the signal is invalidated after this many ms. Whether it auto-recomputes depends on
+     * the `poll` property. `0` means no expiration.
+     */
+    expires: number;
+    /**
+     * Whether to automatically re-run the function when the value expires. Writable and immediately
+     * effective. Only relevant when `expires` is set.
+     *
+     * Defaults to `true`.
+     */
+    poll: boolean;
+    /** @deprecated Use `expires` and `poll` instead. Will be removed before v2 */
     interval: number;
     /** A promise that resolves when the value is computed or rejected. */
     promise(): Promise<void>;
@@ -477,7 +499,9 @@ export declare interface AsyncSignal<T = unknown> extends ComputedSignal<T> {
 
 declare const enum AsyncSignalFlags {
     EAGER_CLEANUP = 32,
-    CLIENT_ONLY = 64
+    CLIENT_ONLY = 64,
+    CLEAR_ON_INVALIDATE = 128,
+    NO_POLL = 256
 }
 
 /**
@@ -486,21 +510,23 @@ declare const enum AsyncSignalFlags {
  * AsyncSignalImpl
  *
  * # ================================
+ *
+ * @internal
  */
 declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> implements BackRef, AsyncSignal<T> {
     $untrackedLoading$: boolean;
     $untrackedError$: Error | undefined;
-    $loadingEffects$: undefined | Set<EffectSubscription>;
-    $errorEffects$: undefined | Set<EffectSubscription>;
     $current$: AsyncJob<T> | null;
-    $jobs$: AsyncJob<T>[];
-    $concurrency$: number;
-    $interval$: number;
+    $jobs$: AsyncJob<T>[] | undefined;
+    $concurrency$: number | undefined;
+    $expires$: number | undefined;
     $timeoutMs$: number | undefined;
-    $info$: unknown;
-    $infoVersion$: number;
+    $loadingEffects$: undefined | Set<EffectSubscription>;
+    $errorEffects$: undefined | Set<EffectSubscription>;
     $pollTimeoutId$: ReturnType<typeof setTimeout> | undefined;
     $computationTimeoutId$: ReturnType<typeof setTimeout> | undefined;
+    $info$: unknown | undefined;
+    $infoVersion$: number | undefined;
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | undefined;
     constructor(container: _Container | null, fn: AsyncQRL<T>, flags?: SignalFlags | SerializationSignalFlags, options?: AsyncSignalOptions<T>);
     get untrackedValue(): T;
@@ -532,10 +558,16 @@ declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> impl
     get error(): Error | undefined;
     set untrackedError(value: Error | undefined);
     get untrackedError(): Error | undefined;
+    get expires(): number;
+    set expires(value: number);
+    get poll(): boolean;
+    set poll(value: boolean);
+    /** @deprecated Use `expires` and `poll` instead. */
     get interval(): number;
     set interval(value: number);
     /** Invalidates the signal, causing it to re-compute its value. */
     invalidate(info?: unknown): Promise<void>;
+    $setInvalid$(allowRecalc: boolean, mustClear: boolean | number): void;
     /** Abort the current computation and run cleanups if needed. */
     abort(reason?: any): void;
     /** Schedule eager cleanup on next macro task if no subscribers remain. */
@@ -545,14 +577,19 @@ declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> impl
     /** Run the computation if needed */
     $computeIfNeeded$(): void;
     $runComputation$(running: AsyncJob<T>): Promise<void>;
+    /**
+     * Sets the error from the given job. We only accept errors from the current job and we ignore
+     * AbortErrors.
+     */
+    $setError$(job: AsyncJob<T>, error: Error): void;
     /** Called after SSR/unmount */
     $destroy$(): Promise<void>;
     private $clearNextPoll$;
     private $scheduleNextPoll$;
     private $hasSubscribers$;
-    $requestCleanups$(job: AsyncJob<T>, reason?: any): Promise<void | null>;
+    $requestCleanups$(job: AsyncJob<T>, reason?: any): void;
     /** Clean up and trigger signal compute once complete */
-    $runCleanups$(job: AsyncJob<T>): Promise<void>;
+    $runCleanups$(job: AsyncJob<T>): Promise<void> | undefined;
 }
 
 /** @public */
@@ -573,21 +610,23 @@ export declare interface AsyncSignalOptions<T> extends ComputedOptions {
      */
     eagerCleanup?: boolean;
     /**
-     * Wait for previous invocation to complete before running again.
+     * Time in milliseconds after which the value expires.
      *
-     * Defaults to `true`.
+     * When the value expires and subscribers exist, the signal is invalidated. If `poll` is `true`
+     * (default), the function is re-run automatically. If `poll` is `false`, the value is marked
+     * stale and recomputation happens when reading `.value` or `.loading`.
      *
-     * @deprecated Not implemented yet
+     * `0` (default) means no expiration.
      */
-    awaitPrevious?: boolean;
+    expires?: number;
     /**
-     * Controls staleness and polling behavior.
+     * Whether to automatically re-run the function when the value expires. Only relevant when
+     * `expires` is set.
      *
-     * - **Positive**: Re-run the function after `interval` ms if subscribers exist (polling).
-     * - **Negative**: Mark the value as stale after `|interval|` ms, but do NOT auto-recompute.
-     *   Consumers can check staleness and manually trigger recomputation.
-     * - **`0`** (default): No staleness tracking or polling.
+     * Defaults to `true`.
      */
+    poll?: boolean;
+    /** @deprecated Use `expires` and `poll` instead. Will be removed before v2 */
     interval?: number;
     /**
      * When true, the async computation is postponed to the browser. On SSR, the signal remains
@@ -596,6 +635,23 @@ export declare interface AsyncSignalOptions<T> extends ComputedOptions {
      * Defaults to `false`.
      */
     clientOnly?: boolean;
+    /**
+     * When true (default), the previous value is kept while the signal re-computes after
+     * invalidation, so reads return stale data instead of throwing a promise. Reactivity will then
+     * update the readers when the new value is ready.
+     *
+     * When false, invalidation clears the value so reads throw the computation promise (like the
+     * initial load), which is useful for navigations where showing old data would be confusing.
+     *
+     * Note that polling invalidations (`expires` with `poll: true`) are not affected by this option
+     * and will keep the old value while the new value is loading, to avoid flashing loaders.
+     *
+     * This option only affects manual invalidations via `invalidate()`, and non-polling expirations
+     * (`poll: false`, or there are no subscribers).
+     *
+     * Defaults to `true`.
+     */
+    allowStale?: boolean;
     /**
      * Maximum time in milliseconds to wait for the async computation to complete. If exceeded, the
      * computation is aborted and an error is thrown.
@@ -633,6 +689,10 @@ declare type BivariantQrlFn<ARGS extends any[], RETURN> = {
 /** @public */
 declare type Booleanish = boolean | `${boolean}`;
 
+declare type Capture = {
+    [K in keyof HTMLElementEventMap as `capture:${K}`]?: boolean;
+};
+
 /**
  * The current captured scope during QRL invocation. This is used to provide the lexical scope for
  * QRL functions. It is used one time per invocation, synchronously, so it is safe to store it in
@@ -1155,6 +1215,11 @@ export declare interface CSSProperties extends CSS_2.Properties<string | number>
     [v: `--${string}`]: string | number | undefined;
 }
 
+declare class DeleteOperation {
+    target: Element | Text;
+    constructor(target: Element | Text);
+}
+
 declare interface DescriptorBase<T = unknown, B = unknown> extends BackRef {
     $flags$: number;
     $index$: number;
@@ -1194,7 +1259,7 @@ export declare interface DOMAttributes<EL extends Element> extends DOMAttributes
     class?: ClassList | Signal<ClassList> | undefined;
 }
 
-declare interface DOMAttributesBase<EL extends Element> extends QwikIntrinsicAttributes, PreventDefault, StopPropagation, RefAttr<EL> {
+declare interface DOMAttributesBase<EL extends Element> extends QwikIntrinsicAttributes, PreventDefault, StopPropagation, Capture, Passive, RefAttr<EL> {
     dangerouslySetInnerHTML?: string | undefined;
 }
 
@@ -1607,6 +1672,13 @@ export declare const inlinedQrl: <T>(symbol: T | null, symbolName: string, lexic
 /** @internal */
 export declare const inlinedQrlDEV: <T = any>(symbol: T, symbolName: string, opts: QRLDev, lexicalScopeCapture?: Readonly<unknown[]>) => QRL<T>;
 
+declare class InsertOrMoveOperation {
+    target: Element | Text;
+    parent: Element;
+    beforeTarget: Element | Text | null;
+    constructor(target: Element | Text, parent: Element, beforeTarget: Element | Text | null);
+}
+
 /**
  * These are the HTML tags with handlers allowing plain callbacks, to be used for the JSX interface
  *
@@ -1701,9 +1773,10 @@ export declare const _isTask: (value: any) => value is Task;
 
 /** @internal */
 declare interface IStreamHandler {
-    flush(): void;
+    flush(): ValueOrPromise<void>;
+    waitForPendingFlush(): ValueOrPromise<void>;
     streamBlockStart(): void;
-    streamBlockEnd(): void;
+    streamBlockEnd(): ValueOrPromise<void>;
 }
 
 /**
@@ -2103,6 +2176,10 @@ declare type PascalCaseName<T extends string> = T extends keyof LcEventNameMap ?
  */
 declare type PascalCaseNames = 'AnimationEnd' | 'AnimationIteration' | 'AnimationStart' | 'AuxClick' | 'BeforeToggle' | 'CanPlay' | 'CanPlayThrough' | 'CompositionEnd' | 'CompositionStart' | 'CompositionUpdate' | 'ContextMenu' | 'DblClick' | 'DragEnd' | 'DragEnter' | 'DragExit' | 'DragLeave' | 'DragOver' | 'DragStart' | 'DurationChange' | 'FocusIn' | 'FocusOut' | 'FullscreenChange' | 'FullscreenError' | 'GotPointerCapture' | 'KeyDown' | 'KeyPress' | 'KeyUp' | 'LoadedData' | 'LoadedMetadata' | 'LoadEnd' | 'LoadStart' | 'LostPointerCapture' | 'MouseDown' | 'MouseEnter' | 'MouseLeave' | 'MouseMove' | 'MouseOut' | 'MouseOver' | 'MouseUp' | 'PointerCancel' | 'PointerDown' | 'PointerEnter' | 'PointerLeave' | 'PointerMove' | 'PointerOut' | 'PointerOver' | 'PointerUp' | 'QIdle' | 'QInit' | 'QResume' | 'QSymbol' | 'QVisible' | 'QViewTransition' | 'RateChange' | 'RateChange' | 'SecurityPolicyViolation' | 'SelectionChange' | 'SelectStart' | 'TimeUpdate' | 'TouchCancel' | 'TouchEnd' | 'TouchMove' | 'TouchStart' | 'TransitionCancel' | 'TransitionEnd' | 'TransitionRun' | 'TransitionStart' | 'VisibilityChange' | 'VolumeChange';
 
+declare type Passive = {
+    [K in keyof HTMLElementEventMap as `passive:${K}`]?: boolean;
+};
+
 declare type PopoverTargetAction = 'hide' | 'show' | 'toggle';
 
 declare type PossibleEvents = Event | SimplifiedServerRequestEvent | typeof TaskEvent | typeof RenderEvent;
@@ -2672,7 +2749,10 @@ export declare type QwikWheelEvent<T = Element> = NativeWheelEvent;
 
 declare type QwikWindowEventMap = Omit<WindowEventHandlersEventMap, keyof QwikDocumentEventMap> & QwikDocumentEventMap;
 
-/** @public @deprecated not used */
+/**
+ * @deprecated Use `Readonly<Signal<T>>` instead.
+ * @public
+ */
 export declare interface ReadonlySignal<T = unknown> {
     readonly value: T;
 }
@@ -2701,6 +2781,11 @@ declare type RefFnInterface<EL> = {
  */
 export declare const _regSymbol: (symbol: any, hash: string) => any;
 
+declare class RemoveAllChildrenOperation {
+    target: Element;
+    constructor(target: Element);
+}
+
 /**
  * Remove an external projection from its parent and clean up.
  *
@@ -3036,6 +3121,15 @@ declare class SerializerSignalImpl<T, S> extends ComputedSignalImpl<T> {
  */
 export declare const SerializerSymbol: unique symbol;
 
+declare class SetAttributeOperation {
+    target: Element;
+    attrName: string;
+    attrValue: any;
+    scopedStyleIdPrefix: string | null;
+    isSvg: boolean;
+    constructor(target: Element, attrName: string, attrValue: any, scopedStyleIdPrefix: string | null, isSvg: boolean);
+}
+
 /** @internal */
 export declare function _setEvent(serializationCtx: SerializationContext, key: string, rawValue: unknown, hasMovedCaptures: boolean): string | null;
 
@@ -3061,6 +3155,12 @@ export declare const setPlatform: (plt: CorePlatform) => CorePlatform;
  */
 export declare function _setProjectionTarget(vnode: _VirtualVNode, targetElement: Element): void;
 
+declare class SetTextOperation {
+    target: Text;
+    text: string;
+    constructor(target: Text, text: string);
+}
+
 /** @internal */
 export declare abstract class _SharedContainer implements _Container {
     readonly $version$: string;
@@ -3512,7 +3612,8 @@ declare type StoreTarget = Record<string | symbol, any>;
 
 /** @internal */
 export declare interface StreamWriter {
-    write(chunk: string): void;
+    write(chunk: string): ValueOrPromise<void>;
+    waitForDrain?(): ValueOrPromise<void>;
 }
 
 /** @file Shared types */
@@ -4205,7 +4306,7 @@ export declare const useLexicalScope: <VARS extends any[]>() => VARS;
  * @public
  * @see `useOn`, `useOnWindow`, `useOnDocument`.
  */
-export declare const useOn: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>) => void;
+export declare const useOn: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>, options?: UseOnOptions) => void;
 
 /**
  * Register a listener on `document`.
@@ -4234,7 +4335,21 @@ export declare const useOn: <T extends KnownEventNames>(event: T | T[], eventQrl
  * });
  * ```
  */
-export declare const useOnDocument: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>) => void;
+export declare const useOnDocument: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>, options?: UseOnOptions) => void;
+
+/** @public */
+export declare type UseOnOptions = UseOnOptionsBase & ({
+    passive?: boolean;
+    preventdefault?: never;
+} | {
+    passive?: never;
+    preventdefault?: boolean;
+});
+
+declare interface UseOnOptionsBase {
+    capture?: boolean;
+    stoppropagation?: boolean;
+}
 
 /**
  * Register a listener on `window`.
@@ -4264,7 +4379,7 @@ export declare const useOnDocument: <T extends KnownEventNames>(event: T | T[],
  * });
  * ```
  */
-export declare const useOnWindow: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>) => void;
+export declare const useOnWindow: <T extends KnownEventNames>(event: T | T[], eventQrl: EventQRL<T>, options?: UseOnOptions) => void;
 
 /**
  * This method works like an async memoized function that runs whenever some tracked value changes
@@ -4661,7 +4776,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.31-dev+906321a
+ * 2.0.0-beta.34-dev+8b055bb
  *
  * @public
  */
@@ -4700,9 +4815,24 @@ export declare const _vnode_ensureElementInflated: (container: _Container, vnode
 /** @internal */
 export declare const _vnode_getAttrKeys: (container: _Container, vnode: _ElementVNode | _VirtualVNode) => string[];
 
+/** @internal */
+export declare const _vnode_getElementName: (vnode: _ElementVNode) => string;
+
 /** @internal */
 export declare const _vnode_getFirstChild: (vnode: _VNode) => _VNode | null;
 
+/** @internal */
+export declare const _vnode_getProp: <T = unknown>(vNode: _VNode, key: string, getObject: ((id: string) => unknown) | null) => T | null;
+
+/** @internal */
+export declare const _vnode_getVNodeForChildNode: (vNode: _ElementVNode, childElement: Element) => _ElementVNode;
+
+/** @internal */
+export declare const _vnode_insertBefore: (journal: _VNodeJournal, parent: _ElementVNode | _VirtualVNode, newChild: _VNode, insertBefore: _VNode | null) => void;
+
+/** @internal */
+export declare const _vnode_isElementVNode: (vNode: _VNode) => vNode is _ElementVNode;
+
 /** @internal */
 export declare const _vnode_isMaterialized: (vNode: _VNode) => boolean;
 
@@ -4712,6 +4842,15 @@ export declare const _vnode_isTextVNode: (vNode: _VNode) => vNode is _TextVNode;
 /** @internal */
 export declare const _vnode_isVirtualVNode: (vNode: _VNode) => vNode is _VirtualVNode;
 
+/** @internal */
+export declare const _vnode_newVirtual: () => _VirtualVNode;
+
+/** @internal */
+export declare const _vnode_remove: (journal: _VNodeJournal, vParent: _ElementVNode | _VirtualVNode, vToRemove: _VNode, removeDOM: boolean) => void;
+
+/** @internal */
+export declare const _vnode_setProp: (vNode: _VNode, key: string, value: unknown) => void;
+
 /** @internal */
 export declare function _vnode_toString(this: _VNode | null, depth?: number, offset?: string, materialize?: boolean, siblings?: boolean, colorize?: boolean, container?: _Container | null): string;
 
@@ -4799,6 +4938,11 @@ export declare const enum _VNodeFlags {
     HasTargetElement = 2048
 }
 
+/** @internal */
+export declare type _VNodeJournal = Array<VNodeOperation>;
+
+declare type VNodeOperation = DeleteOperation | RemoveAllChildrenOperation | SetTextOperation | InsertOrMoveOperation | SetAttributeOperation;
+
 /** @internal */
 export declare const _waitUntilRendered: (container: _Container) => Promise<void>;